diff --git a/.ci/README b/.ci/README
deleted file mode 100644
index 86b72afb83..0000000000
--- a/.ci/README
+++ /dev/null
@@ -1,3 +0,0 @@
-This directory contains support scripts for Travis and Appveyor continuous
-integration services.
-Travis is used to run tests on Linux and OSX, Appveyor runs tests on Windows.
diff --git a/.ci/appveyor/README b/.ci/appveyor/README
deleted file mode 100644
index 2e092a07c8..0000000000
--- a/.ci/appveyor/README
+++ /dev/null
@@ -1,2 +0,0 @@
-This directory contains support files for appveyor, a continuous integration
-service which runs tests on Windows on every push.
diff --git a/.ci/appveyor/download_exes.py b/.ci/appveyor/download_exes.py
deleted file mode 100755
index 37ebdfd147..0000000000
--- a/.ci/appveyor/download_exes.py
+++ /dev/null
@@ -1,148 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009 Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""
-Script which downloads exe and wheel files hosted on AppVeyor:
-https://ci.appveyor.com/project/giampaolo/psutil
-Copied and readapted from the original recipe of Ibarra Corretge'
-<saghul@gmail.com>:
-http://code.saghul.net/index.php/2015/09/09/
-"""
-
-from __future__ import print_function
-import argparse
-import errno
-import multiprocessing
-import os
-import requests
-import shutil
-import sys
-
-from concurrent.futures import ThreadPoolExecutor
-
-
-BASE_URL = 'https://ci.appveyor.com/api'
-PY_VERSIONS = ['2.7', '3.3', '3.4', '3.5']
-
-
-def term_supports_colors(file=sys.stdout):
-    try:
-        import curses
-        assert file.isatty()
-        curses.setupterm()
-        assert curses.tigetnum("colors") > 0
-    except Exception:
-        return False
-    else:
-        return True
-
-
-if term_supports_colors():
-    def hilite(s, ok=True, bold=False):
-        """Return an highlighted version of 'string'."""
-        attr = []
-        if ok is None:  # no color
-            pass
-        elif ok:   # green
-            attr.append('32')
-        else:   # red
-            attr.append('31')
-        if bold:
-            attr.append('1')
-        return '\x1b[%sm%s\x1b[0m' % (';'.join(attr), s)
-else:
-    def hilite(s, *a, **k):
-        return s
-
-
-def safe_makedirs(path):
-    try:
-        os.makedirs(path)
-    except OSError as err:
-        if err.errno == errno.EEXIST:
-            if not os.path.isdir(path):
-                raise
-        else:
-            raise
-
-
-def safe_rmtree(path):
-    def onerror(fun, path, excinfo):
-        exc = excinfo[1]
-        if exc.errno != errno.ENOENT:
-            raise
-
-    shutil.rmtree(path, onerror=onerror)
-
-
-def download_file(url):
-    local_fname = url.split('/')[-1]
-    local_fname = os.path.join('dist', local_fname)
-    print(local_fname)
-    safe_makedirs('dist')
-    r = requests.get(url, stream=True)
-    with open(local_fname, 'wb') as f:
-        for chunk in r.iter_content(chunk_size=1024):
-            if chunk:    # filter out keep-alive new chunks
-                f.write(chunk)
-    return local_fname
-
-
-def get_file_urls(options):
-    session = requests.Session()
-    data = session.get(
-        BASE_URL + '/projects/' + options.user + '/' + options.project)
-    data = data.json()
-
-    urls = []
-    for job in (job['jobId'] for job in data['build']['jobs']):
-        job_url = BASE_URL + '/buildjobs/' + job + '/artifacts'
-        data = session.get(job_url)
-        data = data.json()
-        for item in data:
-            file_url = job_url + '/' + item['fileName']
-            urls.append(file_url)
-    if not urls:
-        sys.exit("no artifacts found")
-    for url in sorted(urls, key=lambda x: os.path.basename(x)):
-        yield url
-
-
-def rename_27_wheels():
-    # See: https://github.com/giampaolo/psutil/issues/810
-    src = 'dist/psutil-4.3.0-cp27-cp27m-win32.whl'
-    dst = 'dist/psutil-4.3.0-cp27-none-win32.whl'
-    print("rename: %s\n        %s" % (src, dst))
-    os.rename(src, dst)
-    src = 'dist/psutil-4.3.0-cp27-cp27m-win_amd64.whl'
-    dst = 'dist/psutil-4.3.0-cp27-none-win_amd64.whl'
-    print("rename: %s\n        %s" % (src, dst))
-    os.rename(src, dst)
-
-
-def main(options):
-    files = []
-    safe_rmtree('dist')
-    with ThreadPoolExecutor(max_workers=multiprocessing.cpu_count()) as e:
-        for url in get_file_urls(options):
-            fut = e.submit(download_file, url)
-            files.append(fut.result())
-    # 2 exes (32 and 64 bit) and 2 wheels (32 and 64 bit) for each ver.
-    expected = len(PY_VERSIONS) * 4
-    got = len(files)
-    if expected != got:
-        print(hilite("expected %s files, got %s" % (expected, got), ok=False),
-              file=sys.stderr)
-    rename_27_wheels()
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(
-        description='AppVeyor artifact downloader')
-    parser.add_argument('--user', required=True)
-    parser.add_argument('--project', required=True)
-    args = parser.parse_args()
-    main(args)
diff --git a/.ci/appveyor/install.ps1 b/.ci/appveyor/install.ps1
deleted file mode 100644
index 3f05628255..0000000000
--- a/.ci/appveyor/install.ps1
+++ /dev/null
@@ -1,85 +0,0 @@
-# Sample script to install Python and pip under Windows
-# Authors: Olivier Grisel and Kyle Kastner
-# License: CC0 1.0 Universal: http://creativecommons.org/publicdomain/zero/1.0/
-
-$BASE_URL = "https://www.python.org/ftp/python/"
-$GET_PIP_URL = "https://bootstrap.pypa.io/get-pip.py"
-$GET_PIP_PATH = "C:\get-pip.py"
-
-
-function DownloadPython ($python_version, $platform_suffix) {
-    $webclient = New-Object System.Net.WebClient
-    $filename = "python-" + $python_version + $platform_suffix + ".msi"
-    $url = $BASE_URL + $python_version + "/" + $filename
-
-    $basedir = $pwd.Path + "\"
-    $filepath = $basedir + $filename
-    if (Test-Path $filename) {
-        Write-Host "Reusing" $filepath
-        return $filepath
-    }
-
-    # Download and retry up to 5 times in case of network transient errors.
-    Write-Host "Downloading" $filename "from" $url
-    $retry_attempts = 3
-    for($i=0; $i -lt $retry_attempts; $i++){
-        try {
-            $webclient.DownloadFile($url, $filepath)
-            break
-        }
-        Catch [Exception]{
-            Start-Sleep 1
-        }
-   }
-   Write-Host "File saved at" $filepath
-   return $filepath
-}
-
-
-function InstallPython ($python_version, $architecture, $python_home) {
-    Write-Host "Installing Python" $python_version "for" $architecture "bit architecture to" $python_home
-    if (Test-Path $python_home) {
-        Write-Host $python_home "already exists, skipping."
-        return $false
-    }
-    if ($architecture -eq "32") {
-        $platform_suffix = ""
-    } else {
-        $platform_suffix = ".amd64"
-    }
-    $filepath = DownloadPython $python_version $platform_suffix
-    Write-Host "Installing" $filepath "to" $python_home
-    $args = "/qn /i $filepath TARGETDIR=$python_home"
-    Write-Host "msiexec.exe" $args
-    Start-Process -FilePath "msiexec.exe" -ArgumentList $args -Wait -Passthru
-    Write-Host "Python $python_version ($architecture) installation complete"
-    return $true
-}
-
-
-function InstallPip ($python_home) {
-    $pip_path = $python_home + "/Scripts/pip.exe"
-    $python_path = $python_home + "/python.exe"
-    if (-not(Test-Path $pip_path)) {
-        Write-Host "Installing pip..."
-        $webclient = New-Object System.Net.WebClient
-        $webclient.DownloadFile($GET_PIP_URL, $GET_PIP_PATH)
-        Write-Host "Executing:" $python_path $GET_PIP_PATH
-        Start-Process -FilePath "$python_path" -ArgumentList "$GET_PIP_PATH" -Wait -Passthru
-    } else {
-        Write-Host "pip already installed."
-    }
-}
-
-function InstallPackage ($python_home, $pkg) {
-    $pip_path = $python_home + "/Scripts/pip.exe"
-    & $pip_path install $pkg
-}
-
-function main () {
-    InstallPython $env:PYTHON_VERSION $env:PYTHON_ARCH $env:PYTHON
-    InstallPip $env:PYTHON
-    InstallPackage $env:PYTHON wheel
-}
-
-main
diff --git a/.ci/appveyor/run_with_compiler.cmd b/.ci/appveyor/run_with_compiler.cmd
deleted file mode 100644
index 5da547c499..0000000000
--- a/.ci/appveyor/run_with_compiler.cmd
+++ /dev/null
@@ -1,88 +0,0 @@
-:: To build extensions for 64 bit Python 3, we need to configure environment
-:: variables to use the MSVC 2010 C++ compilers from GRMSDKX_EN_DVD.iso of:
-:: MS Windows SDK for Windows 7 and .NET Framework 4 (SDK v7.1)
-::
-:: To build extensions for 64 bit Python 2, we need to configure environment
-:: variables to use the MSVC 2008 C++ compilers from GRMSDKX_EN_DVD.iso of:
-:: MS Windows SDK for Windows 7 and .NET Framework 3.5 (SDK v7.0)
-::
-:: 32 bit builds, and 64-bit builds for 3.5 and beyond, do not require specific
-:: environment configurations.
-::
-:: Note: this script needs to be run with the /E:ON and /V:ON flags for the
-:: cmd interpreter, at least for (SDK v7.0)
-::
-:: More details at:
-:: https://github.com/cython/cython/wiki/64BitCythonExtensionsOnWindows
-:: http://stackoverflow.com/a/13751649/163740
-::
-:: Author: Olivier Grisel
-:: License: CC0 1.0 Universal: http://creativecommons.org/publicdomain/zero/1.0/
-::
-:: Notes about batch files for Python people:
-::
-:: Quotes in values are literally part of the values:
-::      SET FOO="bar"
-:: FOO is now five characters long: " b a r "
-:: If you don't want quotes, don't include them on the right-hand side.
-::
-:: The CALL lines at the end of this file look redundant, but if you move them
-:: outside of the IF clauses, they do not run properly in the SET_SDK_64==Y
-:: case, I don't know why.
-@ECHO OFF
-
-SET COMMAND_TO_RUN=%*
-SET WIN_SDK_ROOT=C:\Program Files\Microsoft SDKs\Windows
-SET WIN_WDK=c:\Program Files (x86)\Windows Kits\10\Include\wdf
-
-:: Extract the major and minor versions, and allow for the minor version to be
-:: more than 9.  This requires the version number to have two dots in it.
-SET MAJOR_PYTHON_VERSION=%PYTHON_VERSION:~0,1%
-IF "%PYTHON_VERSION:~3,1%" == "." (
-    SET MINOR_PYTHON_VERSION=%PYTHON_VERSION:~2,1%
-) ELSE (
-    SET MINOR_PYTHON_VERSION=%PYTHON_VERSION:~2,2%
-)
-
-:: Based on the Python version, determine what SDK version to use, and whether
-:: to set the SDK for 64-bit.
-IF %MAJOR_PYTHON_VERSION% == 2 (
-    SET WINDOWS_SDK_VERSION="v7.0"
-    SET SET_SDK_64=Y
-) ELSE (
-    IF %MAJOR_PYTHON_VERSION% == 3 (
-        SET WINDOWS_SDK_VERSION="v7.1"
-        IF %MINOR_PYTHON_VERSION% LEQ 4 (
-            SET SET_SDK_64=Y
-        ) ELSE (
-            SET SET_SDK_64=N
-            IF EXIST "%WIN_WDK%" (
-                :: See: https://connect.microsoft.com/VisualStudio/feedback/details/1610302/
-                REN "%WIN_WDK%" 0wdf
-            )
-        )
-    ) ELSE (
-        ECHO Unsupported Python version: "%MAJOR_PYTHON_VERSION%"
-        EXIT 1
-    )
-)
-
-IF %PYTHON_ARCH% == 64 (
-    IF %SET_SDK_64% == Y (
-        ECHO Configuring Windows SDK %WINDOWS_SDK_VERSION% for Python %MAJOR_PYTHON_VERSION% on a 64 bit architecture
-        SET DISTUTILS_USE_SDK=1
-        SET MSSdk=1
-        "%WIN_SDK_ROOT%\%WINDOWS_SDK_VERSION%\Setup\WindowsSdkVer.exe" -q -version:%WINDOWS_SDK_VERSION%
-        "%WIN_SDK_ROOT%\%WINDOWS_SDK_VERSION%\Bin\SetEnv.cmd" /x64 /release
-        ECHO Executing: %COMMAND_TO_RUN%
-        call %COMMAND_TO_RUN% || EXIT 1
-    ) ELSE (
-        ECHO Using default MSVC build environment for 64 bit architecture
-        ECHO Executing: %COMMAND_TO_RUN%
-        call %COMMAND_TO_RUN% || EXIT 1
-    )
-) ELSE (
-    ECHO Using default MSVC build environment for 32 bit architecture
-    ECHO Executing: %COMMAND_TO_RUN%
-    call %COMMAND_TO_RUN% || EXIT 1
-)
diff --git a/.ci/travis/README b/.ci/travis/README
deleted file mode 100644
index d9d5f65adf..0000000000
--- a/.ci/travis/README
+++ /dev/null
@@ -1,2 +0,0 @@
-This directory contains support files for Travis, a continuous integration
-service which runs tests on Linux and Windows on every push.
diff --git a/.ci/travis/install.sh b/.ci/travis/install.sh
deleted file mode 100755
index 5735b7a1da..0000000000
--- a/.ci/travis/install.sh
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/bin/bash
-
-set -e
-set -x
-
-uname -a
-python -c "import sys; print(sys.version)"
-
-if [[ "$(uname -s)" == 'Darwin' ]]; then
-    brew update || brew update
-    brew outdated pyenv || brew upgrade pyenv
-    brew install pyenv-virtualenv
-
-    if which pyenv > /dev/null; then
-        eval "$(pyenv init -)"
-    fi
-
-    case "${PYVER}" in
-        # py26)
-        #     pyenv install 2.6.9
-        #     pyenv virtualenv 2.6.9 psutil
-        #     ;;
-        py27)
-            pyenv install 2.7.10
-            pyenv virtualenv 2.7.10 psutil
-            ;;
-        # py32)
-        #     pyenv install 3.2.6
-        #     pyenv virtualenv 3.2.6 psutil
-        #     ;;
-        # py33)
-        #     pyenv install 3.3.6
-        #     pyenv virtualenv 3.3.6 psutil
-        #     ;;
-        py34)
-            pyenv install 3.4.3
-            pyenv virtualenv 3.4.3 psutil
-            ;;
-    esac
-    pyenv rehash
-    pyenv activate psutil
-fi
-
-if [[ $TRAVIS_PYTHON_VERSION == '2.6' ]] || [[ $PYVER == 'py26' ]]; then
-    pip install -U ipaddress unittest2 mock==1.0.1
-elif [[ $TRAVIS_PYTHON_VERSION == '2.7' ]] || [[ $PYVER == 'py27' ]]; then
-    pip install -U ipaddress mock
-elif [[ $TRAVIS_PYTHON_VERSION == '3.2' ]] || [[ $PYVER == 'py32' ]]; then
-    pip install -U ipaddress mock
-elif [[ $TRAVIS_PYTHON_VERSION == '3.3' ]] || [[ $PYVER == 'py33' ]]; then
-    pip install -U ipaddress
-fi
-
-pip install coverage coveralls flake8 pep8 setuptools
diff --git a/.ci/travis/run.sh b/.ci/travis/run.sh
deleted file mode 100755
index 4269f30ced..0000000000
--- a/.ci/travis/run.sh
+++ /dev/null
@@ -1,24 +0,0 @@
-#!/bin/bash
-
-set -e
-set -x
-
-if [[ "$(uname -s)" == 'Darwin' ]]; then
-    if which pyenv > /dev/null; then
-        eval "$(pyenv init -)"
-    fi
-    pyenv activate psutil
-fi
-
-python setup.py build
-python setup.py develop
-
-if [[ "$(uname -s)" != 'Darwin' ]]; then
-    coverage run psutil/tests/runner.py --include="psutil/*" --omit="test/*,*setup*"
-else
-    python psutil/tests/runner.py
-fi
-
-python psutil/tests/test_memory_leaks.py
-flake8
-pep8
diff --git a/.clang-format b/.clang-format
new file mode 100644
index 0000000000..3867ab07fa
--- /dev/null
+++ b/.clang-format
@@ -0,0 +1,68 @@
+# Re-adapted from: https://gist.github.com/JPHutchins/6ef33a52cc92fc4a71996b32b11724b4
+# clang-format doc: https://clang.llvm.org/docs/ClangFormatStyleOptions.html
+
+BasedOnStyle: Google
+AlignAfterOpenBracket: BlockIndent
+AlignTrailingComments: false
+AllowAllArgumentsOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortEnumsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: None
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: MultiLine
+  AfterEnum: false
+  AfterExternBlock: false
+  AfterFunction: false
+  AfterNamespace: false
+  AfterObjCDeclaration: false
+  AfterStruct: false
+  AfterUnion: false
+  BeforeCatch: false
+  BeforeElse: true
+  BeforeLambdaBody: false
+  BeforeWhile: false
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyNamespace: false
+  SplitEmptyRecord: false
+BitFieldColonSpacing: After
+BreakBeforeBinaryOperators: NonAssignment
+BreakBeforeBraces: Custom
+BreakStringLiterals: true
+ColumnLimit: 79
+DerivePointerAlignment: false
+IndentCaseBlocks: true
+IndentCaseLabels: true
+IndentWidth: 4
+MaxEmptyLinesToKeep: 2
+PointerAlignment: Right
+SortIncludes: false
+SpaceBeforeParens: ControlStatementsExceptControlMacros
+UseTab: Never
+
+# Force fun return type and fun definition to stay on 2 different lines:
+#    static int
+#    foo() {
+#       printf();
+#    }
+AlwaysBreakAfterReturnType: TopLevelDefinitions
+
+# Prevents:
+#    foo =
+#        Bar(...)
+PenaltyBreakAssignment: 400
+PenaltyBreakBeforeFirstCallParameter: 0
+
+# Handle macros with no `;` at EOL, so that they don't include the next line
+# into them.
+StatementMacros:
+  - Py_BEGIN_ALLOW_THREADS
+  - Py_END_ALLOW_THREADS
diff --git a/.coveragerc b/.coveragerc
deleted file mode 100644
index 6b6309b9f0..0000000000
--- a/.coveragerc
+++ /dev/null
@@ -1,33 +0,0 @@
-[report]
-
-include =
-    *psutil*
-
-omit =
-    psutil/tests/*
-    setup.py
-    psutil/_compat.py
-
-exclude_lines =
-    pragma: no cover
-    if PY3:
-    if __name__ == .__main__.:
-    if sys.platform.startswith
-    if _WINDOWS:
-    import enum
-    if enum is not None:
-    if enum is None:
-    if has_enums:
-    if LITTLE_ENDIAN:
-    enum.IntEnum
-    except ImportError:
-    raise NotImplementedError
-    if WINDOWS
-    if OSX
-    if BSD
-    if FREEBSD
-    if OPENBSD
-    if NETBSD
-    if SUNOS
-    if LINUX
-    if ppid_map is None:
diff --git a/.dprint.jsonc b/.dprint.jsonc
new file mode 100644
index 0000000000..43481e5794
--- /dev/null
+++ b/.dprint.jsonc
@@ -0,0 +1,60 @@
+{
+    "markdown": {
+        "lineWidth": 79,
+        "textWrap": "always",
+    },
+    "json": {
+        "indentWidth": 4,
+        "associations": [
+            "**/*.json",
+            "**/*.jsonc",
+        ],
+    },
+    "yaml": {
+        "printWidth": 120,
+        "associations": [
+            "**/*.yml",
+            "**/*.yaml",
+            "**/.clang-format",
+        ],
+    },
+    // js
+    "typescript": {
+        "indentWidth": 4,
+        "lineWidth": 79,
+        "quoteStyle": "preferDouble",
+        "useBraces": "always",
+        "singleBodyPosition": "nextLine",
+        "nextControlFlowPosition": "nextLine",
+        "operatorPosition": "sameLine",
+        "conditionalExpression.operatorPosition": "nextLine",
+        "functionExpression.spaceBeforeParentheses": true,
+        "trailingCommas": "onlyMultiLine",
+        "associations": [
+            "**/*.js",
+        ],
+    },
+    // css
+    "malva": {
+        "indentWidth": 4,
+        "printWidth": 79,
+        "associations": [
+            "**/*.css",
+        ],
+    },
+    "excludes": [
+        "**/*-lock.json",
+        "docs/_static/css/code.css",
+        "docs/_static/css/fonts.css",
+        ".github/ISSUE_TEMPLATE/bug.md",
+        ".github/ISSUE_TEMPLATE/enhancement.md",
+        ".github/PULL_REQUEST_TEMPLATE.md",
+    ],
+    "plugins": [
+        "https://plugins.dprint.dev/markdown-0.22.1.wasm",
+        "https://plugins.dprint.dev/json-0.23.0.wasm",
+        "https://plugins.dprint.dev/g-plane/pretty_yaml-v0.6.0.wasm",
+        "https://plugins.dprint.dev/typescript-0.96.1.wasm",
+        "https://plugins.dprint.dev/g-plane/malva-v0.16.0.wasm",
+    ],
+}
diff --git a/.git-pre-commit b/.git-pre-commit
deleted file mode 100755
index 99387729eb..0000000000
--- a/.git-pre-commit
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/usr/bin/env python
-
-# This gets executed on 'git commit' and rejects the commit in case the
-# submitted code does not pass validation.
-# Install it with "make install-git-hooks"
-
-import os
-import subprocess
-import sys
-
-
-def main():
-    out = subprocess.check_output("git diff --cached --name-only", shell=True)
-    files = [x for x in out.split(b'\n') if x.endswith(b'.py') and
-             os.path.exists(x)]
-
-    for path in files:
-        with open(path) as f:
-            data = f.read()
-
-        # pdb
-        if "pdb.set_trace" in data:
-            for lineno, line in enumerate(data.split('\n'), 1):
-                line = line.rstrip()
-                if "pdb.set_trace" in line:
-                    print("%s: %s" % (lineno, line))
-                    sys.exit(
-                        "commit aborted: you forgot a pdb in your python code")
-
-        # bare except clause
-        if "except:" in data:
-            for lineno, line in enumerate(data.split('\n'), 1):
-                line = line.rstrip()
-                if "except:" in line and not line.endswith("# NOQA"):
-                    print("%s: %s" % (lineno, line))
-                    sys.exit("commit aborted: bare except clause")
-
-    # flake8
-    failed = False
-    for path in files:
-        ret = subprocess.call("python -m flake8 %s" % path, shell=True)
-        if ret != 0:
-            failed = True
-    if failed:
-        sys.exit("commit aborted: python code is not flake8-compliant")
-
-main()
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000000..03c7c77c17
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1,9 @@
+# These are supported funding model platforms
+
+tidelift: "pypi/psutil"
+github: giampaolo
+patreon: # Replace with a single Patreon username
+open_collective: psutil
+ko_fi: # Replace with a single Ko-fi username
+community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+custom: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=A9ZS7PKKRM3S8
diff --git a/.github/ISSUE_TEMPLATE/bug.md b/.github/ISSUE_TEMPLATE/bug.md
new file mode 100644
index 0000000000..7db9f45e83
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug.md
@@ -0,0 +1,21 @@
+---
+name: Bug
+about: Report a bug
+title: "[OS] title"
+labels: 'bug'
+---
+
+## Summary
+
+- OS: { type-or-version }
+- Architecture: { 64bit, 32bit, ARM, PowerPC, s390 }
+- Psutil version: { pip3 show psutil }
+- Python version: { python3 -V }
+- Type: { core, doc, performance, scripts, tests, wheels, new-api, installation }
+
+## Description
+
+{{{
+  A clear explanation of the bug, including traceback message (if any). Please read the contributing guidelines before submit:
+  https://github.com/giampaolo/psutil/blob/master/CONTRIBUTING.md
+}}}
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 0000000000..39dc113f1a
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Ask a question
+    url: https://groups.google.com/g/psutil
+    about: Use this to ask for support
diff --git a/.github/ISSUE_TEMPLATE/enhancement.md b/.github/ISSUE_TEMPLATE/enhancement.md
new file mode 100644
index 0000000000..32b20a93fe
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/enhancement.md
@@ -0,0 +1,18 @@
+---
+name: Enhancement
+about: Propose an enhancement
+labels: 'enhancement'
+title: "[OS] title"
+---
+
+## Summary
+
+- OS: { type-or-version }
+- Type: { core, doc, performance, scripts, tests, wheels, new-api }
+
+## Description
+
+{{{
+  A clear explanation of your proposal. Please read the contributing guidelines before submit:
+  https://github.com/giampaolo/psutil/blob/master/CONTRIBUTING.md
+}}}
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 0000000000..dd506cb9fb
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,13 @@
+## Summary
+
+- OS: { type-or-version }
+- Bug fix: { yes/no }
+- Type: { core, doc, performance, scripts, tests, wheels, new-api }
+- Fixes: { comma-separated list of issues fixed by this PR, if any }
+
+## Description
+
+{{{
+  A clear explanation of your bugfix or enhancement. Please read the contributing guidelines before submit:
+  https://github.com/giampaolo/psutil/blob/master/CONTRIBUTING.md
+}}}
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000000..debc712d8c
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,11 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+    # Bundle all action bumps into one PR instead of one each.
+    groups:
+      github-actions:
+        patterns:
+          - "*"
diff --git a/.github/no-response.yml b/.github/no-response.yml
new file mode 100644
index 0000000000..56457a28d0
--- /dev/null
+++ b/.github/no-response.yml
@@ -0,0 +1,10 @@
+# Configuration for probot-no-response: https://github.com/probot/no-response
+
+# Number of days of inactivity before an issue is closed for lack of response
+daysUntilClose: 14
+# Label requiring a response
+responseRequiredLabel: need-more-info
+# Comment to post when closing an Issue for lack of response.
+# Set to `false` to disable
+closeComment: >
+  This issue has been automatically closed because there has been no response for more information from the original author. Please reach out if you have or find the answers requested so that this can be investigated further.
diff --git a/.github/placeholder b/.github/placeholder
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/.github/workflows/bsd.yml b/.github/workflows/bsd.yml
new file mode 100644
index 0000000000..036cd1d5f9
--- /dev/null
+++ b/.github/workflows/bsd.yml
@@ -0,0 +1,80 @@
+# Execute tests on *BSD platforms. Does not produce wheels.
+# Useful URLs:
+# https://github.com/vmactions/freebsd-vm
+# https://github.com/vmactions/openbsd-vm
+# https://github.com/vmactions/netbsd-vm
+
+on:
+  workflow_dispatch:
+  push:
+    # only run this job if the following files are modified
+    paths: &bsd_paths
+      - ".github/workflows/bsd.yml"
+      - "Makefile"
+      - "psutil/__init__.py"
+      - "psutil/_common.py"
+      - "psutil/_ntuples.py"
+      - "psutil/_psbsd.py"
+      - "psutil/_psposix.py"
+      - "psutil/_psutil_bsd.c"
+      - "psutil/arch/*bsd*/**"
+      - "psutil/arch/*posix*/**"
+      - "psutil/arch/all/**"
+      - "pyproject.toml"
+      - "scripts/internal/install-pydeps.sh"
+      - "scripts/internal/install-sysdeps.sh"
+      - "setup.py"
+      - "tests/**"
+  pull_request:
+    paths: *bsd_paths
+name: bsd
+concurrency:
+  group: ${{ github.ref }}-${{ github.workflow }}-${{ github.event_name }}-${{ github.ref == format('refs/heads/{0}', github.event.repository.default_branch) && github.sha || '' }}
+  cancel-in-progress: true
+jobs:
+  freebsd:
+    # if: false
+    # Skip same-repo PR runs: the push event already covers them.
+    if: &skip_same_repo_pr github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+      - name: Run tests
+        uses: vmactions/freebsd-vm@v1
+        with:
+          release: "14.3"
+          usesh: true
+          run: |
+            make ci-test
+            make test-memleaks-parallel
+
+  openbsd:
+    # if: false
+    if: *skip_same_repo_pr
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+      - name: Run tests
+        uses: vmactions/openbsd-vm@v1
+        with:
+          usesh: true
+          run: |
+            make ci-test
+            make test-memleaks-parallel
+
+  netbsd:
+    # if: false
+    if: *skip_same_repo_pr
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+      - name: Run tests
+        uses: vmactions/netbsd-vm@v1
+        with:
+          usesh: true
+          run: |
+            make ci-test
+            make test-memleaks-parallel
diff --git a/.github/workflows/changelog_bot.py b/.github/workflows/changelog_bot.py
new file mode 100644
index 0000000000..dae6bff73d
--- /dev/null
+++ b/.github/workflows/changelog_bot.py
@@ -0,0 +1,1188 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Activated when commenting "/changelog" on a PR.
+
+This bot will ask Claude to add an entry into docs/changelog.rst based
+on the changes introduced in the PR, and also add an entry to
+docs/credits.rst.
+
+Requires:
+
+- A subscription to Claude API
+- The "ANTHROPIC_API_KEY" environment variable to be set via GitHub
+  web interface (Settings -> Secrets & Variables)
+"""
+
+import argparse
+import datetime
+import json
+import os
+import re
+import sys
+import urllib.error
+import urllib.request
+
+# CLI args
+PR_NUMBER = None
+REPO = None
+TOKEN = None
+COMMENT_FILE = None
+ERROR_FILE = None
+
+CHANGELOG_FILE = "docs/changelog.rst"
+CREDITS_FILE = "docs/credits.rst"
+MODEL = "claude-sonnet-5"
+MAX_DIFF_CHARS = 20_000
+COMPARE_MAX_FILES = 300
+MAX_TOKENS = 4096  # thinking tokens count against this too
+HTTP_TIMEOUT = 30
+
+PROMPT = """\
+You are helping maintain the official changelog for psutil, a Python
+system monitoring library.
+
+Your task is to decide how ONE pull request should be recorded in the
+changelog, and to produce at most ONE entry.
+
+PR #{number}: {title}
+Author: @{author} (full name: {author_name})
+
+Description:
+{body}
+
+Diff:
+{diff}
+
+CURRENT CHANGELOG BLOCK
+
+This is the top (in-development) version block of docs/changelog.rst.
+Base your decision on what it already contains:
+
+----- BEGIN BLOCK -----
+{block}
+----- END BLOCK -----
+
+DECIDING THE ACTION
+
+- insert: the block has no entry for this change. Provide "section"
+  and "entry_text".
+- amend: the block already has an entry for this issue, or for the
+  same user-visible change, and this PR extends or corrects it.
+  Provide "amend_gh" (the issue number of that entry) and "entry_text",
+  a full replacement entry that keeps the same :gh:`N` reference and
+  now covers both changes.
+- skip: the block already fully describes this PR. Provide
+  "skip_reason".
+
+The script places the text and handles ordering, blank lines, badge
+labels and the credits file. It rejects an insert whose issue already
+has an entry, so pick amend in that case.
+
+ISSUE NUMBER SELECTION
+
+The entry should reference the GitHub ISSUE number when one exists,
+not the pull request number.
+
+1. If the PR title or description references an issue such as
+   "Fixes #1234", "Closes #1234", "Refs #1234" or "#1234", use that
+   number.
+2. If multiple issues are referenced, choose the primary one.
+3. If no issue reference exists, fall back to the PR number.
+
+STYLE
+
+- Write concise entries (1-2 sentences max).
+- Focus on the user-visible behavior change.
+- Avoid implementation details unless relevant.
+- Prefer imperative verbs: "fix", "add", "improve", "avoid", "detect".
+- Do not repeat the PR title verbatim.
+- Do not mention "PR" in the text.
+- Wrap lines around ~79 characters.
+
+CLASSIFICATION
+
+Choose the section for an insert, from the vocabulary the changelog
+uses (listed in the order sections appear in a release):
+
+- New APIs: a new function, argument or field, or an existing one now
+  working where it didn't.
+- New platforms: support for a new OS, architecture or interpreter.
+- API changes: an existing API changed, was deprecated or was removed.
+- Performance: something got faster.
+- Build and packaging: wheels, the sdist, what gets installed.
+- Documentation: docs/ only.
+- Internals: psutil's own machinery: CI, tests, scripts, debug output.
+  Nothing user-facing.
+- Dropped support: a platform, OS or Python version is no longer
+  supported.
+- Bug fixes: crashes, wrong results, leaks, build failures.
+
+PLATFORM TAGS
+
+If the change is platform specific, add tags immediately after the
+issue reference, e.g.:
+
+:gh:`1234`, [Linux]:
+:gh:`1234`, [macOS], [BSD]:
+
+Known tags: [Linux], [Windows], [macOS], [FreeBSD], [NetBSD],
+[OpenBSD], [SunOS], [AIX], [BSD], [UNIX], [PyPy]. Use the specific OS
+when one is named; [BSD] only when the change is about the BSDs as a
+family, [UNIX] for shared POSIX behavior where no single OS fits.
+Only add platform tags if the change clearly affects specific OSes.
+The script checks every tag against the issue's labels on the bug
+tracker and rejects the entry when a tag isn't backed by one.
+
+BADGE LABELS
+
+Do not write :label:`...` badges (critical, build-fail, memleak,
+breaking). The script derives them from the issue's labels on the
+tracker and adds them to the entry itself.
+
+RST FORMATTING
+
+Use Sphinx roles for psutil APIs: :func:`function_name`,
+:meth:`Class.method`, :class:`ClassName`, :exc:`ExceptionName`. C
+functions or identifiers use double backticks: ``function_name()``.
+
+ENTRY FORMAT
+
+An entry is a single bullet:
+
+- :gh:`ISSUE_NUMBER`: <description>.
+
+Or with platform tags:
+
+- :gh:`ISSUE_NUMBER`, [Linux]: <description>.
+
+Continuation lines are indented by two spaces. End with a period.
+
+EXAMPLES
+
+- :gh:`2708`, [macOS]: :meth:`Process.cmdline` and
+  :meth:`Process.environ` may fail with ``OSError: [Errno 0]``. They
+  now raise :exc:`AccessDenied` instead.
+
+- :gh:`2674`, [Windows]: :func:`disk_usage` could truncate values on
+  32-bit systems for drives larger than 4GB.
+"""
+
+SUBMIT_TOOL = {
+    "name": "submit",
+    "description": "Submit the changelog decision for this PR.",
+    "input_schema": {
+        "type": "object",
+        "additionalProperties": False,
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["insert", "amend", "skip"],
+                "description": (
+                    "insert: no entry for this change exists yet. amend:"
+                    " the block already has an entry for this issue that"
+                    " should be extended/corrected. skip: the block already"
+                    " fully covers this PR."
+                ),
+            },
+            "section": {
+                "type": ["string", "null"],
+                "enum": [
+                    "New APIs",
+                    "New platforms",
+                    "API changes",
+                    "Performance",
+                    "Build and packaging",
+                    "Documentation",
+                    "Internals",
+                    "Dropped support",
+                    "Bug fixes",
+                    None,
+                ],
+                "description": "Required for insert.",
+            },
+            "entry_text": {
+                "type": ["string", "null"],
+                "description": (
+                    "Full RST entry, wrapped at ~79 cols. Required for"
+                    " insert/amend. For amend, the complete replacement"
+                    " entry (must keep the same :gh:`N` reference)."
+                ),
+            },
+            "amend_gh": {
+                "type": ["integer", "null"],
+                "description": (
+                    "Issue number of the existing entry to replace."
+                    " Required for amend."
+                ),
+            },
+            "skip_reason": {
+                "type": ["string", "null"],
+                "description": "One sentence. Required for skip.",
+            },
+        },
+        "required": [
+            "action",
+            "section",
+            "entry_text",
+            "amend_gh",
+            "skip_reason",
+        ],
+    },
+}
+
+
+def gh_request(path, accept="application/vnd.github+json"):
+    url = f"https://api.github.com{path}"
+    req = urllib.request.Request(
+        url,
+        headers={
+            "Authorization": f"Bearer {TOKEN}",
+            "Accept": accept,
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT) as resp:
+            return resp.read()
+    except urllib.error.HTTPError as err:
+        # Surface GitHub's error body; a bare "HTTP Error 404" hides it.
+        body = err.read().decode("utf-8", errors="replace")
+        sys.exit(f"GitHub API {err.code} for {path}: {body}")
+
+
+def fetch_pr_metadata():
+    pr = json.loads(gh_request(f"/repos/{REPO}/pulls/{PR_NUMBER}"))
+    author = pr["user"]["login"]
+    # Fetch the user profile to get the full name.
+    user = json.loads(gh_request(f"/users/{author}"))
+    author_name = user.get("name") or author
+    return {
+        "number": pr["number"],
+        "title": pr["title"],
+        "body": pr.get("body") or "",
+        "author": author,
+        "author_name": author_name,
+        "head_sha": pr["head"]["sha"],
+    }
+
+
+def fetch_pr_diff():
+    return gh_request(
+        f"/repos/{REPO}/pulls/{PR_NUMBER}",
+        accept="application/vnd.github.v3.diff",
+    ).decode("utf-8", errors="replace")
+
+
+def stale_reason(head_sha):
+    """Why the branch is too old to receive an entry, if it is.
+    We commit on top of the PR head, so an entry written against a
+    stale copy of the docs makes the PR unmergeable.
+    """
+    data = json.loads(gh_request(f"/repos/{REPO}/compare/{head_sha}...master"))
+    files = [f["filename"] for f in data.get("files", [])]
+    stale = [f for f in (CHANGELOG_FILE, CREDITS_FILE) if f in files]
+    if stale:
+        return f"master has moved on: {' and '.join(stale)} changed"
+    if len(files) >= COMPARE_MAX_FILES:
+        return "master's diff is too big to tell whether the docs changed"
+    return None
+
+
+def ask_claude(pr, diff, block):
+    prompt = PROMPT.format(
+        number=pr["number"],
+        title=pr["title"],
+        author=pr["author"],
+        author_name=pr["author_name"],
+        body=pr["body"],
+        diff=diff[:MAX_DIFF_CHARS],
+        block=block,
+    )
+    import anthropic
+
+    api_key = os.environ.get("ANTHROPIC_API_KEY", "").strip()
+    if not api_key:
+        sys.exit("ANTHROPIC_API_KEY is not set")
+    client = anthropic.Anthropic(api_key=api_key)
+    message = client.messages.create(
+        model=MODEL,
+        max_tokens=MAX_TOKENS,
+        thinking={"type": "adaptive"},
+        output_config={"effort": "low"},
+        tools=[SUBMIT_TOOL],
+        tool_choice={"type": "tool", "name": "submit"},
+        messages=[{"role": "user", "content": prompt}],
+    )
+    if message.stop_reason == "max_tokens":
+        sys.exit("Claude response was truncated (raise MAX_TOKENS)")
+    tool_use = next((b for b in message.content if b.type == "tool_use"), None)
+    if tool_use is None:
+        sys.exit(
+            f"Claude returned no tool call (stop_reason={message.stop_reason})"
+        )
+    return tool_use.input
+
+
+VERSION_RE = re.compile(r"^(\d+\.\d+\.\d+|X\.X\.X)\b")
+
+# The section vocabulary, in the order sections appear in a release.
+SECTIONS = (
+    "New APIs",
+    "New platforms",
+    "API changes",
+    "Performance",
+    "Build and packaging",
+    "Documentation",
+    "Internals",
+    "Dropped support",
+    "Bug fixes",
+)
+
+# Badge labels: (tracker label, badge name), in the order badges
+# appear in an entry and entries sort within a section.
+BADGES = (
+    ("critical", "critical"),
+    ("build-fail", "build-fail"),
+    ("memleak", "memleak"),
+    ("compatibility", "breaking"),
+)
+
+# Platform tags accepted in an entry, with the tracker label that must
+# back each one.
+TAG2LABEL = {
+    "Linux": "linux",
+    "Windows": "windows",
+    "macOS": "macos",
+    "FreeBSD": "freebsd",
+    "NetBSD": "netbsd",
+    "OpenBSD": "openbsd",
+    "SunOS": "sunos",
+    "AIX": "aix",
+    "BSD": "bsd",
+    "UNIX": "unix",
+    "POSIX": "unix",
+    "PyPy": "pypy",
+}
+NAMED_BSD = {"freebsd", "netbsd", "openbsd"}
+POSIXY = NAMED_BSD | {"linux", "macos", "sunos", "aix", "bsd", "unix"}
+
+ENTRY_PREFIX_RE = re.compile(
+    r"^- (?::gh:`\d+`, )*:gh:`\d+`((?:,? \[[^\]]+\])*)"
+)
+
+
+class ValidationError(Exception):
+    """The LLM decision doesn't match the file state; fail loud."""
+
+
+def find_dev_block(lines):
+    """Locate the top version block in a list of changelog lines.
+
+    Returns (start, end, header, is_dev): start/end are line indices
+    (end points at the next version header or len(lines)); is_dev is
+    False when the top block is an already-released, dated version.
+    """
+    start = next(
+        (i for i, ln in enumerate(lines) if VERSION_RE.match(ln)), None
+    )
+    if start is None:
+        sys.exit(f"No version header found in {CHANGELOG_FILE}")
+    end = next(
+        (
+            i
+            for i in range(start + 1, len(lines))
+            if VERSION_RE.match(lines[i])
+        ),
+        len(lines),
+    )
+    header = lines[start]
+    is_dev = "(IN DEVELOPMENT)" in header or header.startswith("X.X.X")
+    return start, end, header, is_dev
+
+
+def changelog_context(text):
+    """Return only the top version block, to feed to the LLM."""
+    lines = text.splitlines()
+    start, end, _, _ = find_dev_block(lines)
+    return "\n".join(lines[start:end]).rstrip() + "\n"
+
+
+def section_header_idx(block, section):
+    header = f"**{section}**"
+    return next(
+        (i for i, ln in enumerate(block) if ln.strip() == header), None
+    )
+
+
+def next_header_idx(block, from_idx):
+    """Index of the next ``**...**`` header after from_idx, else end."""
+    return next(
+        (
+            i
+            for i in range(from_idx + 1, len(block))
+            if block[i].startswith("**")
+        ),
+        len(block),
+    )
+
+
+def section_rank(header_name):
+    """Canonical position of a section header, or None.
+
+    Per-platform variants ("Bug fixes: Linux") rank as their base.
+    """
+    base = header_name.split(":")[0].strip()
+    return SECTIONS.index(base) if base in SECTIONS else None
+
+
+def create_section(block, section):
+    """Insert an empty ``**section**`` header keeping the canonical
+    section order.
+    """
+    rank = SECTIONS.index(section)
+    new = [f"**{section}**", ""]
+    for i, ln in enumerate(block):
+        if ln.startswith("**") and ln.rstrip().endswith("**"):
+            got = section_rank(ln.strip().strip("*"))
+            if got is not None and got > rank:
+                return block[:i] + [*new, ""] + block[i:]
+    insert_at = len(block)
+    while insert_at > 0 and not block[insert_at - 1].strip():
+        insert_at -= 1
+    return block[:insert_at] + ["", *new] + block[insert_at:]
+
+
+def entry_number(line):
+    m = re.match(r"- :gh:`(\d+)`", line)
+    return int(m.group(1)) if m else None
+
+
+def entry_tier(line):
+    """Sort tier of an entry: badge-labelled ones first, in badge
+    order, plain ones last.
+    """
+    for i, (_, name) in enumerate(BADGES):
+        if f":label:`{name}`" in line:
+            return i
+    return len(BADGES)
+
+
+def entry_tags(entry_text):
+    """The [Platform] tags in an entry's prefix (not its prose)."""
+    m = ENTRY_PREFIX_RE.match(entry_text)
+    if not m:
+        return []
+    return re.findall(r"\[([^\]]+)\]", m.group(1))
+
+
+def check_platform_tags(entry_text, issue_labels):
+    """Every [Tag] must be backed by a label on the issue, so the
+    changelog never asserts a platform the tracker doesn't know
+    about. The family tags are backed by any label of the family.
+    """
+    have = set(issue_labels)
+    for tag in entry_tags(entry_text):
+        label = TAG2LABEL.get(tag)
+        if label is None:
+            raise ValidationError(f"unknown platform tag [{tag}]")
+        if label in have:
+            continue
+        if label == "bsd" and have & NAMED_BSD:
+            continue
+        if label == "unix" and have & POSIXY:
+            continue
+        raise ValidationError(
+            f"[{tag}] is not backed by a {label!r} label on the issue"
+            f" (it has: {sorted(have) or 'none'})"
+        )
+
+
+def rst_words(text):
+    """Split on spaces, except inside a `...` or ``...`` span."""
+    words, cur, span = [], "", 0
+    i = 0
+    while i < len(text):
+        if text[i] == "`":
+            run = 1
+            while i + run < len(text) and text[i + run] == "`":
+                run += 1
+            cur += "`" * run
+            i += run
+            if span == 0:
+                span = run
+            elif run >= span:
+                span = 0
+            continue
+        if text[i] == " " and span == 0:
+            if cur:
+                words.append(cur)
+            cur = ""
+        else:
+            cur += text[i]
+        i += 1
+    if cur:
+        words.append(cur)
+    return words
+
+
+def wrap_entry(flat, width=79):
+    """Wrap a one-line entry into '- ' + two-space continuations."""
+    out, cur = [], ""
+    for word in rst_words(flat):
+        trial = f"{cur} {word}" if cur else ("  " + word if out else word)
+        if len(trial) > width and cur:
+            out.append(cur)
+            cur = "  " + word
+        else:
+            cur = trial
+    if cur:
+        out.append(cur)
+    return "\n".join(out)
+
+
+def inject_labels(entry_text, issue_labels):
+    """Add the :label:`...` badges the issue's labels call for, then
+    rewrap. The model never writes badges itself.
+    """
+    flat = " ".join(ln.strip() for ln in entry_text.splitlines())
+    badges = [name for lab, name in BADGES if lab in issue_labels]
+    if badges:
+        m = ENTRY_PREFIX_RE.match(flat)
+        roles = ", ".join(f":label:`{b}`" for b in badges)
+        flat = f"{flat[: m.end()]}, {roles}{flat[m.end():]}"
+    return wrap_entry(flat)
+
+
+def insert_in_section(block, section, entry_lines):
+    hdr = section_header_idx(block, section)
+    if hdr is None:
+        block = create_section(block, section)
+        hdr = section_header_idx(block, section)
+    boundary = next_header_idx(block, hdr)
+    # End of the section's content, before any trailing blank lines.
+    end = boundary
+    while end > hdr + 2 and not block[end - 1].strip():
+        end -= 1
+    # Start of the last contiguous run of entries. A blank line or a
+    # pseudo-header (e.g. "New APIs:") ends a run, so we stay out of
+    # earlier groups.
+    run_start = end
+    while run_start > hdr + 2:
+        if not block[run_start - 1].startswith(("- ", "  ")):
+            break
+        run_start -= 1
+    # Insert after the last entry that sorts before ours: labelled
+    # entries lead (critical, build-fail, memleak, breaking), plain
+    # ones follow, numerically within each tier. Robust to a leading
+    # out-of-order entry (we compare keys, not positions).
+    gh = entry_number(entry_lines[0])
+    tier = entry_tier(entry_lines[0])
+    insert_at = run_start
+    i = run_start
+    while i < end:
+        num = entry_number(block[i])
+        j = i + 1
+        while j < end and block[j].startswith("  "):  # skip continuations
+            j += 1
+        if block[i].startswith("- "):
+            t = entry_tier(block[i])
+            if t < tier or (
+                t == tier and num is not None and gh is not None and num < gh
+            ):
+                insert_at = j
+        i = j
+    return block[:insert_at] + list(entry_lines) + block[insert_at:]
+
+
+def check_entry_ordered(text, gh):
+    """Verify the new :gh:`gh` entry respects its run's ordering:
+    labelled entries first in badge order, then plain ones, numeric
+    within each tier. Raises ValidationError otherwise. A blank line
+    or a pseudo-header ends a run, so an earlier group doesn't count.
+    """
+    block = changelog_context(text).splitlines()
+    idx = next(
+        (i for i, ln in enumerate(block) if ln.startswith(f"- :gh:`{gh}`")),
+        None,
+    )
+    if idx is None:
+        return
+    mine = (entry_tier(block[idx]), gh)
+
+    def run_neighbor(indices):
+        for i in indices:
+            ln = block[i]
+            if ln.startswith("- "):
+                return (entry_tier(ln), entry_number(ln))
+            if not ln.startswith("  "):  # blank / pseudo-header
+                return None
+        return None
+
+    def sorts_after(a, b):
+        if a[0] != b[0]:
+            return a[0] > b[0]
+        if a[1] is None or b[1] is None:
+            return False
+        return a[1] > b[1]
+
+    prev = run_neighbor(range(idx - 1, -1, -1))
+    nxt = run_neighbor(range(idx + 1, len(block)))
+    if prev is not None and sorts_after(prev, mine):
+        raise ValidationError(
+            f"changelog: :gh:`{gh}` is out of order (after {prev})"
+        )
+    if nxt is not None and sorts_after(mine, nxt):
+        raise ValidationError(
+            f"changelog: :gh:`{gh}` is out of order (before {nxt})"
+        )
+
+
+def prepend_dev_block(lines, start):
+    header = "X.X.X (IN DEVELOPMENT)"
+    new = [header, "^" * len(header), ""]
+    lines = lines[:start] + new + lines[start:]
+    return lines, start, start + len(new)
+
+
+def insert_entry(text, section, entry_text):
+    """Append an entry to a section, creating a dev block if needed."""
+    lines = text.splitlines()
+    start, end, _, is_dev = find_dev_block(lines)
+    if not is_dev:
+        lines, start, end = prepend_dev_block(lines, start)
+    block = lines[start:end]
+    block = insert_in_section(block, section, entry_text.splitlines())
+    lines[start:end] = block
+    return "\n".join(lines) + "\n"
+
+
+def find_entry_span(block, gh):
+    """Return (start, end) of the entry for :gh:`gh` within block lines.
+
+    The span covers the ``- :gh:`gh``` line plus its continuation
+    lines. Returns None if there's no such entry.
+    """
+    prefix = f"- :gh:`{gh}`"
+    start = next(
+        (i for i, ln in enumerate(block) if ln.startswith(prefix)), None
+    )
+    if start is None:
+        return None
+    end = start + 1
+    while end < len(block):
+        ln = block[end]
+        if (
+            ln.startswith(("- ", "**"))
+            or not ln.strip()
+            or VERSION_RE.match(ln)
+        ):
+            break
+        end += 1
+    return start, end
+
+
+def amend_entry(text, gh, entry_text):
+    """Replace the dev-block entry for :gh:`gh` with entry_text."""
+    lines = text.splitlines()
+    start, end, _, _ = find_dev_block(lines)
+    block = lines[start:end]
+    prefix = f"- :gh:`{gh}`"
+    matches = [i for i, ln in enumerate(block) if ln.startswith(prefix)]
+    if len(matches) != 1:
+        raise ValidationError(
+            f"expected one entry for :gh:`{gh}` to amend, found {len(matches)}"
+        )
+    span_start, span_end = find_entry_span(block, gh)
+    block[span_start:span_end] = entry_text.splitlines()
+    lines[start:end] = block
+    return "\n".join(lines) + "\n"
+
+
+ENTRY_RE = re.compile(
+    r"^- :gh:`(\d+)`(?:,? \[[^\]]+\])*(?:, :label:`[a-z-]+`)*:\s"
+)
+
+
+def referenced_issues(title, body, pr_number):
+    """Issue numbers this PR may legitimately reference."""
+    text = f"{title}\n{body}"
+    pat = r"#(\d+)|GH-(\d+)|/(?:issues|pull)/(\d+)"
+    refs = {int(n) for group in re.findall(pat, text) for n in group if n}
+    refs.add(pr_number)
+    return refs
+
+
+def validate_entry_text(entry_text):
+    """Check an entry's RST shape; return its issue number."""
+    entry_lines = entry_text.splitlines()
+    m = ENTRY_RE.match(entry_lines[0]) if entry_lines else None
+    if not m:
+        raise ValidationError(
+            f"entry must start with '- :gh:`N`...: ', got: {entry_text!r}"
+        )
+    if not entry_text.rstrip().endswith("."):
+        raise ValidationError("entry must end with a period")
+    if entry_text.count("``") % 2 or entry_text.count("`") % 2:
+        raise ValidationError("entry has unbalanced backticks")
+    for ln in entry_lines[1:]:
+        if ln.startswith("- "):
+            raise ValidationError("entry must be a single bullet")
+        if ln.strip() and not ln.startswith("  "):
+            raise ValidationError("continuation lines must be indented")
+    return int(m.group(1))
+
+
+BUGFIX_FAMILY = {
+    "linux": "Linux",
+    "windows": "Windows",
+    "macos": "macOS",
+    "freebsd": "BSD",
+    "netbsd": "BSD",
+    "openbsd": "BSD",
+    "bsd": "BSD",
+    "sunos": "UNIX",
+    "aix": "UNIX",
+    "unix": "UNIX",
+}
+
+
+def bugfix_section(text, entry_text):
+    """When the dev block splits Bug fixes per platform (8.0.0 does),
+    route the entry by its platform tags. Otherwise plain "Bug fixes".
+    """
+    block = changelog_context(text).splitlines()
+    subs = {
+        ln.strip().strip("*")
+        for ln in block
+        if ln.strip().startswith("**Bug fixes:")
+    }
+    if not subs:
+        return "Bug fixes"
+    labels = {TAG2LABEL[t] for t in entry_tags(entry_text)}
+    names = {BUGFIX_FAMILY.get(lab) for lab in labels} - {None}
+    name = names.pop() if len(names) == 1 else "cross-platform"
+    for candidate in (f"Bug fixes: {name}", "Bug fixes: cross-platform"):
+        if candidate in subs:
+            return candidate
+    return "Bug fixes"
+
+
+def apply_changelog_decision(text, decision, allowed_issues):
+    """Validate and apply the LLM decision to the changelog text.
+
+    Returns (new_text, status, gh) where status is "inserted",
+    "amended" or "skipped" and gh is the issue number touched (None on
+    skip). Raises ValidationError on any mismatch, so nothing is
+    written on bad input.
+    """
+    action = decision["action"]
+    if action == "skip":
+        return text, "skipped", None
+
+    entry_text = decision.get("entry_text")
+    if not entry_text:
+        raise ValidationError(f"{action} requires entry_text")
+    gh = validate_entry_text(entry_text)
+    _, _, _, is_dev = find_dev_block(text.splitlines())
+
+    if action == "insert":
+        # An insert must reference an issue the PR actually touches; an
+        # amend is authorized by the entry already existing in the block
+        # (checked in amend_entry), so the PR need not restate it.
+        if gh not in allowed_issues:
+            raise ValidationError(
+                f":gh:`{gh}` is not referenced by this PR"
+                f" (allowed: {sorted(allowed_issues)})"
+            )
+        section = decision.get("section")
+        if section not in SECTIONS:
+            raise ValidationError(f"invalid section {section!r}")
+        if section == "Bug fixes":
+            section = bugfix_section(text, entry_text)
+        # Only dedup against a real in-development block; after a
+        # release the top block is history, and a new entry belongs in
+        # a fresh dev block regardless of what shipped.
+        if is_dev:
+            block_lines = changelog_context(text).splitlines()
+            if any(ln.startswith(f"- :gh:`{gh}`") for ln in block_lines):
+                raise ValidationError(
+                    f"an entry for :gh:`{gh}` already exists; amend it instead"
+                )
+        new_text = insert_entry(text, section, entry_text)
+        check_entry_ordered(new_text, gh)
+        return new_text, "inserted", gh
+
+    if action == "amend":
+        if not is_dev:
+            raise ValidationError(
+                "top changelog block is released; cannot amend, insert instead"
+            )
+        amend_gh = decision.get("amend_gh")
+        if amend_gh is None:
+            raise ValidationError("amend requires amend_gh")
+        if gh != amend_gh:
+            raise ValidationError(
+                f"amended entry must keep :gh:`{amend_gh}`, got :gh:`{gh}`"
+            )
+        return amend_entry(text, amend_gh, entry_text), "amended", gh
+
+    raise ValidationError(f"unknown action {action!r}")
+
+
+def credit_line(author, author_name, gh):
+    if author_name and author_name != author:
+        who = f":user:`{author_name} <{author}>`"
+    else:
+        who = f":user:`{author}`"
+    return f"* {who} - :gh:`{gh}`"
+
+
+def credits_sort_key(line):
+    s = line.strip()
+    # :user:`Name <handle>` or :user:`handle`
+    m = re.match(r"\*\s+:user:`([^<`]+?)(?:\s*<[^>]+>)?`", s)
+    if m:
+        return m.group(1).strip().lower()
+    # legacy: * `Display Name`_ - ...
+    m = re.match(r"\*\s+`([^`]+)`_", s)
+    if m:
+        return m.group(1).strip().lower()
+    return s.lower()
+
+
+def credits_handle(line):
+    m = re.search(r":user:`(?:[^<`]+<([^>]+)>|([^`<]+))`", line)
+    if not m:
+        return None
+    return (m.group(1) or m.group(2)).strip()
+
+
+def legacy_name_to_handle(lines):
+    """Map a legacy ``Name``_ display name to its GitHub handle.
+
+    Built from the ``.. _`Name`: https://github.com/<handle>`` target
+    definitions at the bottom of credits.rst.
+    """
+    out = {}
+    pat = r"\.\. _`([^`]+)`:\s*https?://github\.com/([^/\s]+)"
+    for ln in lines:
+        m = re.match(pat, ln.strip())
+        if m:
+            out[m.group(1).strip()] = m.group(2).strip()
+    return out
+
+
+def line_handle(line, name_map):
+    """GitHub handle for a credits line (``:user:`` or legacy form)."""
+    handle = credits_handle(line)
+    if handle:
+        return handle
+    m = re.match(r"\*\s+`([^`]+)`_", line)
+    if m:
+        return name_map.get(m.group(1).strip())
+    return None
+
+
+def append_gh_to_line(line, gh):
+    ref = f":gh:`{gh}`"
+    # Insert before a trailing parenthetical note like "(wheels ...)".
+    m = re.search(r"\s+\([^)]*\)\s*$", line)
+    if m:
+        return f"{line[: m.start()]}, {ref}{line[m.start():]}"
+    return f"{line.rstrip()}, {ref}"
+
+
+def apply_credit(text, author, author_name, gh, year):
+    """Add or extend the author's credits line for the given year.
+
+    Returns (new_text, status) where status is "added", "appended" or
+    "skipped". @giampaolo is never credited.
+    """
+    if author == "giampaolo":
+        return text, "skipped"
+    lines = text.splitlines()
+    year_re = re.compile(r"^\d{4}$")
+    section_idx = next(
+        (
+            i
+            for i, ln in enumerate(lines)
+            if ln.strip() == "Code contributors by year"
+        ),
+        None,
+    )
+    if section_idx is None:
+        sys.exit(f"'Code contributors by year' not found in {CREDITS_FILE}")
+
+    year_idx = next(
+        (
+            i
+            for i in range(section_idx, len(lines))
+            if lines[i].strip() == year
+        ),
+        None,
+    )
+    if year_idx is None:
+        first_year = next(
+            (
+                i
+                for i in range(section_idx, len(lines))
+                if year_re.match(lines[i].strip())
+            ),
+            len(lines),
+        )
+        lines[first_year:first_year] = [
+            year,
+            "~" * len(year),
+            "",
+            credit_line(author, author_name, gh),
+            "",
+        ]
+        return "\n".join(lines) + "\n", "added"
+
+    year_end = next(
+        (
+            i
+            for i in range(year_idx + 2, len(lines))
+            if year_re.match(lines[i].strip())
+        ),
+        len(lines),
+    )
+    name_map = legacy_name_to_handle(lines)
+    for i in range(year_idx + 2, year_end):
+        ln = lines[i]
+        if ln.startswith("* ") and line_handle(ln, name_map) == author:
+            # A credit may wrap onto 2-space-indented continuation
+            # lines; treat the whole thing as one logical entry.
+            j = i + 1
+            while j < year_end and lines[j].startswith("  "):
+                j += 1
+            entry = lines[i:j]
+            if any(f":gh:`{gh}`" in ln for ln in entry):
+                return text, "skipped"
+            appended = append_gh_to_line(entry[-1], gh)
+            if len(appended) <= 79:
+                entry[-1] = appended
+            else:
+                entry[-1] = entry[-1].rstrip() + ","
+                entry.append(f"  :gh:`{gh}`")
+            lines[i:j] = entry
+            result = resort_credits_year("\n".join(lines) + "\n", year)
+            return result, "appended"
+
+    new_line = credit_line(author, author_name, gh)
+    key = credits_sort_key(new_line)
+    insert_idx = year_end
+    for i in range(year_idx + 2, year_end):
+        if lines[i].startswith("* ") and credits_sort_key(lines[i]) > key:
+            insert_idx = i
+            break
+    min_idx = year_idx + 3
+    while insert_idx > min_idx and not lines[insert_idx - 1].strip():
+        insert_idx -= 1
+    lines.insert(insert_idx, new_line)
+    result = resort_credits_year("\n".join(lines) + "\n", year)
+    return result, "added"
+
+
+def resort_credits_year(text, year):
+    """Sort the year's credit entries alphabetically, keeping each
+    entry's wrapped continuation lines with it.
+    """
+    lines = text.splitlines()
+    year_re = re.compile(r"^\d{4}$")
+    section_idx = next(
+        (
+            i
+            for i, ln in enumerate(lines)
+            if ln.strip() == "Code contributors by year"
+        ),
+        None,
+    )
+    if section_idx is None:
+        return text
+    year_idx = next(
+        (
+            i
+            for i in range(section_idx, len(lines))
+            if lines[i].strip() == year
+        ),
+        None,
+    )
+    if year_idx is None:
+        return text
+    start = year_idx + 2
+    while start < len(lines) and not lines[start].strip():
+        start += 1
+    end = next(
+        (
+            i
+            for i in range(year_idx + 2, len(lines))
+            if year_re.match(lines[i].strip())
+        ),
+        len(lines),
+    )
+    while end > start and not lines[end - 1].strip():
+        end -= 1
+    entries = []
+    for ln in lines[start:end]:
+        if ln.startswith("* ") or not entries:
+            entries.append([ln])
+        else:
+            entries[-1].append(ln)
+    entries.sort(key=lambda e: credits_sort_key(e[0]))
+    lines[start:end] = [ln for entry in entries for ln in entry]
+    return "\n".join(lines) + "\n"
+
+
+def write_file(path, body):
+    """Write a PR comment body for the workflow to post later.
+
+    Success and validation-error bodies go to different files so the
+    workflow's failure step never posts a stale "entry added" body when
+    a later step (e.g. the push) is what failed.
+    """
+    print(body)
+    if path:
+        with open(path, "w") as f:
+            f.write(body)
+
+
+def parse_cli():
+    global PR_NUMBER, REPO, TOKEN, COMMENT_FILE, ERROR_FILE
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--pr-number", type=int, required=True)
+    p.add_argument(
+        "--repo", type=str, required=True, help="e.g. giampaolo/psutil"
+    )
+    p.add_argument("--token", type=str, required=True, help="GitHub token")
+    p.add_argument(
+        "--comment-file",
+        type=str,
+        default=None,
+        help="On success, write the PR comment body here",
+    )
+    p.add_argument(
+        "--error-file",
+        type=str,
+        default=None,
+        help="On a validation failure, write the error comment here",
+    )
+    args = p.parse_args()
+    PR_NUMBER = args.pr_number
+    REPO = args.repo
+    TOKEN = args.token
+    COMMENT_FILE = args.comment_file
+    ERROR_FILE = args.error_file
+
+
+def build_comment(cl_status, cr_status, decision, gh, author):
+    """Compose the PR comment strictly from what the script did."""
+    entry = decision.get("entry_text") or ""
+    block = f"```rst\n{entry}\n```"
+    if cl_status == "inserted":
+        section = decision["section"]
+        header = f"`{CHANGELOG_FILE}` entry added under **{section}**:"
+        parts = [f"{header}\n\n{block}"]
+    elif cl_status == "amended":
+        header = f"`{CHANGELOG_FILE}` entry for :gh:`{gh}` amended:"
+        parts = [f"{header}\n\n{block}"]
+    else:
+        reason = decision.get("skip_reason") or "already covered"
+        parts = [f"`{CHANGELOG_FILE}` **not** modified (skipped): {reason}"]
+
+    if cr_status == "added":
+        parts.append(f"`{CREDITS_FILE}`: credited @{author} for :gh:`{gh}`.")
+    elif cr_status == "appended":
+        parts.append(
+            f"`{CREDITS_FILE}`: appended :gh:`{gh}` to @{author}'s line."
+        )
+    return "\n\n".join(parts)
+
+
+def fetch_issue_labels(number):
+    raw = json.loads(gh_request(f"/repos/{REPO}/issues/{number}"))
+    return sorted(x["name"] for x in raw["labels"])
+
+
+def run_decision(pr, decision, year=None, get_labels=fetch_issue_labels):
+    """Apply the decision to both files; return (cl_status, cr_status, gh)."""
+    allowed = referenced_issues(pr["title"], pr["body"], pr["number"])
+    entry = decision.get("entry_text")
+    if decision.get("action") != "skip" and entry:
+        if ":label:`" in entry:
+            raise ValidationError(
+                "entry must not contain :label: badges; they are"
+                " derived from the issue's labels"
+            )
+        labels = get_labels(validate_entry_text(entry))
+        check_platform_tags(entry, labels)
+        # In place, so the PR comment shows what was really written.
+        decision["entry_text"] = inject_labels(entry, labels)
+    with open(CHANGELOG_FILE) as f:
+        changelog = f.read()
+    new_changelog, cl_status, gh = apply_changelog_decision(
+        changelog, decision, allowed
+    )
+    # A no-op amend (identical text) changes nothing; report it as a
+    # skip so the comment doesn't claim an edit that never happened.
+    if cl_status != "skipped" and new_changelog == changelog:
+        cl_status, gh = "skipped", None
+    if cl_status != "skipped":
+        with open(CHANGELOG_FILE, "w") as f:
+            f.write(new_changelog)
+    print(f"Changelog: {cl_status}")
+
+    cr_status = "skipped"
+    if gh is not None:
+        year = year or str(datetime.date.today().year)
+        with open(CREDITS_FILE) as f:
+            credits = f.read()
+        new_credits, cr_status = apply_credit(
+            credits, pr["author"], pr["author_name"], gh, year
+        )
+        if cr_status != "skipped":
+            with open(CREDITS_FILE, "w") as f:
+                f.write(new_credits)
+    print(f"Credits: {cr_status}")
+    return cl_status, cr_status, gh
+
+
+def main():
+    parse_cli()
+    print(f"Fetching PR #{PR_NUMBER} from {REPO}...")
+    pr = fetch_pr_metadata()
+    stale = stale_reason(pr["head_sha"])
+    if stale:
+        write_file(
+            ERROR_FILE,
+            f"⚠� The /changelog bot did nothing: {stale}. Committing an"
+            " entry now would make this PR unmergeable. Click **Update"
+            " branch**, then comment `/changelog` again.",
+        )
+        sys.exit(f"stale branch: {stale}")
+    diff = fetch_pr_diff()
+    with open(CHANGELOG_FILE) as f:
+        block = changelog_context(f.read())
+    print("Asking Claude for changelog decision...")
+    decision = ask_claude(pr, diff, block)
+    print(f"Decision: {decision}")
+    try:
+        cl_status, cr_status, gh = run_decision(pr, decision)
+    except ValidationError as err:
+        blob = json.dumps(decision, indent=2)
+        write_file(
+            ERROR_FILE,
+            f"⚠� The /changelog bot could not apply the entry: {err}\n\n"
+            f"Model output:\n\n```json\n{blob}\n```",
+        )
+        sys.exit(f"validation failed: {err}")
+    write_file(
+        COMMENT_FILE,
+        build_comment(cl_status, cr_status, decision, gh, pr["author"]),
+    )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/workflows/changelog_bot.yml b/.github/workflows/changelog_bot.yml
new file mode 100644
index 0000000000..3a535e6647
--- /dev/null
+++ b/.github/workflows/changelog_bot.yml
@@ -0,0 +1,145 @@
+name: changelog-bot
+
+on:
+  issue_comment:
+    types: [created]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  changelog:
+    if: >
+      contains(github.event.comment.body, '/changelog') &&
+      github.event.issue.pull_request != null
+    runs-on: ubuntu-latest
+
+    # Don't let two /changelog comments on the same PR race the
+    # checkout/push. Queue the second one instead of cancelling.
+    concurrency:
+      group: changelog-${{ github.event.issue.number }}
+      cancel-in-progress: false
+
+    steps:
+      - name: Check commenter permissions
+        id: check-perms
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          COMMENTER: ${{ github.event.comment.user.login }}
+          BODY: ${{ github.event.comment.body }}
+        run: |
+          # The `if:` above can't trim, and the browser sends the
+          # command as "\r\n/changelog\r\n\r\n".
+          if [ "$(printf '%s' "$BODY" | tr -d '[:space:]')" != "/changelog" ]
+          then
+            echo "Not a /changelog command"
+            exit 1
+          fi
+          PERMISSION=$(gh api \
+            "repos/${{ github.repository }}/collaborators/$COMMENTER/permission" \
+            --jq '.permission')
+          echo "permission=$PERMISSION"
+          if [[ "$PERMISSION" != "write" && "$PERMISSION" != "admin" ]]; then
+            echo "User $COMMENTER does not have write/admin permission"
+            exit 1
+          fi
+
+      - name: Get PR info
+        id: pr-info
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ github.event.issue.number }}
+        run: |
+          PR_JSON=$(gh pr view "$PR_NUMBER" \
+            --repo "${{ github.repository }}" \
+            --json headRefName,headRepository,headRepositoryOwner,headRefOid)
+          HEAD_BRANCH=$(echo "$PR_JSON" | jq -r '.headRefName')
+          HEAD_OWNER=$(echo "$PR_JSON" | jq -r '.headRepositoryOwner.login')
+          HEAD_REPO=$(echo "$PR_JSON" | jq -r '.headRepository.name')
+          HEAD_SHA=$(echo "$PR_JSON" | jq -r '.headRefOid')
+          echo "branch=$HEAD_BRANCH" >> "$GITHUB_OUTPUT"
+          echo "head_repo=$HEAD_OWNER/$HEAD_REPO" >> "$GITHUB_OUTPUT"
+          echo "head_sha=$HEAD_SHA" >> "$GITHUB_OUTPUT"
+
+      - name: Checkout PR branch
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+        with:
+          ref: ${{ steps.pr-info.outputs.head_sha }}
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install dependencies
+        run: pip install anthropic rstwrap
+
+      - name: Run changelog bot
+        env:
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          PR_NUMBER: ${{ github.event.issue.number }}
+        run: |
+          # Run the trusted script from master, not the PR's copy, so a
+          # malicious PR can't get arbitrary code executed on the runner.
+          git fetch --depth 1 origin master
+          git show origin/master:.github/workflows/changelog_bot.py > /tmp/changelog_bot.py
+          python /tmp/changelog_bot.py \
+            --pr-number "$PR_NUMBER" \
+            --repo "${{ github.repository }}" \
+            --token "${{ secrets.GITHUB_TOKEN }}" \
+            --comment-file "$RUNNER_TEMP/changelog_comment.md" \
+            --error-file "$RUNNER_TEMP/changelog_error.md"
+
+      - name: Commit and push if changelog changed
+        id: push
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ github.event.issue.number }}
+          # Pass fork-controlled values through env, never interpolate
+          # ${{ }} into the shell: a branch named "x$(cmd)" would
+          # otherwise run as a command.
+          HEAD_REPO: ${{ steps.pr-info.outputs.head_repo }}
+          HEAD_BRANCH: ${{ steps.pr-info.outputs.branch }}
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          rstwrap docs/changelog.rst docs/credits.rst
+          git add docs/changelog.rst docs/credits.rst
+          if git diff --cached --quiet; then
+            echo "No changes, skipping commit"
+          else
+            git commit --no-verify -m "Update changelog for PR #$PR_NUMBER"
+            PUSH_URL="https://x-access-token:${GH_TOKEN}@github.com/${HEAD_REPO}.git"
+            git push "$PUSH_URL" "HEAD:refs/heads/${HEAD_BRANCH}"
+          fi
+
+      - name: Post confirmation comment
+        # Best-effort: a comment hiccup must not mislabel a landed
+        # push as a failure.
+        if: success()
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ github.event.issue.number }}
+        run: |
+          gh pr comment "$PR_NUMBER" \
+            --repo "${{ github.repository }}" \
+            --body-file "$RUNNER_TEMP/changelog_comment.md"
+
+      - name: Report failure on the PR
+        if: failure() && steps.check-perms.outcome == 'success'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: ${{ github.event.issue.number }}
+          RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        run: |
+          # A validation error leaves a specific message; anything else
+          # (e.g. a failed push) only gets the generic pointer, never a
+          # stale success body.
+          ERROR_FILE="$RUNNER_TEMP/changelog_error.md"
+          if [ -s "$ERROR_FILE" ]; then
+            gh pr comment "$PR_NUMBER" \
+              --repo "${{ github.repository }}" \
+              --body-file "$ERROR_FILE"
+          else
+            gh pr comment "$PR_NUMBER" \
+              --repo "${{ github.repository }}" \
+              --body "⚠� The /changelog bot failed. See the run log: $RUN_URL"
+          fi
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 0000000000..26337add26
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,130 @@
+# Builds and tests the docs, then deploys them to GitHub Pages.
+#
+# Flow: sanity tests -> build -> deploy -> live-site tests. Single
+# version, served at the site root (psutil.io). Nothing is committed:
+# the built site is uploaded as an artifact and served directly (no
+# gh-pages branch, no separate repo).
+#
+# Repo setup: Settings -> Pages -> Source = "GitHub Actions", and set
+# the custom domain to psutil.io.
+#
+# Prior art if we ever add versioning. Preferred path is the Salt
+# model: keep this artifact method and single repo, but fan the build
+# out over master + the last few supported release tags (master -> /,
+# each tag -> /vX.Y/) and rebuild that set every run. No separate repo,
+# no committed HTML, EOL versions drop off. Root stays master so the
+# blog keeps publishing; the /vX.Y/ dirs are frozen API snapshots. A
+# JS flyout reads a generated versions.json.
+#   Salt (this model, in production):
+#     https://github.com/saltstack/builddocs/blob/main/.github/workflows/gh-pages-builddocs.yml
+#   NumPy (heavier: separate repo, one committed dir per release, by
+#   hand) - only for a permanent archive of every past release:
+#     https://github.com/numpy/numpy.org/blob/main/.github/workflows/gh-pages.yml
+#     https://github.com/numpy/doc
+
+on:
+  push:
+    branches: [master]
+    paths: &docs_paths
+      - "docs/**"
+      - ".github/workflows/docs.yml"
+      - "pyproject.toml"
+  pull_request:
+    paths: *docs_paths
+  workflow_dispatch:
+
+name: docs
+
+concurrency:
+  group: docs-deploy
+  cancel-in-progress: false
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          fetch-depth: 0 # full history for sphinx-last-updated-by-git
+
+      - uses: actions/setup-python@v7
+        with:
+          python-version: 3.x
+
+      - name: Install dependencies
+        run: |
+          make install-pydeps-docs
+          make install-pydeps-lint
+          make install-pydeps-test
+          pip install .                   # codeautolink imports psutil
+
+      - name: Lint rst
+        run: make lint-rst
+
+      - name: Doc sanity tests
+        run: make -C docs test
+
+      - name: Refresh adoption stats
+        # Change is not committed to GIT, but ends up on the live site.
+        continue-on-error: true
+        run: python3 scripts/internal/docs/refresh_adoption_stats.py
+
+      - name: Build HTML
+        run: make -C docs html
+
+      - name: Build past doc releases
+        run: make -C docs versions
+
+      - name: Add deploy marker
+        run: echo "${{ github.sha }}" > docs/_build/html/build-sha.txt
+
+      - uses: actions/upload-pages-artifact@v5
+        with:
+          path: docs/_build/html
+
+  deploy:
+    needs: build
+    if: github.event_name != 'pull_request'
+    runs-on: ubuntu-latest
+    permissions:
+      pages: write
+      id-token: write
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v5
+
+  test-online:
+    needs: deploy
+    if: github.event_name != 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: 3.x
+      - name: Install dependencies
+        run: |
+          make install-pydeps-test
+          make install-pydeps-docs
+
+      - name: Wait for the live site to serve this commit
+        # deploy-pages reports "live" before the CDN edge catches up,
+        # so poll build-sha.txt (cache-busted) until it matches.
+        run: |
+          for i in $(seq 1 60); do
+            live=$(curl -fsS "https://psutil.io/build-sha.txt?cb=$i" || true)
+            if [ "$live" = "${{ github.sha }}" ]; then
+              echo "live site is serving ${{ github.sha }}"
+              exit 0
+            fi
+            echo "waiting for CDN propagation ($i)..."
+            sleep 5
+          done
+          echo "timed out waiting for the deploy to go live"
+          exit 1
+
+      - name: Live-site tests
+        run: make -C docs test-online-doc
diff --git a/.github/workflows/sunos.yml b/.github/workflows/sunos.yml
new file mode 100644
index 0000000000..84b4af4413
--- /dev/null
+++ b/.github/workflows/sunos.yml
@@ -0,0 +1,49 @@
+# Execute tests on SunOS
+# https://github.com/vmactions/solaris-vm
+
+name: sunos
+on:
+  workflow_dispatch:
+  push:
+    # only run this job if the following files are modified
+    paths: &sunos_paths
+      - ".github/workflows/sunos.yml"
+      - "Makefile"
+      - "psutil/__init__.py"
+      - "psutil/_common.py"
+      - "psutil/_ntuples.py"
+      - "psutil/_psposix.py"
+      - "psutil/_pssunos.py"
+      - "psutil/_psutil_sunos.c"
+      - "psutil/arch/all/**"
+      - "psutil/arch/posix/**"
+      - "psutil/arch/sunos/**"
+      - "pyproject.toml"
+      - "scripts/internal/install-pydeps.sh"
+      - "scripts/internal/install-sysdeps.sh"
+      - "setup.py"
+  pull_request:
+    paths: *sunos_paths
+concurrency:
+  group: ${{ github.ref }}-${{ github.workflow }}-${{ github.event_name }}-${{ github.ref == format('refs/heads/{0}', github.event.repository.default_branch) && github.sha || '' }}
+  cancel-in-progress: true
+jobs:
+  test:
+    # Skip same-repo PR runs: the push event already covers them.
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+      - name: Run tests
+        id: test
+        uses: vmactions/solaris-vm@v1
+        with:
+          release: "11.4-gcc"
+          usesh: true
+          run: |
+            set -x
+            pkg install --accept developer/build/gnu-make || true
+            gmake build
+            gmake install-pydeps-test
+            gmake test-memleaks-parallel
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000000..417669d762
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,90 @@
+# Runs CI tests against a source build on the following platforms:
+# * Linux
+# * macOS
+# * Windows
+#
+# Wheels are built by wheels.yml.
+#
+# Useful URLs:
+# * https://github.com/actions/cache
+# * https://github.com/actions/checkout
+# * https://github.com/actions/setup-python
+
+on:
+  workflow_dispatch:
+  push:
+    paths-ignore:
+      - "docs/**"
+  pull_request:
+    paths-ignore:
+      - "docs/**"
+name: tests
+concurrency:
+  # Cancel run if a new one starts, but don't interrupt all jobs on the first
+  # failure.
+  group: test-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+
+  # Run tests on Linux, macOS, Windows
+  tests:
+    name: "${{ matrix.osname }} ${{ matrix.arch }} (py${{ matrix.python }})"
+    # Skip same-repo PR runs: the push event already covers them.
+    if: &skip_same_repo_pr github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-latest, osname: linux, arch: x86_64, python: "3.14", memleaks: true }
+          - { os: ubuntu-24.04-arm, osname: linux, arch: aarch64, python: "3.8" }
+          - { os: ubuntu-latest, osname: linux, arch: x86_64, python: "3.14t" }
+          - { os: macos-15, osname: macos, arch: arm64, python: "3.14", memleaks: true }
+          - { os: macos-15-intel, osname: macos, arch: x86_64, python: "3.13" } # py 3.9 install is too slow
+          - { os: windows-2025, osname: win, arch: AMD64, python: "3.10", memleaks: true }
+          - { os: windows-11-arm, osname: win, arch: ARM64, python: "3.14" }
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Install Python
+        uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python }}
+
+      # setup-python always provides "python"; "python3" is missing on
+      # Windows, and the Makefile defaults to it.
+      - name: Run tests
+        shell: bash
+        run: make PYTHON=python ci-test
+
+      - name: Run memleak tests
+        if: matrix.memleaks
+        shell: bash
+        run: make PYTHON=python test-memleaks-parallel
+
+  # Run linters + bots tests
+  linters:
+    if: *skip_same_repo_pr
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: 3.x
+      # Cache dprint binary + plugins, which would otherwise be recompiled
+      # on every run (~5s).
+      - name: Cache dprint
+        uses: actions/cache@v6
+        with:
+          path: |
+            ~/.dprint
+            ~/.cache/dprint
+          key: dprint-${{ hashFiles('.dprint.jsonc') }}
+      - name: "Run linters"
+        run: |
+          make ci-lint
+      - name: "Run bot tests"
+        run: |
+          ./scripts/internal/install-pydeps.sh pytest
+          make test-bots
diff --git a/.github/workflows/tests/test_changelog_bot.py b/.github/workflows/tests/test_changelog_bot.py
new file mode 100644
index 0000000000..39e59bac32
--- /dev/null
+++ b/.github/workflows/tests/test_changelog_bot.py
@@ -0,0 +1,1094 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Tests for the /changelog bot (.github/workflows/changelog_bot.py).
+
+The bot edits docs/changelog.rst and docs/credits.rst based on an LLM
+decision. These tests exercise the deterministic file surgery and the
+validation gate against small RST fixtures; no network or API is used.
+"""
+
+import importlib.util
+import io
+import pathlib
+
+import pytest
+
+BOT_PATH = pathlib.Path(__file__).parent.parent / "changelog_bot.py"
+
+
+def import_module_by_path(path):
+    spec = importlib.util.spec_from_file_location(path.stem, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+cb = import_module_by_path(BOT_PATH)
+
+CHANGELOG = """\
+Changelog
+=========
+
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`100`: new API one.
+
+**Bug fixes**
+
+- :gh:`200`: bug one.
+- :gh:`201`, [Linux]: bug two spanning
+  two physical lines.
+
+7.2.2 — 2026-01-28
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`50`: old released bug.
+"""
+
+
+class TestContext:
+    def test_returns_only_top_block(self):
+        block = cb.changelog_context(CHANGELOG)
+        assert block.startswith("8.0.0 (IN DEVELOPMENT)")
+        assert ":gh:`200`" in block
+        # The released block below must not be included.
+        assert "7.2.2" not in block
+        assert ":gh:`50`" not in block
+
+
+class TestInsert:
+    def _lines(self, text):
+        return text.splitlines()
+
+    def test_appends_to_end_of_section(self):
+        out = cb.insert_entry(CHANGELOG, "Bug fixes", "- :gh:`300`: new bug.")
+        lines = self._lines(out)
+        idx = lines.index("- :gh:`300`: new bug.")
+        # It lands after the existing bug entries.
+        assert lines.index("- :gh:`200`: bug one.") < idx
+
+    def test_does_not_glue_to_next_header(self):
+        # The regression: a new entry must not abut the next version
+        # header with no blank line in between.
+        out = cb.insert_entry(CHANGELOG, "Bug fixes", "- :gh:`300`: new bug.")
+        lines = self._lines(out)
+        idx = lines.index("- :gh:`300`: new bug.")
+        assert lines[idx + 1] == ""
+        assert lines[idx + 2].startswith("7.2.2")
+
+    def test_inserts_into_correct_section(self):
+        out = cb.insert_entry(CHANGELOG, "New APIs", "- :gh:`300`: new api.")
+        lines = self._lines(out)
+        api = lines.index("**New APIs**")
+        bug = lines.index("**Bug fixes**")
+        idx = lines.index("- :gh:`300`: new api.")
+        assert api < idx < bug
+
+    def test_inserts_in_sorted_position(self):
+        # 150 < 200, so it must come before it (#123 before #124).
+        out = cb.insert_entry(CHANGELOG, "Bug fixes", "- :gh:`150`: early.")
+        lines = self._lines(out)
+        assert lines.index("- :gh:`150`: early.") < lines.index(
+            "- :gh:`200`: bug one."
+        )
+
+    def test_inserts_into_last_run_of_grouped_section(self):
+        # A section split into pseudo-header groups: a new
+        # entry goes into the last run, sorted, never into an earlier
+        # group even if its number would sort there.
+        text = """\
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+**Performance**
+
+New APIs:
+
+- :gh:`100`: api one.
+- :gh:`300`: api three.
+
+Others:
+
+- :gh:`200`: other two.
+- :gh:`400`: other four.
+"""
+        out = cb.insert_entry(text, "Performance", "- :gh:`250`: new misc.")
+        lines = self._lines(out)
+        new = lines.index("- :gh:`250`: new misc.")
+        # In the Others run (after that header), not New APIs.
+        assert lines.index("Others:") < new
+        assert lines.index("- :gh:`200`: other two.") < new
+        assert new < lines.index("- :gh:`400`: other four.")
+
+    def test_multiline_entry_kept_together(self):
+        entry = "- :gh:`300`: a long entry that wraps onto\n  a second line."
+        out = cb.insert_entry(CHANGELOG, "Bug fixes", entry)
+        lines = self._lines(out)
+        idx = lines.index("- :gh:`300`: a long entry that wraps onto")
+        assert lines[idx + 1] == "  a second line."
+        assert lines[idx + 2] == ""
+
+    def test_creates_missing_section_in_canonical_order(self):
+        text = """\
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`100`: api.
+"""
+        out = cb.insert_entry(text, "Bug fixes", "- :gh:`300`: new bug.")
+        lines = self._lines(out)
+        assert lines.index("**New APIs**") < lines.index("**Bug fixes**")
+        assert lines.index("**Bug fixes**") < lines.index(
+            "- :gh:`300`: new bug."
+        )
+
+    def test_created_section_has_blank_line_before_first_entry(self):
+        # Regression: a freshly created section must not glue its first
+        # entry to the header (renders as run-on prose, silently).
+        text = """\
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`100`: api.
+"""
+        out = cb.insert_entry(text, "Bug fixes", "- :gh:`300`: new bug.")
+        lines = self._lines(out)
+        hdr = lines.index("**Bug fixes**")
+        assert lines[hdr + 1] == ""
+        assert lines[hdr + 2] == "- :gh:`300`: new bug."
+
+    def test_created_mid_order_section_has_blank_line_before_entry(self):
+        text = """\
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`200`: bug.
+"""
+        out = cb.insert_entry(text, "Performance", "- :gh:`300`: faster.")
+        lines = self._lines(out)
+        hdr = lines.index("**Performance**")
+        assert lines[hdr + 1] == ""
+        assert lines[hdr + 2] == "- :gh:`300`: faster."
+
+    def test_creates_missing_section_before_later_one(self):
+        text = """\
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`200`: bug.
+"""
+        out = cb.insert_entry(text, "Performance", "- :gh:`300`: faster.")
+        lines = self._lines(out)
+        assert lines.index("**Performance**") < lines.index("**Bug fixes**")
+
+
+class TestLabels:
+    def test_inject_in_badge_order_and_wrapped(self):
+        entry = (
+            "- :gh:`300`, [NetBSD]: a fairly long entry describing a"
+            " double free\n  in :func:`swap_memory` on some systems."
+        )
+        out = cb.inject_labels(entry, ["bug", "critical", "memleak", "netbsd"])
+        first = out.splitlines()[0]
+        assert first.startswith(
+            "- :gh:`300`, [NetBSD], :label:`critical`, :label:`memleak`:"
+        )
+        assert all(len(ln) <= 79 for ln in out.splitlines())
+
+    def test_compatibility_becomes_breaking(self):
+        out = cb.inject_labels(
+            "- :gh:`300`: renamed.", ["compatibility", "windows"]
+        )
+        assert out.startswith("- :gh:`300`, :label:`breaking`: renamed.")
+
+    def test_no_labels_no_badges(self):
+        out = cb.inject_labels("- :gh:`300`: plain.", ["bug", "linux"])
+        assert ":label:" not in out
+
+    def test_wrap_never_splits_inside_roles(self):
+        entry = (
+            "- :gh:`300`: fix by"
+            " :user:`Somebody With A Very Long Name <handle>` plus"
+            " ``a b c`` and more words to push this over the limit for"
+            " sure."
+        )
+        out = cb.inject_labels(entry, [])
+        flat = " ".join(ln.strip() for ln in out.splitlines())
+        assert ":user:`Somebody With A Very Long Name <handle>`" in flat
+        assert "``a b c``" in flat
+
+
+class TestPlatformTags:
+    def test_backed_tag_passes(self):
+        cb.check_platform_tags("- :gh:`1`, [Linux]: x.", ["bug", "linux"])
+
+    def test_family_tag_backed_by_member(self):
+        cb.check_platform_tags("- :gh:`1`, [BSD]: x.", ["freebsd"])
+        cb.check_platform_tags("- :gh:`1`, [UNIX]: x.", ["sunos"])
+
+    def test_unbacked_tag_rejected(self):
+        with pytest.raises(cb.ValidationError):
+            cb.check_platform_tags("- :gh:`1`, [Windows]: x.", ["linux"])
+
+    def test_brackets_in_prose_are_not_tags(self):
+        cb.check_platform_tags(
+            "- :gh:`1`: raises ``[Errno 2]`` sometimes.", []
+        )
+
+
+class TestTierOrdering:
+    def test_labelled_entry_inserted_before_plain_ones(self):
+        entry = "- :gh:`300`, :label:`critical`: segfault."
+        out = cb.insert_entry(CHANGELOG, "Bug fixes", entry)
+        lines = out.splitlines()
+        assert lines.index(entry) < lines.index("- :gh:`200`: bug one.")
+
+    def test_plain_entry_lands_after_labelled_run(self):
+        text = """\
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`500`, :label:`critical`: boom.
+- :gh:`100`: plain.
+"""
+        out = cb.insert_entry(text, "Bug fixes", "- :gh:`300`: also plain.")
+        lines = out.splitlines()
+        assert lines.index("- :gh:`100`: plain.") < lines.index(
+            "- :gh:`300`: also plain."
+        )
+        assert lines.index(
+            "- :gh:`500`, :label:`critical`: boom."
+        ) < lines.index("- :gh:`100`: plain.")
+
+
+class TestBugfixRouting:
+    SPLIT = """\
+Changelog
+=========
+
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+**Bug fixes: cross-platform**
+
+- :gh:`10`: everywhere.
+
+**Bug fixes: Windows**
+
+- :gh:`20`, [Windows]: win bug.
+
+**Bug fixes: BSD**
+
+- :gh:`30`, [NetBSD]: bsd bug.
+"""
+
+    def test_routes_by_platform_tag(self):
+        assert (
+            cb.bugfix_section(self.SPLIT, "- :gh:`40`, [Windows]: x.")
+            == "Bug fixes: Windows"
+        )
+        assert (
+            cb.bugfix_section(self.SPLIT, "- :gh:`40`, [FreeBSD]: x.")
+            == "Bug fixes: BSD"
+        )
+
+    def test_untagged_or_mixed_goes_cross_platform(self):
+        assert (
+            cb.bugfix_section(self.SPLIT, "- :gh:`40`: x.")
+            == "Bug fixes: cross-platform"
+        )
+        assert (
+            cb.bugfix_section(self.SPLIT, "- :gh:`40`, [Linux], [SunOS]: x.")
+            == "Bug fixes: cross-platform"
+        )
+
+    def test_plain_block_stays_plain(self):
+        assert (
+            cb.bugfix_section(CHANGELOG, "- :gh:`40`, [Windows]: x.")
+            == "Bug fixes"
+        )
+
+
+class TestOrderCheck:
+    ORDERED = """\
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`100`: a.
+- :gh:`200`: b.
+"""
+
+    def test_passes_for_sorted_run(self):
+        cb.check_entry_ordered(self.ORDERED, 200)
+
+    def test_raises_when_placed_after_higher_number(self):
+        text = self.ORDERED.replace("- :gh:`100`", "- :gh:`300`")
+        with pytest.raises(cb.ValidationError):
+            cb.check_entry_ordered(text, 200)
+
+    def test_stops_at_group_boundary(self):
+        # A pseudo-header ends the run, so a higher number in an earlier
+        # group doesn't count as "before" this entry.
+        text = """\
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+**Enhancements**
+
+New APIs:
+
+- :gh:`300`: api.
+
+Others:
+
+- :gh:`200`: other.
+"""
+        cb.check_entry_ordered(text, 200)
+
+
+class TestAmend:
+    def _lines(self, text):
+        return text.splitlines()
+
+    def test_replaces_single_line_entry(self):
+        out = cb.amend_entry(
+            CHANGELOG, 200, "- :gh:`200`: bug one, now amended."
+        )
+        lines = self._lines(out)
+        assert "- :gh:`200`: bug one, now amended." in lines
+        assert "- :gh:`200`: bug one." not in lines
+        # Siblings untouched.
+        assert "- :gh:`201`, [Linux]: bug two spanning" in lines
+
+    def test_replaces_multiline_entry_span(self):
+        out = cb.amend_entry(CHANGELOG, 201, "- :gh:`201`: collapsed.")
+        lines = self._lines(out)
+        assert "- :gh:`201`: collapsed." in lines
+        # Both old physical lines of the 201 entry are gone.
+        assert "- :gh:`201`, [Linux]: bug two spanning" not in lines
+        assert "  two physical lines." not in lines
+
+    def test_raises_when_entry_absent(self):
+        with pytest.raises(cb.ValidationError):
+            cb.amend_entry(CHANGELOG, 999, "- :gh:`999`: nope.")
+
+    def test_does_not_match_released_block_entry(self):
+        # :gh:`50` only exists in the released 7.2.2 block.
+        with pytest.raises(cb.ValidationError):
+            cb.amend_entry(CHANGELOG, 50, "- :gh:`50`: nope.")
+
+
+CREDITS = """\
+Code contributors
+=================
+
+Code contributors by year
+-------------------------
+
+2026
+~~~~
+
+* `Amaan Qureshi`_ - :gh:`2770`
+* :user:`Gabriel Changamire <gabrielchangamire-arch>` - :gh:`2809`
+* :user:`Tobias Klauser <tklauser>` - :gh:`2711`
+
+2025
+~~~~
+
+* `Ben Peddell`_ - :gh:`2495`, :gh:`2568`
+"""
+
+
+class TestCreditLine:
+    def test_full_name_form(self):
+        line = cb.credit_line("hansonw", "Hanson Wang", 2809)
+        assert line == "* :user:`Hanson Wang <hansonw>` - :gh:`2809`"
+
+    def test_handle_only_form(self):
+        # author_name falls back to the handle when no full name is set.
+        line = cb.credit_line("someuser", "someuser", 2710)
+        assert line == "* :user:`someuser` - :gh:`2710`"
+
+
+class TestCredits:
+    def _lines(self, text):
+        return text.splitlines()
+
+    def test_adds_new_contributor_sorted(self):
+        out, status = cb.apply_credit(
+            CREDITS, "newuser", "New User", 300, "2026"
+        )
+        assert status == "added"
+        lines = self._lines(out)
+        gab = lines.index(
+            "* :user:`Gabriel Changamire <gabrielchangamire-arch>`"
+            " - :gh:`2809`"
+        )
+        new = lines.index("* :user:`New User <newuser>` - :gh:`300`")
+        tob = lines.index("* :user:`Tobias Klauser <tklauser>` - :gh:`2711`")
+        assert gab < new < tob
+
+    def test_appends_gh_to_existing_contributor(self):
+        out, status = cb.apply_credit(
+            CREDITS, "tklauser", "Tobias Klauser", 300, "2026"
+        )
+        assert status == "appended"
+        assert (
+            "* :user:`Tobias Klauser <tklauser>` - :gh:`2711`, :gh:`300`"
+            in self._lines(out)
+        )
+
+    def test_sorts_before_legacy_named_link(self):
+        out, status = cb.apply_credit(
+            CREDITS, "aardvark", "Aardvark Zero", 300, "2026"
+        )
+        assert status == "added"
+        lines = self._lines(out)
+        new = lines.index("* :user:`Aardvark Zero <aardvark>` - :gh:`300`")
+        amaan = lines.index("* `Amaan Qureshi`_ - :gh:`2770`")
+        assert new < amaan
+
+    LEGACY = """\
+Code contributors
+=================
+
+Code contributors by year
+-------------------------
+
+2026
+~~~~
+
+* `Amaan Qureshi`_ - :gh:`2770`
+* :user:`Tobias Klauser <tklauser>` - :gh:`2711`
+
+.. _`Amaan Qureshi`: https://github.com/amaanq
+"""
+
+    def test_repeat_legacy_contributor_appends_not_duplicates(self):
+        # Amaan is listed in the legacy `Name`_ style; his handle is in
+        # the link target. A second 2026 PR must append, not add a
+        # duplicate :user: line.
+        out, status = cb.apply_credit(
+            self.LEGACY, "amaanq", "Amaan Qureshi", 300, "2026"
+        )
+        assert status == "appended"
+        lines = self._lines(out)
+        assert "* `Amaan Qureshi`_ - :gh:`2770`, :gh:`300`" in lines
+        assert not any(ln.startswith("* :user:`Amaan") for ln in lines)
+
+    def test_giampaolo_is_skipped(self):
+        out, status = cb.apply_credit(
+            CREDITS, "giampaolo", "Giampaolo Rodola", 300, "2026"
+        )
+        assert status == "skipped"
+        assert out == CREDITS
+
+    def test_duplicate_gh_is_skipped(self):
+        out, status = cb.apply_credit(
+            CREDITS,
+            "gabrielchangamire-arch",
+            "Gabriel Changamire",
+            2809,
+            "2026",
+        )
+        assert status == "skipped"
+        assert out == CREDITS
+
+    WRAPPED = """\
+Code contributors
+=================
+
+Code contributors by year
+-------------------------
+
+2026
+~~~~
+
+* :user:`Long Name Person <longname>` - :gh:`2001`, :gh:`2002`, :gh:`2003`,
+  :gh:`2004`, :gh:`2005`
+* :user:`Short <short>` - :gh:`10`
+"""
+
+    def test_append_to_wrapped_entry_hits_last_line(self):
+        out, status = cb.apply_credit(
+            self.WRAPPED, "longname", "Long Name Person", 2006, "2026"
+        )
+        assert status == "appended"
+        lines = self._lines(out)
+        # First physical line is untouched (no double comma).
+        first = lines.index(
+            "* :user:`Long Name Person <longname>` - :gh:`2001`,"
+            " :gh:`2002`, :gh:`2003`,"
+        )
+        assert ",," not in out
+        # The new ref lands on the continuation, not the first line.
+        assert ":gh:`2006`" in out
+        assert ":gh:`2006`" not in lines[first]
+
+    def test_append_dup_check_spans_wrapped_entry(self):
+        # :gh:`2005` is on the continuation line; must still skip.
+        out, status = cb.apply_credit(
+            self.WRAPPED, "longname", "Long Name Person", 2005, "2026"
+        )
+        assert status == "skipped"
+        assert out == self.WRAPPED
+
+    def test_append_stays_within_79_cols(self):
+        out, _ = cb.apply_credit(
+            self.WRAPPED, "longname", "Long Name Person", 2006, "2026"
+        )
+        assert all(len(ln) <= 79 for ln in self._lines(out))
+
+    def test_creates_new_year_block(self):
+        out, status = cb.apply_credit(
+            CREDITS, "newuser", "New User", 1, "2027"
+        )
+        assert status == "added"
+        lines = self._lines(out)
+        assert "2027" in lines
+        y2027 = lines.index("2027")
+        y2026 = lines.index("2026")
+        # Newest year on top.
+        assert y2027 < y2026
+        assert lines[y2027 + 1] == "~~~~"
+
+
+class TestResortCredits:
+    def test_sorts_year_block(self):
+        text = """\
+Code contributors by year
+-------------------------
+
+2026
+~~~~
+
+* :user:`Tobias Klauser <tklauser>` - :gh:`2711`
+* `Amaan Qureshi`_ - :gh:`2770`
+* :user:`Gabriel Changamire <gab>` - :gh:`2809`
+"""
+        out = cb.resort_credits_year(text, "2026")
+        entries = [x for x in out.splitlines() if x.startswith("* ")]
+        assert entries == [
+            "* `Amaan Qureshi`_ - :gh:`2770`",
+            "* :user:`Gabriel Changamire <gab>` - :gh:`2809`",
+            "* :user:`Tobias Klauser <tklauser>` - :gh:`2711`",
+        ]
+
+    def test_keeps_multiline_entry_together(self):
+        text = """\
+Code contributors by year
+-------------------------
+
+2026
+~~~~
+
+* :user:`Zoe Last <zoe>` - :gh:`10`,
+  :gh:`11`
+* `Amaan Qureshi`_ - :gh:`2770`
+"""
+        out = cb.resort_credits_year(text, "2026")
+        lines = out.splitlines()
+        zoe = lines.index("* :user:`Zoe Last <zoe>` - :gh:`10`,")
+        assert lines[zoe + 1] == "  :gh:`11`"
+        assert lines.index("* `Amaan Qureshi`_ - :gh:`2770`") < zoe
+
+    def test_leaves_other_years_untouched(self):
+        text = """\
+Code contributors by year
+-------------------------
+
+2026
+~~~~
+
+* :user:`Bea <bea>` - :gh:`2`
+* :user:`Ann <ann>` - :gh:`1`
+
+2025
+~~~~
+
+* :user:`Zed <zed>` - :gh:`9`
+* :user:`Amy <amy>` - :gh:`8`
+"""
+        out = cb.resort_credits_year(text, "2026")
+        lines = out.splitlines()
+        # 2026 got sorted, 2025 kept as-is.
+        assert lines.index("* :user:`Ann <ann>` - :gh:`1`") < lines.index(
+            "* :user:`Bea <bea>` - :gh:`2`"
+        )
+        assert lines.index("* :user:`Zed <zed>` - :gh:`9`") < lines.index(
+            "* :user:`Amy <amy>` - :gh:`8`"
+        )
+
+
+class TestReferencedIssues:
+    def test_collects_refs_and_pr_number(self):
+        refs = cb.referenced_issues(
+            "Fix crash", "Closes #2809, see #100", 2810
+        )
+        assert refs == {2809, 100, 2810}
+
+    def test_collects_url_and_gh_forms(self):
+        body = (
+            "Fixes https://github.com/giampaolo/psutil/issues/2809\n"
+            "also GH-100 and giampaolo/psutil#42"
+        )
+        refs = cb.referenced_issues("t", body, 2810)
+        assert {2809, 100, 42, 2810} <= refs
+
+
+class TestApplyChangelogDecision:
+    ALLOWED = {200, 201, 300}
+
+    def test_insert_valid(self):
+        decision = {
+            "action": "insert",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`300`: new bug.",
+            "amend_gh": None,
+            "skip_reason": None,
+        }
+        out, status, gh = cb.apply_changelog_decision(
+            CHANGELOG, decision, self.ALLOWED
+        )
+        assert status == "inserted"
+        assert gh == 300
+        assert "- :gh:`300`: new bug." in out
+
+    def test_insert_rejects_issue_not_referenced(self):
+        decision = {
+            "action": "insert",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`777`: hallucinated.",
+            "amend_gh": None,
+            "skip_reason": None,
+        }
+        with pytest.raises(cb.ValidationError):
+            cb.apply_changelog_decision(CHANGELOG, decision, self.ALLOWED)
+
+    def test_insert_rejects_malformed_entry(self):
+        decision = {
+            "action": "insert",
+            "section": "Bug fixes",
+            "entry_text": "just some text without a gh ref",
+            "amend_gh": None,
+            "skip_reason": None,
+        }
+        with pytest.raises(cb.ValidationError):
+            cb.apply_changelog_decision(CHANGELOG, decision, self.ALLOWED)
+
+    def test_insert_rejects_when_issue_already_present(self):
+        # :gh:`200` already has an entry; insert should have been amend.
+        decision = {
+            "action": "insert",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`200`: duplicate.",
+            "amend_gh": None,
+            "skip_reason": None,
+        }
+        with pytest.raises(cb.ValidationError):
+            cb.apply_changelog_decision(CHANGELOG, decision, self.ALLOWED)
+
+    def test_insert_rejects_entry_without_period(self):
+        decision = {
+            "action": "insert",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`300`: no period here",
+            "amend_gh": None,
+            "skip_reason": None,
+        }
+        with pytest.raises(cb.ValidationError):
+            cb.apply_changelog_decision(CHANGELOG, decision, self.ALLOWED)
+
+    def test_amend_valid(self):
+        decision = {
+            "action": "amend",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`200`: bug one and also two.",
+            "amend_gh": 200,
+            "skip_reason": None,
+        }
+        out, status, _ = cb.apply_changelog_decision(
+            CHANGELOG, decision, self.ALLOWED
+        )
+        assert status == "amended"
+        assert "- :gh:`200`: bug one and also two." in out
+
+    def test_amend_allowed_when_issue_not_referenced_by_pr(self):
+        # An amend targets an entry that already exists in the block;
+        # the PR need not restate that issue number.
+        decision = {
+            "action": "amend",
+            "section": None,
+            "entry_text": "- :gh:`200`: bug one, extended.",
+            "amend_gh": 200,
+            "skip_reason": None,
+        }
+        out, status, _ = cb.apply_changelog_decision(
+            CHANGELOG, decision, {12345}
+        )
+        assert status == "amended"
+        assert "- :gh:`200`: bug one, extended." in out
+
+    def test_amend_rejects_when_gh_changed(self):
+        decision = {
+            "action": "amend",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`999`: wrong number.",
+            "amend_gh": 200,
+            "skip_reason": None,
+        }
+        with pytest.raises(cb.ValidationError):
+            cb.apply_changelog_decision(CHANGELOG, decision, self.ALLOWED)
+
+    def test_skip_leaves_text_unchanged(self):
+        decision = {
+            "action": "skip",
+            "section": None,
+            "entry_text": None,
+            "amend_gh": None,
+            "skip_reason": "already covered.",
+        }
+        out, status, gh = cb.apply_changelog_decision(
+            CHANGELOG, decision, self.ALLOWED
+        )
+        assert status == "skipped"
+        assert out == CHANGELOG
+        assert gh is None
+
+
+class TestBuildComment:
+    def test_inserted(self):
+        decision = {
+            "action": "insert",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`300`: x.",
+            "amend_gh": None,
+            "skip_reason": None,
+        }
+        out = cb.build_comment("inserted", "added", decision, 300, "bob")
+        assert "entry added under **Bug fixes**" in out
+        assert "- :gh:`300`: x." in out
+        assert "credited @bob for :gh:`300`" in out
+
+    def test_amended(self):
+        decision = {
+            "action": "amend",
+            "section": None,
+            "entry_text": "- :gh:`200`: y.",
+            "amend_gh": 200,
+            "skip_reason": None,
+        }
+        out = cb.build_comment("amended", "appended", decision, 200, "bob")
+        assert "entry for :gh:`200` amended" in out
+        assert "appended :gh:`200` to @bob" in out
+
+    def test_skipped_states_reason_and_no_false_claim(self):
+        decision = {
+            "action": "skip",
+            "section": None,
+            "entry_text": None,
+            "amend_gh": None,
+            "skip_reason": "already covered.",
+        }
+        out = cb.build_comment("skipped", "skipped", decision, None, "bob")
+        assert "**not** modified (skipped): already covered." in out
+        assert "entry added" not in out
+
+
+class TestRunDecision:
+    def _setup_files(self):
+        import tempfile
+
+        d = pathlib.Path(tempfile.mkdtemp())
+        clp = d / "changelog.rst"
+        crp = d / "credits.rst"
+        clp.write_text(CHANGELOG)
+        crp.write_text(CREDITS)
+        cb.CHANGELOG_FILE = str(clp)
+        cb.CREDITS_FILE = str(crp)
+        return clp, crp
+
+    def test_amend_flow_writes_both_files(self):
+        # The incident scenario: an entry for the issue already exists,
+        # the PR amends it and the contributor is credited.
+        clp, _ = self._setup_files()
+        pr = {
+            "number": 2810,
+            "title": "Fix #200",
+            "body": "",
+            "author": "tklauser",
+            "author_name": "Tobias Klauser",
+        }
+        decision = {
+            "action": "amend",
+            "section": None,
+            "entry_text": "- :gh:`200`: bug one, now also two.",
+            "amend_gh": 200,
+            "skip_reason": None,
+        }
+        cl_status, cr_status, gh = cb.run_decision(
+            pr, decision, year="2026", get_labels=lambda _: []
+        )
+        assert cl_status == "amended"
+        assert gh == 200
+        assert "- :gh:`200`: bug one, now also two." in clp.read_text()
+        # tklauser already credited in 2026 -> append.
+        assert cr_status == "appended"
+
+    def test_skip_flow_touches_nothing(self):
+        clp, crp = self._setup_files()
+        before_cl = clp.read_text()
+        before_cr = crp.read_text()
+        pr = {
+            "number": 2810,
+            "title": "t",
+            "body": "",
+            "author": "tklauser",
+            "author_name": "Tobias Klauser",
+        }
+        decision = {
+            "action": "skip",
+            "section": None,
+            "entry_text": None,
+            "amend_gh": None,
+            "skip_reason": "already covered.",
+        }
+        cl_status, cr_status, _ = cb.run_decision(
+            pr, decision, year="2026", get_labels=lambda _: []
+        )
+        assert cl_status == "skipped"
+        assert cr_status == "skipped"
+        assert clp.read_text() == before_cl
+        assert crp.read_text() == before_cr
+
+    def test_noop_amend_reports_skip(self):
+        # Amending an entry with byte-identical text changes nothing, so
+        # the bot must report a skip, not a false "amended".
+        clp, _ = self._setup_files()
+        before = clp.read_text()
+        pr = {
+            "number": 2810,
+            "title": "t",
+            "body": "",
+            "author": "tklauser",
+            "author_name": "Tobias Klauser",
+        }
+        decision = {
+            "action": "amend",
+            "section": None,
+            "entry_text": "- :gh:`200`: bug one.",
+            "amend_gh": 200,
+            "skip_reason": None,
+        }
+        cl_status, cr_status, gh = cb.run_decision(
+            pr, decision, year="2026", get_labels=lambda _: []
+        )
+        assert cl_status == "skipped"
+        assert cr_status == "skipped"
+        assert gh is None
+        assert clp.read_text() == before
+
+    def test_insert_injects_badges_from_tracker_labels(self):
+        clp, _ = self._setup_files()
+        pr = {
+            "number": 2810,
+            "title": "Fix #300",
+            "body": "Fixes #300",
+            "author": "bob",
+            "author_name": "Bob",
+        }
+        decision = {
+            "action": "insert",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`300`, [Linux]: fix a double free.",
+            "amend_gh": None,
+            "skip_reason": None,
+        }
+        cl_status, _, _gh = cb.run_decision(
+            pr,
+            decision,
+            year="2026",
+            get_labels=lambda _: ["bug", "critical", "linux"],
+        )
+        assert cl_status == "inserted"
+        text = clp.read_text()
+        entry = "- :gh:`300`, [Linux], :label:`critical`: fix a double free."
+        assert entry in text
+        # Labelled, so it leads the section.
+        lines = text.splitlines()
+        assert lines.index(entry) < lines.index("- :gh:`200`: bug one.")
+        # The comment shows the final entry, not the model's draft.
+        assert decision["entry_text"] == entry
+
+    def test_model_written_badge_is_rejected(self):
+        self._setup_files()
+        pr = {
+            "number": 2810,
+            "title": "t",
+            "body": "Fixes #300",
+            "author": "bob",
+            "author_name": "Bob",
+        }
+        decision = {
+            "action": "insert",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`300`, :label:`critical`: sneaky.",
+            "amend_gh": None,
+            "skip_reason": None,
+        }
+        with pytest.raises(cb.ValidationError):
+            cb.run_decision(pr, decision, year="2026", get_labels=lambda _: [])
+
+    def test_validation_failure_writes_nothing(self):
+        clp, _ = self._setup_files()
+        before_cl = clp.read_text()
+        pr = {
+            "number": 2810,
+            "title": "t",
+            "body": "",
+            "author": "bob",
+            "author_name": "Bob",
+        }
+        # :gh:`777` is not referenced by the PR -> rejected.
+        decision = {
+            "action": "insert",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`777`: hallucinated.",
+            "amend_gh": None,
+            "skip_reason": None,
+        }
+        with pytest.raises(cb.ValidationError):
+            cb.run_decision(pr, decision, year="2026", get_labels=lambda _: [])
+        assert clp.read_text() == before_cl
+
+
+RELEASED_TOP = """\
+Changelog
+=========
+
+8.0.1 (2026-02-01)
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`10`: released bug.
+"""
+
+
+class TestDecisionPostRelease:
+    def test_insert_allowed_even_if_issue_in_released_block(self):
+        # The released top block has :gh:`10`; a new PR for the same
+        # issue must still insert (into a fresh dev block), not be
+        # rejected as a duplicate.
+        decision = {
+            "action": "insert",
+            "section": "Bug fixes",
+            "entry_text": "- :gh:`10`: a follow-up fix.",
+            "amend_gh": None,
+            "skip_reason": None,
+        }
+        out, status, _ = cb.apply_changelog_decision(
+            RELEASED_TOP, decision, {10}
+        )
+        assert status == "inserted"
+        assert "X.X.X (IN DEVELOPMENT)" in out
+
+    def test_amend_rejected_when_top_block_released(self):
+        # Amending released history is never allowed.
+        decision = {
+            "action": "amend",
+            "section": None,
+            "entry_text": "- :gh:`10`: rewritten released bug.",
+            "amend_gh": 10,
+            "skip_reason": None,
+        }
+        with pytest.raises(cb.ValidationError):
+            cb.apply_changelog_decision(RELEASED_TOP, decision, {10})
+
+
+class TestReleasedBlock:
+    def test_creates_dev_block_when_top_is_released(self):
+        text = """\
+Changelog
+=========
+
+8.0.1 (2026-02-01)
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`10`: released bug.
+"""
+        out = cb.insert_entry(text, "Bug fixes", "- :gh:`300`: new bug.")
+        lines = out.splitlines()
+        dev = lines.index("X.X.X (IN DEVELOPMENT)")
+        released = lines.index("8.0.1 (2026-02-01)")
+        new = lines.index("- :gh:`300`: new bug.")
+        # New dev block sits above the released one, entry inside it.
+        assert dev < new < released
+        assert lines[dev + 1] == "^" * len("X.X.X (IN DEVELOPMENT)")
+
+
+class TestGhRequest:
+    class _Resp:
+        def __init__(self, body):
+            self.body = body
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *a):
+            return False
+
+        def read(self):
+            return self.body
+
+    def _call(self, result):
+        def fake_urlopen(req, timeout=None):
+            if isinstance(result, Exception):
+                raise result
+            return self._Resp(result)
+
+        orig_open = cb.urllib.request.urlopen
+        cb.urllib.request.urlopen = fake_urlopen
+        cb.TOKEN = "x"
+        try:
+            return cb.gh_request("/x")
+        finally:
+            cb.urllib.request.urlopen = orig_open
+
+    def _http_error(self, code):
+        return cb.urllib.error.HTTPError(
+            "http://x", code, "err", {}, io.BytesIO(b"<html>boom</html>")
+        )
+
+    def test_returns_body(self):
+        assert self._call(b"ok") == b"ok"
+
+    def test_error_includes_github_body(self):
+        # A bare "HTTP Error 404" hides why GitHub refused.
+        err = self._http_error(404)
+        try:
+            with pytest.raises(SystemExit, match="boom"):
+                self._call(err)
+        finally:
+            err.close()
diff --git a/.github/workflows/tests/test_triage_labels.py b/.github/workflows/tests/test_triage_labels.py
new file mode 100644
index 0000000000..ba8fb4dec2
--- /dev/null
+++ b/.github/workflows/tests/test_triage_labels.py
@@ -0,0 +1,90 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Tests for the triage bot (.github/workflows/triage_labels.py).
+
+These cover the confidence gating, which is what keeps a shaky answer
+from deleting a label someone applied by hand. No network or API is
+used.
+"""
+
+import importlib.util
+import pathlib
+
+BOT_PATH = pathlib.Path(__file__).parent.parent / "triage_labels.py"
+
+
+def import_module_by_path(path):
+    spec = importlib.util.spec_from_file_location(path.stem, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+tl = import_module_by_path(BOT_PATH)
+
+
+def decide(**kw):
+    """A decision, confident and empty unless told otherwise.
+
+    Pass e.g. platform=["linux"], platform_confidence="low".
+    """
+    out = {
+        "type": "bug",
+        "platform": [],
+        "component": [],
+        "severity": [],
+    }
+    out.update({f"{axis}_confidence": "high" for axis in tl.AXES})
+    out.update(kw)
+    return out
+
+
+class TestFreshLabels:
+    def test_low_confidence_axis_contributes_nothing(self):
+        decision = decide(
+            platform=["linux"],
+            platform_confidence="low",
+            component=["tests"],
+        )
+        assert tl.fresh_labels(decision) == {"bug", "tests"}
+
+    def test_low_confidence_type_contributes_nothing(self):
+        decision = decide(type="bug", type_confidence="low")
+        assert tl.fresh_labels(decision) == set()
+
+
+class TestStaleLabels:
+    def test_removes_only_when_confident(self):
+        item = {"labels": ["bug", "windows"]}
+        decision = decide(platform=["linux"], platform_confidence="medium")
+        assert tl.stale_labels(item, decision) == set()
+
+        decision = decide(platform=["linux"], platform_confidence="high")
+        assert tl.stale_labels(item, decision) == {"windows"}
+
+    def test_severity_is_never_removed(self):
+        # severity is add-only: the text can suggest critical but it
+        # can never prove the absence of one.
+        item = {"labels": ["bug", "critical", "memleak"]}
+        decision = decide(severity=[], severity_confidence="high")
+        assert tl.stale_labels(item, decision) == set()
+
+    def test_confident_null_type_clears_bug(self):
+        item = {"labels": ["bug", "linux"]}
+        decision = decide(type=None, platform=["linux"])
+        assert tl.stale_labels(item, decision) == {"bug"}
+
+
+class TestDropGeneralPlatforms:
+    def test_named_os_wins_over_the_general_one(self):
+        decision = decide(platform=["unix", "linux"])
+        assert tl.fresh_labels(decision) == {"bug", "linux"}
+
+        decision = decide(platform=["bsd", "freebsd"])
+        assert tl.fresh_labels(decision) == {"bug", "freebsd"}
+
+    def test_general_one_stays_when_nothing_names_an_os(self):
+        decision = decide(platform=["unix", "pypy"])
+        assert tl.fresh_labels(decision) == {"bug", "unix", "pypy"}
diff --git a/.github/workflows/triage.py b/.github/workflows/triage.py
new file mode 100755
index 0000000000..a0c5afeabc
--- /dev/null
+++ b/.github/workflows/triage.py
@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Bot triggered by Github Actions every time a new issue or PR is
+created. Replies to common mistakes. Labelling is
+.github/workflows/triage_labels.py's job.
+"""
+
+import functools
+import json
+import os
+import pathlib
+from pprint import pprint as pp
+
+from github import Github
+
+ROOT_DIR = pathlib.Path(__file__).resolve().parent.parent.parent
+MAINTAINERS = {"giampaolo"}
+
+# --- replies
+
+REPLY_MAINTAINER_OWNED_FILES = """\
+⚠� Please **remove** your changes to `docs/changelog.rst` and / or \
+`docs/credits.rst`. ⚠�
+These two files are maintained by the project, and a \
+maintainer edits them before the PR is merged. \
+Editing them in a PR tends to cause merge conflicts. \
+This is an auto-generated response.
+"""
+
+
+# --- github API utils
+
+
+def is_pr(issue):
+    return issue.pull_request is not None
+
+
+def get_repo():
+    repo = os.environ['GITHUB_REPOSITORY']
+    token = os.environ['GITHUB_TOKEN']
+    return Github(token).get_repo(repo)
+
+
+# --- event utils
+
+
+@functools.lru_cache
+def _get_event_data():
+    with open(os.environ["GITHUB_EVENT_PATH"]) as f:
+        ret = json.load(f)
+        pp(ret)
+        return ret
+
+
+def is_event_new_pr():
+    data = _get_event_data()
+    try:
+        return data['action'] == 'opened' and 'pull_request' in data
+    except KeyError:
+        return False
+
+
+def get_issue():
+    data = _get_event_data()
+    try:
+        num = data['issue']['number']
+    except KeyError:
+        num = data['pull_request']['number']
+    return get_repo().get_issue(number=num)
+
+
+# --- actions
+
+
+def log(msg):
+    if '\n' in msg or "\r\n" in msg:
+        print(f">>>\n{msg}\n<<<", flush=True)
+    else:
+        print(f">>> {msg} <<<", flush=True)
+
+
+def on_new_pr(issue):
+    if issue.user.login in MAINTAINERS:
+        return
+    pr = get_repo().get_pull(issue.number)
+    files = [x.filename for x in pr.get_files()]
+
+    # changelog.rst / credits.rst are maintainer-owned; ask to drop them.
+    owned = ("docs/changelog.rst", "docs/credits.rst")
+    if any(f in files for f in owned):
+        log("PR edits maintainer-owned changelog/credits files")
+        issue.create_comment(REPLY_MAINTAINER_OWNED_FILES)
+
+
+def main():
+    issue = get_issue()
+    stype = "PR" if is_pr(issue) else "issue"
+    log(f"running issue bot for {stype} {issue!r}")
+
+    if is_event_new_pr():
+        log(f"created new PR {issue}")
+        on_new_pr(issue)
+    else:
+        log("unhandled event")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/.github/workflows/triage.yml b/.github/workflows/triage.yml
new file mode 100644
index 0000000000..a9502fd8d5
--- /dev/null
+++ b/.github/workflows/triage.yml
@@ -0,0 +1,42 @@
+# Fired by Github Actions every time an issue or PR is created.
+
+name: triage
+on:
+  issues:
+    types: [opened]
+  pull_request_target:
+    types: [opened]
+permissions:
+  issues: write
+  pull-requests: write
+jobs:
+  triage:
+    runs-on: ubuntu-latest
+    steps:
+      # No `ref:` on purpose. pull_request_target runs with our
+      # secrets, so checking out the PR's head would hand them over.
+      - name: Checkout
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7
+
+      - name: Install Python
+        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7
+        with:
+          python-version: "3.x"
+
+      - name: Install deps
+        run: python3 -m pip install PyGithub anthropic
+
+      - name: Reply
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          PYTHONUNBUFFERED=1 PYTHONWARNINGS=always python3 .github/workflows/triage.py
+
+      - name: Label
+        continue-on-error: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+          NUMBER: ${{ github.event.issue.number || github.event.pull_request.number }}
+        run: |
+          PYTHONUNBUFFERED=1 python3 .github/workflows/triage_labels.py "$NUMBER" --apply
diff --git a/.github/workflows/triage_labels.py b/.github/workflows/triage_labels.py
new file mode 100755
index 0000000000..03d42e995f
--- /dev/null
+++ b/.github/workflows/triage_labels.py
@@ -0,0 +1,868 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Setup the right labels for new GitHub issues and PRs by asking Claude.
+
+Usage:
+    python3 .github/workflows/triage_labels.py 2635
+    python3 .github/workflows/triage_labels.py 2635 1783 2029
+    python3 .github/workflows/triage_labels.py 2635 --apply
+"""
+
+import argparse
+import json
+import os
+import re
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+
+REPO = "giampaolo/psutil"
+HTTP_TIMEOUT = 30
+MAX_BODY_CHARS = 6000
+MAX_FILES = 100
+MAX_TOKENS = 2048
+
+# Set by parse_cli().
+TOKEN = ""
+MODEL = ""
+NUMBERS = []
+APPLY = False
+
+PROMPT = """\
+You are triaging a psutil issue or pull request. psutil is a Python
+library that reads process and system information, with a Python layer
+per platform (_pslinux.py, _pswindows.py, ...) backed by C extensions.
+
+Type is bug or null. Platform, component and severity are lists and
+may name more than one, though most items need a platform and little
+else. On the three lists, leave it empty rather than reaching for a
+label that only half fits: a wrong label is worse than no label.
+
+TYPE
+
+- bug: something is broken, wrong, or crashes.
+
+That is the only type. There is no label for the rest: a new feature,
+a speedup, a refactor or a question simply isn't a bug, so answer
+null, and let the component list say which kind of not-a-bug it is. A
+confident null is also what clears a bug label that shouldn't be
+there.
+
+The template's "Bug fix: yes/no" line is a hint, not the answer. Read
+what the change does. Adding support for something that never worked
+is not a bug even when the author ticked yes.
+
+PLATFORM
+
+Fill this only when the item is specific to where psutil runs: an OS,
+a container, a different cPython implementation (PYPY). A bug that would
+happen anywhere is an empty list, even when the reporter happens to be
+on Linux.
+
+A "[Linux]" tag in the title or a filled-in "* OS: ..." line is the
+reporter saying it outright, so take them at their word. When they
+name two or three, list all of them. These mix freely, so a container
+bug on Linux is ["linux", "vm"].
+
+On a PR, the changed files outrank that line. People fill the template
+in loosely and it is often stale or plain wrong: a PR whose only file
+is .github/workflows/tests.yml has no platform, whatever its "OS:"
+line claims. Believe the diff.
+
+Going wide is the opposite of specific, so leave it empty. A sweep
+across every arch/ directory, a refactor of shared code, anything that
+lands everywhere: no platform at all. Four or more is nearly always
+this mistake. Don't read a PR's changed files as a list of platforms
+to claim.
+
+That rule is about the diff, not the title. Names written in the title
+always count, tagged or not: "[Windows/Linux/Mac] ..." and "publish
+macos and linux wheels" each name platforms out loud, so list them.
+An environment counts as the OS it runs on, so cygwin and msys are
+windows.
+
+One path does settle it. psutil/arch/ holds a directory per platform,
+and a diff that stays inside one of them says which: arch/windows/ is
+windows, arch/osx/ is macos, arch/solaris/ is sunos, arch/bsd/ is bsd,
+arch/posix/ is unix. Only arch/all/ is everywhere. Land in two of them
+and you're back to the sweep above.
+
+An OS named in passing is not the subject either. "Known cases are
+AccessDenied on Windows and a null ctime on NetBSD" is a cross-platform
+bug illustrated with examples, so the list stays empty. "OS: all" means
+empty no matter which names follow it. Ask what the fix changes, not
+where the symptom was noticed.
+
+
+- linux, windows, macos, freebsd, openbsd, netbsd, sunos, aix: the
+  item is about that OS.
+
+- bsd: the item is about the BSDs as a family. "on all 3 BSDs", a
+  "[BSD]" tag, a fix in the shared psutil/arch/bsd/ code. Listing the
+  three by name changes nothing: "all 3 BSDs (FreeBSD, OpenBSD,
+  NetBSD)" is still one bsd label, not three. Reach for the specific
+  ones only when the item is about some of them but not all.
+
+- unix: very rare. Shared POSIX code across several unices where no
+  single OS fits and the item names none. Something POSIX has and
+  Windows doesn't counts even with nothing named: zombie processes,
+  signals, uid and gid, fork, terminals. So does a diff confined to
+  psutil/arch/posix/ or _psutil_posix.c. It stands alone: the moment
+  you can name one OS, list that instead.
+
+- vm: any container or virtual OS, Docker included. Only when it's
+  material, not merely where the reporter happened to run.
+
+- pypy: the item is about running under PyPy, not CPython.
+
+COMPONENT
+
+Usually empty. Roughly half of all items are just a platform bug with
+no component at all. Two is common enough: a cibuildwheel change in a
+workflow file is ["packaging", "ci"]. Three is rarer but real, and a
+CI change to the wheel build that is also a speedup earns all three.
+Four is almost certainly wrong.
+
+The rule for all of them: the item has to be *specific* to the
+component, not merely touch it. A new feature updates the docs, adds
+tests and maybe a script, and it is still just the feature. Only reach
+for a component label when it is what the item is for. These get
+over-applied, so the labels already in the repo are a poor guide. When
+in doubt, leave the list empty.
+
+
+- doc: prose under docs/, the README, docstrings, the doc build or
+  theme. A docstring-only fix counts even though it lives in a .py
+  file. A feature or bugfix that updates the docs on the way past
+  does not: that one is the feature or the bug.
+
+- tests: the test suite and nothing else. A flaky test, a slow test, a
+  test asserting the wrong thing, a skip, a test helper. For a PR the
+  changed files settle it: touching library code (psutil/*.py,
+  psutil/arch/, the C extensions) means the PR is about that code, so
+  no; tests plus boilerplate like HISTORY.rst or the Makefile is fine.
+  A reported test failure that turns out to be a real bug is that bug,
+  and the PR fixing it gets the bug's labels, never this one.
+
+- ci: psutil's own automation. Anything under .github/workflows/, plus
+  cirrus, appveyor and travis. A "CI:" prefix in the title says it
+  outright, so take it. The runners and the test matrix, but
+  equally the bots and release jobs that never run a test: a changed
+  workflow file is nearly always this. Also a job failing for reasons
+  unrelated to the code under test.
+
+- scripts: psutil's own scripts/ directory, including the examples.
+  Not the reporter's script. People often paste one to show a bug;
+  that bug is about whatever it exercises.
+
+- internals: psutil's own machinery, with no effect on the public
+  API. Debug output, internal helpers and refactorings, the Makefile,
+  linters and formatters. ci, tests and scripts are its more specific
+  siblings, so reach for internals only when none of them fits.
+
+- packaging: what psutil ships and how it's built. Wheels, the sdist,
+  the build backend, what gets installed. The release matrix,
+  manylinux, a wheel missing from PyPI. cibuildwheel settles it on
+  its own: an item that touches it is about packaging, even when the
+  change is to the workflow around it, in which case it is ci as
+  well. A compile error on the reporter's own machine is the
+  build-fail severity instead.
+
+- new-api: the public API grows. A brand new function or method, but
+  equally a new argument on one that already exists, a new field in a
+  namedtuple it returns, a new value it can now give back. Anything
+  that hands callers something they couldn't reach before. Making an
+  existing call work on one more platform is not this.
+
+- api-change: an existing public API changed, was deprecated or was
+  removed. A rename, a changed field, a different return type, a new
+  deprecation warning. The counterpart of new-api, which is for
+  growth. When working code has to change, add compatibility too.
+
+- performance: speed or resource usage is the point. Slow is
+  performance, wrong is a bug. psutil's own build and CI count too:
+  making the suite, the wheel build or a workflow faster is
+  performance, on top of ci or packaging. A timing table, or a
+  benchmark showing timings before and after, is the giveaway. So is
+  releasing and reacquiring the GIL around a blocking syscall,
+  numbers or no numbers: the whole point is letting other threads
+  run.
+
+- compatibility: psutil's support matrix moves, or what callers can
+  rely on does. Dropping an old Python or OS version, or restoring
+  one psutil had lost. Dropping a wheel target or an interpreter
+  build, removing a dependency that moves the floor psutil builds
+  on, removing or renaming a public API, dropping a field from a
+  namedtuple. The test is whether a working install or working code
+  has to change. Correcting a value that was simply wrong is not
+  this, it's the bug fix, and a one-off build error on a platform
+  psutil already supports is a plain bug, not a change of support.
+
+- dropped-support: a platform, OS version or Python version is no
+  longer supported. Nearly always compatibility as well, since
+  installs that worked have to change.
+
+- new-platform: support for an operating system psutil does not target
+  yet.
+
+SEVERITY
+
+Ways a bug can be worse than a wrong answer. Usually none applies.
+More than one at once is rare, but allowed. These become colored
+badges in the changelog, so a wrong one is very visible.
+
+- critical: the process doesn't survive, or its memory is no longer
+  trustworthy. A segfault, a use-after-free, a double free, a buffer
+  overflow, an abort. A deadlock or a hang counts too: the process is
+  still there but it's never coming back. So does blowing up at
+  import time: whatever the exception, ``import psutil`` took the
+  program down before it started. A DLL or extension that won't load
+  is build-fail instead, since that build never worked.
+
+- build-fail: psutil doesn't compile or link. A missing header, an
+  undeclared constant, an undefined symbol, a compiler that chokes on
+  the source. The reporter's own toolchain counts: no Python.h, no C
+  compiler installed, the wrong MSVC. So does an extension that built
+  but won't load for an undefined symbol. A test that fails, a
+  compile warning and a wheel missing from PyPI are not this. It
+  never pairs with critical: nothing ever ran, so no runtime failure
+  applies.
+
+- memleak: memory is leaked. Growth without bound, but also a single
+  allocation, handle or refcount never released, error paths
+  included. If the text says leak and points at what leaks, that's
+  this.
+
+- badexc: psutil raises something it isn't allowed to. The public API
+  may raise NoSuchProcess, AccessDenied, ZombieProcess and
+  TimeoutExpired, and nothing else. Anything else getting out is this:
+  a RuntimeError, a SystemError, an OSError, a KeyError, an IndexError,
+  a UnicodeDecodeError. FileNotFoundError and PermissionError count as
+  well, being exactly what psutil should have turned into NoSuchProcess
+  and AccessDenied.
+
+  This is about the type, never the timing. One of those four raised
+  when it shouldn't have been, a false NoSuchProcess on a process that
+  is still alive say, is a wrong answer: a plain bug, not badexc.
+
+  Near misses, none of them badexc: an AssertionError is a test
+  failing. An ImportError or a DLL that won't load is a build that
+  didn't work. An AttributeError on a name that's gone is a caller on
+  an old API. NotImplementedError is how psutil says the platform
+  can't answer. A warning is not an exception. ValueError and
+  TypeError on a bad argument are the API working, though one escaping
+  a /proc or registry parse does count.
+
+It has to be psutil doing it: people paste whole tracebacks from
+whatever program hit the problem, so find psutil in the failing frame
+first. A wrong value, a slow call and a leak are plain bugs however
+annoying. So is a build that won't compile, which never got as far as
+running. An umbrella issue cataloguing ten crashes is about the audit,
+not any one crash, but a PR that fixes several things carries all of
+them: "[SunOS] various fixes" can end up with both labels.
+
+CONFIDENCE
+
+Give type, platform, component and severity a confidence. Use low when
+the text is too thin to tell, so the choice can be discarded later. For
+type, platform and component an empty answer with high confidence means
+you are sure nothing applies, and is what lets a wrong label already on
+the ticket be cleared. Severity is only ever added, never taken away,
+so an empty one says nothing about what the ticket already carries.
+
+EXAMPLES
+
+Title: "Process.memory_info() returns 0 for all processes on Windows 11"
+type=bug, platform=["windows"], component=[]. A plain platform bug,
+which is the most common shape. No component label applies.
+
+Title: "add Process.num_threads() to the AIX implementation"
+type=null, platform=["aix"], component=["new-api"].
+
+Title: "test_disk_partitions fails on the macOS runner since the image
+bump"
+type=bug, platform=["macos"], component=["ci"]. The suite is fine; the
+runner image changed. Not tests.
+
+Title: "test_cpu_percent asserts the wrong bound"
+type=bug, platform=[], component=["tests"]. The test code is wrong, and
+it is wrong everywhere.
+
+Title: "[SunOS] test_unix fails: invalid kind argument 'unix'"
+type=bug, platform=["sunos"], component=[]. A test is how this
+surfaced, but net_connections() really is missing a kind on SunOS.
+Fix the code and the test goes green, so the bug is the item.
+
+Title: "cpu_times() is 3x slower than it needs to be"
+type=null, component=["performance"]. Slow, not wrong.
+
+Title: "[OpenBSD, NetBSD] build failed"
+type=bug, platform=["openbsd", "netbsd"], severity=["build-fail"].
+Both named, so both go in. Not bsd.
+
+Title: "IOError on import when /proc/stat is inaccessible"
+type=bug, platform=["linux"], severity=["critical"]. The build is
+fine; ``import psutil`` itself blows up, taking the program with it.
+
+Title: "macOS: fix SystemError in Process.cmdline() and environ()"
+type=bug, platform=["macos"], severity=["badexc"]. SystemError isn't
+one of the four psutil is allowed to raise, so it counts however
+small the fix turns out to be.
+
+Title: "False NoSuchProcess('PID has been reused') on a process that is
+still alive"
+type=bug, platform=[], severity=[]. NoSuchProcess *is* one of the four.
+Raising it at the wrong moment is a wrong answer, not badexc.
+
+Title: "[Windows] win_service_iter() can segfault on enumeration
+failure"
+type=bug, platform=["windows"], severity=["critical"]. The process
+dies. Nothing was raised, so no badexc.
+
+Title: "[Windows] net_if_stats() reports the wrong link speed"
+type=bug, platform=["windows"], severity=[]. A wrong number is a
+plain bug. Nothing got out and nothing died.
+
+Title: "Fix refcount leaks on parse failure (Linux disk_partitions,
+SunOS proc)"
+type=bug, platform=["linux", "sunos"], severity=["memleak"]. Both
+named, and a leak down an error path is still a leak.
+
+Title: "Rename Process.connections() to Process.net_connections()"
+type=null, component=["api-change", "compatibility"]. An existing API
+moved, and code that wants to stay warning-free has to follow.
+
+Title: "Drop Python 3.6 and 3.7"
+type=null, component=["dropped-support", "compatibility"]. Installs
+that worked have to change. No platform: this isn't about where
+psutil runs.
+
+Title: "Upgrade cibuildwheel to 4.1.1, drop cp313t wheels"
+type=null, component=["packaging", "ci", "compatibility"].
+cibuildwheel means packaging, it lands in a workflow so ci, and
+dropping a build target narrows what we ship. Three is unusual and
+here it's right.
+
+Title: "docs: add explanatory comments to the README examples"
+type=null, component=["doc"]. Prose and nothing else, so doc is what
+the item is for rather than something it touched on the way past.
+
+Answer with the submit tool."""
+
+# Kept out of PROMPT so the cached prefix is byte-identical between
+# tickets. Anything ticket-specific has to live after the breakpoint.
+TICKET = """\
+Kind: {kind}
+Title: {title}
+
+Body:
+{body}
+{files}"""
+
+
+# --- the label taxonomy, as axes
+#
+# The axis names come from the label descriptions on GitHub.
+
+TYPE_LABELS = ["bug"]
+PLATFORM_LABELS = [
+    "linux", "windows", "macos", "freebsd", "openbsd", "netbsd", "bsd",
+    "sunos", "aix", "unix", "vm", "pypy",
+]  # fmt: skip
+SEVERITY_LABELS = ["critical", "badexc", "build-fail", "memleak"]
+COMPONENT_LABELS = [
+    "doc", "tests", "ci", "scripts", "internals", "packaging",
+    "new-api", "api-change", "performance", "compatibility",
+    "dropped-support", "new-platform",
+]  # fmt: skip
+
+# The model never sees these, and they're stripped before comparing.
+IGNORED_LABELS = {
+    "imported",
+    "need-more-info",
+    "dependencies",
+    "github_actions",
+}
+
+AXES = ("type", "platform", "component", "severity")
+LIST_AXES = ("platform", "component", "severity")
+AXIS_LABELS = {
+    "type": TYPE_LABELS,
+    "platform": PLATFORM_LABELS,
+    "component": COMPONENT_LABELS,
+    "severity": SEVERITY_LABELS,
+}
+# severity is missing on purpose. The text can suggest it but never
+# rule it out, so we add those and never take them away.
+REMOVABLE_AXES = ("type", "platform", "component")
+
+
+def enum_list(labels, description):
+    return {
+        "type": "array",
+        "items": {"type": "string", "enum": labels},
+        "description": description,
+    }
+
+
+GENERAL_PLATFORMS = {
+    "bsd": {"freebsd", "openbsd", "netbsd"},
+    "unix": {
+        "aix",
+        "bsd",
+        "freebsd",
+        "linux",
+        "macos",
+        "netbsd",
+        "openbsd",
+        "sunos",
+    },
+}
+
+
+def drop_general_platforms(labels):
+    """Drop unix / bsd when the same answer also names an OS."""
+    out = set(labels)
+    for general, specific in GENERAL_PLATFORMS.items():
+        if out & specific:
+            out.discard(general)
+    return out
+
+
+def axis_values(decision, axis):
+    """What a decision puts on one axis, always as a set."""
+    value = decision[axis]
+    if axis in LIST_AXES:
+        return set(value)
+    return {value} if value else set()
+
+
+CONFIDENCE = {"type": "string", "enum": ["high", "medium", "low"]}
+
+DECISION_PROPS = {
+    "type": {
+        "anyOf": [
+            {"type": "string", "enum": ["bug"]},
+            {"type": "null"},
+        ],
+        "description": "bug when something is broken, else null.",
+    },
+    "type_confidence": CONFIDENCE,
+    "platform": enum_list(
+        PLATFORM_LABELS,
+        "Every OS, container or interpreter the item is specific to."
+        " Often empty.",
+    ),
+    "platform_confidence": CONFIDENCE,
+    "component": enum_list(
+        COMPONENT_LABELS,
+        "What the item is specifically about. Usually empty, sometimes two.",
+    ),
+    "component_confidence": CONFIDENCE,
+    "severity": enum_list(
+        SEVERITY_LABELS,
+        "critical when the process dies or memory is corrupt,"
+        " build-fail when psutil won't compile, memleak when memory is"
+        " leaked, badexc when psutil raises something it shouldn't."
+        " Usually empty.",
+    ),
+    "severity_confidence": CONFIDENCE,
+}
+
+SUBMIT_TOOL = {
+    "name": "submit",
+    "description": "Submit the label decision for this issue or PR.",
+    # Without this the schema is advisory: seen returning a single
+    # out-of-enum field, and nesting the payload under "parameter name".
+    "strict": True,
+    "input_schema": {
+        "type": "object",
+        "additionalProperties": False,
+        "properties": DECISION_PROPS,
+        "required": list(DECISION_PROPS),
+    },
+}
+
+# --- github
+
+
+def gh_request(path, post=None, method=None):
+    req = urllib.request.Request(
+        f"https://api.github.com{path}",
+        data=json.dumps(post).encode() if post else None,
+        method=method,
+        headers={
+            "Authorization": f"Bearer {TOKEN}",
+            "Accept": "application/vnd.github+json",
+            "Content-Type": "application/json",
+            "X-GitHub-Api-Version": "2022-11-28",
+        },
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=HTTP_TIMEOUT) as resp:
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as err:
+        body = err.read().decode("utf-8", errors="replace")
+        sys.exit(f"GitHub API {err.code} for {path}: {body}")
+
+
+def fetch_item(number):
+    """One issue or PR, in the shape classify() wants."""
+    raw = gh_request(f"/repos/{REPO}/issues/{number}")
+    item = {
+        "number": raw["number"],
+        "title": raw["title"],
+        "body": raw.get("body") or "",
+        "is_pr": "pull_request" in raw,
+        "labels": sorted(x["name"] for x in raw["labels"]),
+        "files": [],
+        "by_bot": (raw.get("user") or {}).get("type") == "Bot",
+    }
+    if item["is_pr"]:
+        files = gh_request(f"/repos/{REPO}/pulls/{number}/files")
+        item["files"] = [f["filename"] for f in files][:MAX_FILES]
+    return item
+
+
+# "Fixes #123", "closes gh-123", or the full issue URL.
+CLOSES = re.compile(
+    r"\b(?:fix(?:e[sd])?|close[sd]?|resolve[sd]?)\b[\s:]*"
+    r"(?:https?://github\.com/[\w.-]+/[\w.-]+/issues/|gh-|#)(\d+)",
+    re.IGNORECASE,
+)
+
+
+def closed_issues(item):
+    if not item["is_pr"]:
+        return []
+    seen = []
+    for match in CLOSES.finditer(item["body"][:MAX_BODY_CHARS]):
+        number = int(match.group(1))
+        if number != item["number"] and number not in seen:
+            seen.append(number)
+    return seen
+
+
+def inherit_from_closed(labels, issue_labels):
+    """Take critical, build-fail and memleak from the issue a PR
+    closes.
+
+    The issue quotes the traceback, the PR just says "handle EFAULT",
+    so the same defect reads as critical on one and not the other.
+
+    Sharing a platform is what says the PR really is the fix. "chore:
+    test with Python 3.12" closes a Windows bug without being its fix
+    and inherits nothing.
+    """
+    out = set(labels)
+    ours = out & set(PLATFORM_LABELS)
+    theirs = set(issue_labels) & set(PLATFORM_LABELS)
+    if (ours & theirs) or not (ours or theirs):
+        out |= {"critical", "build-fail", "memleak"} & set(issue_labels)
+    return out
+
+
+def add_labels(number, labels):
+    """Add labels to a ticket. This endpoint never removes any."""
+    gh_request(
+        f"/repos/{REPO}/issues/{number}/labels", {"labels": sorted(labels)}
+    )
+
+
+def remove_label(number, label):
+    path = urllib.parse.quote(label)
+    gh_request(f"/repos/{REPO}/issues/{number}/labels/{path}", method="DELETE")
+
+
+def fresh_labels(decision):
+    """The labels a decision is willing to stand behind.
+
+    Low means the model is guessing, so that axis contributes nothing.
+    Medium still counts: a third of the corpus lands there and it's
+    right most of the time.
+    """
+    out = set()
+    for axis in AXES:
+        if decision[f"{axis}_confidence"] != "low":
+            out |= axis_values(decision, axis)
+    return drop_general_platforms(out)
+
+
+def stale_labels(item, decision, from_bot=()):
+    """Labels the model just contradicted on the same axis.
+
+    Only where it was sure, since medium or low means "I can't tell"
+    and that's no reason to delete what a person put there. A confident
+    empty answer does count, and is the only way a wrong label ever
+    gets cleared.
+
+    from_bot is what the old regex bot applied; that comes off on
+    medium too.
+    """
+    keep = model_labels(decision)
+    out = set()
+    for axis in REMOVABLE_AXES:
+        conf = decision[f"{axis}_confidence"]
+        if conf == "high":
+            out |= {x for x in item["labels"] if x in AXIS_LABELS[axis]} - keep
+        elif conf == "medium" and axis == "component":
+            # The bot read components off the template's "Type:" line,
+            # which reporters fill in by ticking everything. Its
+            # platforms came from "[Linux]" title tags and are usually
+            # right, so those stay protected.
+            botted = {x for x in item["labels"] if x in AXIS_LABELS[axis]}
+            out |= (botted & set(from_bot)) - keep
+    return out
+
+
+# --- the model
+
+
+class BadDecision(Exception):
+    """The model's tool call doesn't match the schema."""
+
+
+def allowed_values(prop):
+    """The values a schema property accepts, None if unconstrained."""
+    if "enum" in prop:
+        return prop["enum"]
+    if prop.get("type") == "array":
+        return prop["items"]["enum"]
+    for branch in prop.get("anyOf", []):
+        if "enum" in branch:
+            return [*branch["enum"], None]
+    return None
+
+
+def build_prompt(title, body, files):
+    listing = ""
+    if files:
+        names = "\n".join(f"- {f}" for f in files)
+        listing = f"\nChanged files:\n{names}\n"
+    return TICKET.format(
+        # An issue has no changed files, a PR always has at least one.
+        kind="pull request" if files else "issue",
+        title=title,
+        body=body[:MAX_BODY_CHARS] or "(empty)",
+        files=listing,
+    )
+
+
+def check_decision(decision):
+    """Fail loud on a decision that doesn't match the schema.
+
+    strict=True should make this unreachable, but a malformed decision
+    reads downstream as "no labels" and quietly poisons the result,
+    which has already happened once.
+    """
+    unknown = set(decision) - set(DECISION_PROPS)
+    missing = set(DECISION_PROPS) - set(decision)
+    if unknown or missing:
+        raise BadDecision(
+            f"bad keys (unknown={sorted(unknown)},"
+            f" missing={sorted(missing)}): {decision}"
+        )
+    for name, value in decision.items():
+        allowed = allowed_values(DECISION_PROPS[name])
+        if allowed is None:
+            continue
+        if not isinstance(value, list):
+            value = [value]
+        elif len(set(value)) != len(value):
+            raise BadDecision(f"{name}={value!r} has duplicates")
+        for one in value:
+            if one not in allowed:
+                raise BadDecision(f"{name}={one!r} not in {allowed}")
+
+
+def thinking_kwargs():
+    if MODEL.startswith(
+        ("claude-opus-5", "claude-sonnet-5", "claude-fable-5")
+    ):
+        return {
+            "thinking": {"type": "adaptive"},
+            "output_config": {"effort": "low"},
+        }
+    return {}
+
+
+def classify(client, title, body, files):
+    """Ask Claude which labels apply.
+
+    Returns (decision, usage). Pass files=None for an issue. Raises
+    BadDecision when the tool call doesn't validate, so a bad answer
+    can't pass for an empty one.
+    """
+    message = client.messages.create(
+        model=MODEL,
+        max_tokens=MAX_TOKENS,
+        **thinking_kwargs(),
+        tools=[SUBMIT_TOOL],
+        tool_choice={"type": "tool", "name": "submit"},
+        # No caching. The 5 minute TTL never survives to the next
+        # issue, so it only ever pays for the write.
+        system=PROMPT,
+        messages=[
+            {"role": "user", "content": build_prompt(title, body, files)}
+        ],
+    )
+    if message.stop_reason == "max_tokens":
+        raise BadDecision("response truncated (raise MAX_TOKENS)")
+    block = next((b for b in message.content if b.type == "tool_use"), None)
+    if block is None:
+        raise BadDecision(f"no tool call (stop_reason={message.stop_reason})")
+    check_decision(block.input)
+    return block.input, message.usage
+
+
+def model_labels(decision):
+    """Flatten a decision into the label set it implies."""
+    out = set()
+    for axis in AXES:
+        out |= axis_values(decision, axis)
+    return out
+
+
+# --- cli
+
+
+def make_client():
+    import anthropic
+
+    key = os.environ.get("ANTHROPIC_API_KEY", "").strip()
+    if not key:
+        path = os.path.expanduser("~/.anthropic.api.key")
+        if not os.path.exists(path):
+            sys.exit(f"no ANTHROPIC_API_KEY and no {path}")
+        with open(path) as f:
+            key = f.read().strip()
+    return anthropic.Anthropic(api_key=key)
+
+
+def fmt(labels):
+    return ", ".join(sorted(labels)) if labels else "-"
+
+
+def report(item, decision):
+    kind = "PR" if item["is_pr"] else "issue"
+    print(f"#{item['number']} ({kind}) {item['title']}")
+    for axis in AXES:
+        conf = decision.get(f"{axis}_confidence")
+        suffix = f"  ({conf})" if conf else ""
+        print(f"  {axis:12s} {fmt(axis_values(decision, axis))}{suffix}")
+    print(f"  already has: {fmt(set(item['labels']) - IGNORED_LABELS)}")
+
+
+def parse_cli():
+    global TOKEN, MODEL, NUMBERS, APPLY
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("numbers", nargs="+", type=int, help="issue or PR numbers")
+    p.add_argument(
+        "--token",
+        default="~/.github.api.key",
+        help="file holding a GitHub token. GITHUB_TOKEN wins.",
+    )
+    p.add_argument("--model", default="claude-sonnet-5")
+    p.add_argument(
+        "--apply",
+        action="store_true",
+        help="add the labels on GitHub; without this nothing is written",
+    )
+    args = p.parse_args()
+    TOKEN = os.environ.get("GITHUB_TOKEN", "").strip()
+    if not TOKEN:
+        with open(os.path.expanduser(args.token)) as f:
+            TOKEN = f.read().strip()
+    MODEL = args.model
+    NUMBERS = args.numbers
+    APPLY = args.apply
+
+
+def show_tokens(prefix, usage):
+    # input_tokens excludes the cache write, which is most of it.
+    print(
+        f"  {prefix:12s} {usage.input_tokens} in,"
+        f" {usage.cache_creation_input_tokens} written,"
+        f" {usage.cache_read_input_tokens} cached,"
+        f" {usage.output_tokens} out"
+    )
+
+
+def handle(item, decision, usage, totals, index):
+    """Print one decision and, with --apply, act on it."""
+    if index:
+        print()
+    report(item, decision)
+    if usage is not None:
+        for field in totals:
+            totals[field] += getattr(usage, field)
+        show_tokens("tokens:", usage)
+    judged = fresh_labels(decision)
+    for number in closed_issues(item):
+        try:
+            linked = fetch_item(number)["labels"]
+            judged = inherit_from_closed(judged, linked)
+        except SystemExit:
+            # The issue may be gone, or in another repo. Not a reason
+            # to give up on labelling the PR.
+            print(f"  (couldn't read #{number}, ignoring the link)")
+    add = judged - set(item["labels"])
+    drop = stale_labels(item, decision)
+    print(f"  to add:      {fmt(add)}")
+    print(f"  to drop:     {fmt(drop)}")
+    if not (add or drop):
+        return
+    if not APPLY:
+        print("  (--apply to do it)")
+        return
+    if add:
+        add_labels(item["number"], add)
+    for label in sorted(drop):
+        remove_label(item["number"], label)
+    print("  applied")
+
+
+def run(totals):
+    client = make_client()
+    for index, number in enumerate(NUMBERS):
+        item = fetch_item(number)
+        if item["by_bot"]:
+            print(f"#{number}: opened by a bot, skipping")
+            continue
+        try:
+            decision, usage = classify(
+                client, item["title"], item["body"], item["files"]
+            )
+        except BadDecision as err:
+            sys.exit(f"#{number}: {err}")
+        handle(item, decision, usage, totals, index)
+
+
+def main():
+    parse_cli()
+    totals = dict.fromkeys(
+        (
+            "input_tokens",
+            "cache_creation_input_tokens",
+            "cache_read_input_tokens",
+            "output_tokens",
+        ),
+        0,
+    )
+    run(totals)
+    if len(NUMBERS) > 1 and totals["output_tokens"]:
+        print(
+            f"\ntotal: {totals['input_tokens']} in,"
+            f" {totals['cache_creation_input_tokens']} written,"
+            f" {totals['cache_read_input_tokens']} cached,"
+            f" {totals['output_tokens']} out"
+        )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml
new file mode 100644
index 0000000000..3a5b7331bf
--- /dev/null
+++ b/.github/workflows/wheels.yml
@@ -0,0 +1,134 @@
+# Generates wheels for all platforms, architectures and free-threaded builds,
+# then checks the resulting distribution. Tests are run by tests.yml.
+#
+# Useful URLs:
+# * https://github.com/pypa/cibuildwheel
+# * https://github.com/astral-sh/setup-uv
+# * https://github.com/docker/setup-qemu-action
+# * https://github.com/actions/cache
+# * https://github.com/actions/checkout
+# * https://github.com/actions/download-artifact
+# * https://github.com/actions/setup-python
+# * https://github.com/actions/upload-artifact
+
+on:
+  workflow_dispatch:
+  push:
+    paths-ignore:
+      - "docs/**"
+  pull_request:
+    paths-ignore:
+      - "docs/**"
+name: wheels
+concurrency:
+  # Cancel run if a new one starts, but don't interrupt all jobs on the first
+  # failure.
+  group: wheels-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  wheels:
+    name: "${{ matrix.osname }} ${{ matrix.archname || matrix.arch }}${{ matrix.tag && format(' ({0})', matrix.tag) || '' }}"
+    # Skip same-repo PR runs: the push event already covers them.
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 10
+    strategy:
+      fail-fast: false
+      # We produce an abi3 wheel which works from Python 3.8 onwards. We
+      # generate it on Python 3.14, which is faster.
+      matrix:
+        include:
+          # manylinux and musllinux share a runner, so give them a lane each
+          # instead of building one set after the other.
+          - { os: ubuntu-latest, osname: linux, arch: x86_64, build: "cp314{,t}-manylinux*", tag: manylinux }
+          - { os: ubuntu-latest, osname: linux, arch: x86_64, build: "cp314-musllinux*", tag: musllinux }
+          - { os: ubuntu-24.04-arm, osname: linux, arch: aarch64, build: "cp314{,t}-manylinux*", tag: manylinux }
+          - { os: ubuntu-24.04-arm, osname: linux, arch: aarch64, build: "cp314-musllinux*", tag: musllinux }
+          - { os: ubuntu-latest, osname: linux, arch: ppc64le, build: "cp314-manylinux*", tag: abi3, qemu: ppc64le }
+          - { os: ubuntu-latest, osname: linux, arch: s390x, build: "cp314-manylinux*", tag: abi3, qemu: s390x }
+          # Cross-builds x86_64 under Rosetta, so one runner covers both arches
+          # (faster).
+          - { os: macos-15, osname: macos, arch: "arm64 x86_64", archname: both, build: "cp314-*", tag: abi3 }
+          - { os: macos-15, osname: macos, arch: "arm64 x86_64", archname: both, build: "cp314t-*", tag: cp314t }
+          # Same idea for Windows.
+          - { os: windows-2025, osname: win, arch: AMD64, build: "cp314-*", tag: abi3 }
+          - { os: windows-2025, osname: win, arch: AMD64, build: "cp314t-*", tag: cp314t }
+          - { os: windows-11-arm, osname: win, arch: ARM64, build: "cp314-*", tag: abi3 }
+          - { os: windows-11-arm, osname: win, arch: ARM64, build: "cp314t-*", tag: cp314t }
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Set up QEMU
+        if: matrix.qemu
+        uses: docker/setup-qemu-action@v4
+        with:
+          platforms: ${{ matrix.qemu }}
+
+      # Cache the CPython interpreters cibuildwheel downloads, so later pushes
+      # reuse them. Windows only: Linux takes them from the container, and
+      # macOS installs a .pkg into /Library/Frameworks, leaving nothing behind
+      # to cache. Worth ~90 secs on Windows, measured by removing it (see
+      # #2931).
+      - name: Cache cibuildwheel interpreters
+        if: runner.os == 'Windows'
+        uses: actions/cache@v6
+        with:
+          path: ${{ runner.temp }}/cibw-cache
+          # Refresh the cache every time wheels.yml or pyproject.toml change.
+          # restore-keys falls back to the previous entry meanwhile, so an
+          # unrelated edit doesn't mean re-downloading everything.
+          key: cibw-${{ runner.os }}-${{ matrix.arch }}-${{ matrix.tag || 'all' }}-${{ hashFiles('.github/workflows/wheels.yml', 'pyproject.toml') }}
+          restore-keys: cibw-${{ runner.os }}-${{ matrix.arch }}-${{ matrix.tag || 'all' }}-
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v9.0.0
+        with:
+          version: "0.12.3"
+
+      # Not pypa/cibuildwheel: that action pip-installs itself from an sdist on
+      # every lane, which takes ~18 secs instead of ~5.
+      - name: Build wheels
+        shell: bash
+        run: uvx --from 'cibuildwheel==4.1.1' cibuildwheel --output-dir wheelhouse
+        env:
+          CIBW_ARCHS: "${{ matrix.arch }}"
+          CIBW_BUILD: "${{ matrix.build }}"
+          CIBW_CACHE_PATH: ${{ runner.temp }}/cibw-cache
+          CIBW_BUILD_FRONTEND: "build[uv]"
+          CIBW_TEST_COMMAND: 'python -W error::RuntimeWarning -c "import psutil; print(psutil.__version__)"'
+          # Disabled, "make ci-check-dist" does it already.
+          CIBW_AUDIT_COMMAND: ""
+          # Pin it, else it follows whichever Python builds the wheel.
+          CIBW_ENVIRONMENT_MACOS: MACOSX_DEPLOYMENT_TARGET=10.15
+          # We only link Windows system DLLs, so there's nothing for delvewheel
+          # to bundle.
+          CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: ""
+
+      - name: Upload wheels
+        uses: actions/upload-artifact@v7
+        with:
+          name: wheels-${{ matrix.os }}-${{ matrix.archname || matrix.arch }}-${{ matrix.tag || 'all' }}
+          path: wheelhouse
+          compression-level: 0
+
+  # Merge wheels and check sanity of the package distribution.
+  check-dist:
+    needs: [wheels]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: 3.x
+      - uses: actions/download-artifact@v8
+        with:
+          pattern: wheels-*
+          path: wheelhouse
+          merge-multiple: true
+      - run: |
+          make ci-check-dist
+      - uses: actions/upload-artifact@v7
+        with:
+          name: wheels
+          path: dist/*.whl
+          compression-level: 0
diff --git a/.gitignore b/.gitignore
index 99d0d54571..3d8f05eaff 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,8 +11,12 @@ syntax: glob
 *.rej
 *.so
 *.swp
+.failed-tests.txt
 .cache/
 .idea/
 .tox/
 build/
+docs/_build/
 dist/
+wheelhouse/
+.tests/
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 17206c58a5..0000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,39 +0,0 @@
-sudo: false
-language: python
-cache: pip
-matrix:
-    include:
-        - python: 2.6
-        - python: 2.7
-        - python: 3.3
-        - python: 3.4
-        - python: 3.5
-        - "pypy"
-        # XXX - commented because OSX builds are deadly slow
-        # - language: generic
-        #   os: osx
-        #   env: PYVER=py26
-        - language: generic
-          os: osx
-          env: PYVER=py27
-        # XXX - commented because OSX builds are deadly slow
-        # - language: generic
-        #   os: osx
-        #   env: PYVER=py33
-        - language: generic
-          os: osx
-          env: PYVER=py34
-        # XXX - not supported yet
-        # - language: generic
-        #   os: osx
-        #   env: PYVER=py35
-install:
-    - ./.ci/travis/install.sh
-script:
-    - ./.ci/travis/run.sh
-after_success:
-    # upload reports to coveralls.io
-    - |
-        if [ "$(uname -s)" != 'Darwin' ]; then
-            coveralls
-        fi
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000000..b704d7d3b4
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,31 @@
+# Contributing to psutil project
+
+## Issues
+
+- The issue tracker is for reporting problems or proposing enhancements related
+  to the **program code**.
+- Please do not open issues **asking for support**. Instead, use the forum at:
+  https://groups.google.com/g/psutil.
+- Before submitting a new issue, **search** if there are existing issues for
+  the same topic.
+- **Be clear** in describing what the problem is, and fill in the default issue
+  **template**. There is a bot which reads the title and description and
+  assigns **labels** automatically. Labels help keeping the issues properly
+  organized and searchable (by OS, issue type, etc.).
+- When reporting a malfunction, consider enabling
+  [debug mode](https://psutil.io/devguide/#debug-mode) first.
+- To report a **security vulnerability**, use the
+  [Tidelift security contact](https://tidelift.com/security). Tidelift will
+  coordinate the fix and the disclosure of the reported problem.
+
+## Pull Requests
+
+- In order to get acquainted with the code base and tooling, take a look at the
+  **[Development Guide](https://psutil.io/devguide/)**.
+- The PR system is for fixing bugs or make enhancements related to the
+  **program code**.
+- If you wish to implement a new feature or add support for a new platform it's
+  better to **discuss it first**, either on the issue tracker, the forum or via
+  private email.
+- No need to touch the changelog or credits files. A bot automatically adds
+  those entries for you before merging.
diff --git a/CREDITS b/CREDITS
deleted file mode 100644
index ab555efd9e..0000000000
--- a/CREDITS
+++ /dev/null
@@ -1,400 +0,0 @@
-Intro
-=====
-
-I would like to recognize some of the people who have been instrumental in the
-development of psutil.
-I'm sure I'm forgetting some people (feel free to email me), but here is a
-short list.
-It's modeled after the Linux CREDITS file where the fields are:
-name (N), e-mail (E), web-address (W), country (C), description (D), (I) issues
-(issue tracker is at https://github.com/giampaolo/psutil/issues).
-Really thanks to all of you.
-
-- Giampaolo
-
-Author
-======
-
-N: Giampaolo Rodola'
-C: Italy
-E: g.rodola@gmail.com
-W: http://grodola.blogspot.com/
-
-Contributors
-============
-
-N: Jay Loden
-C: NJ, USA
-E: jloden@gmail.com
-D: original co-author, initial design/bootstrap and occasional bug fixes
-W: http://www.jayloden.com
-
-N: Jeff Tang
-W: https://github.com/mrjefftang
-I: 340, 529, 616, 653, 654, 648, 641
-
-N: Jeremy Whitlock
-E: jcscoobyrs@gmail.com
-D: great help with OSX C development.
-I: 125, 150, 174, 206
-
-N: Landry Breuil
-W: https://github.com/landryb
-D: OpenBSD implementation.
-I: 615
-
-N: wj32
-E: wj32.64@gmail.com
-D: process username() and get_connections() on Windows
-I: 114, 115
-
-N: Yan Raber
-C: Bologna, Italy
-E: yanraber@gmail.com
-D: help on Windows development (initial version of Process.username())
-
-N: Justin Venus
-E: justin.venus@gmail.com
-D: Solaris support
-I: 18
-
-N: Dave Daeschler
-C: USA
-E: david.daeschler@gmail.com
-W: http://daviddaeschler.com
-D: some contributions to initial design/bootstrap plus occasional bug fixing
-I: 522, 536
-
-N: Thomas Klausner
-W: https://github.com/0-wiz-0
-I: #557
-
-N: Ryo Onodera
-W: https://github.com/ryoon
-I: #557
-
-N: cjgohlke
-E: cjgohlke@gmail.com
-D: Windows 64 bit support
-I: 107
-
-N: Jeffery Kline
-E: jeffery.kline@gmail.com
-I: 130
-
-N: Grabriel Monnerat
-E: gabrielmonnerat@gmail.com
-I: 146
-
-N: Philip Roberts
-E: philip.roberts@gmail.com
-I: 168
-
-N: jcscoobyrs
-E: jcscoobyrs@gmail.com
-I: 125
-
-N: Sandro Tosi
-E: sandro.tosi@gmail.com
-I: 200, 201
-
-N: Andrew Colin
-E: andrew.colin@gmail.com
-I: 248
-
-N: Amoser
-E: amoser@google.com
-I: 266, 267, 340
-
-N: Matthew Grant
-E: matthewgrant5@gmail.com
-I: 271
-
-N: oweidner
-E: oweidner@cct.lsu.edu
-I: 275
-
-N: Tarek Ziade
-E: ziade.tarek
-I: 281
-
-N: Luca Cipriani
-C: Turin, Italy
-E: luca.opensource@gmail.com
-I: 278
-
-N: Maciej Lach,
-E: maciej.lach@gmail.com
-I: 294
-
-N: James Pye
-E: james.pye@gmail.com
-I: 305, 306
-
-N: Stanchev Emil
-E: stanchev.emil
-I: 314
-
-N: Kim Gräsman
-E: kim.grasman@gmail.com
-D: ...also kindly donated some money.
-I: 316
-
-N: Riccardo Murri
-C: Italy
-I: 318
-
-N: Florent Xicluna
-E: florent.xicluna@gmail.com
-I: 319
-
-N: Michal Spondr
-E: michal.spondr
-I: 313
-
-N: Jean Sebastien
-E: dumbboules@gmail.com
-I: 344
-
-N: Rob Smith
-W: http://www.kormoc.com/
-I: 341
-
-N: Youngsik Kim
-W: https://plus.google.com/101320747613749824490/
-I: 317
-
-N: Gregory Szorc
-W: https://plus.google.com/116873264322260110710/posts
-I: 323
-
-N: André Oriani
-E: aoriani@gmail.com
-I: 361
-
-N: clackwell
-E: clackwell@gmail.com
-I: 356
-
-N: m.malycha
-E: m.malycha@gmail.com
-I: 351
-
-N: John Baldwin
-E: jhb@FreeBSD.org
-I: 370
-
-N: Jan Beich
-E: jbeich@tormail.org
-I: 325
-
-N: floppymaster
-E: floppymaster@gmail.com
-I: 380
-
-N: Arfrever.FTA
-E: Arfrever.FTA@gmail.com
-I: 369, 404
-
-N: danudey
-E: danudey@gmail.com
-I: 386
-
-N: Adrien Fallou
-I: 224
-
-N: Gisle Vanem
-E: gisle.vanem@gmail.com
-I: 411
-
-N: thepyr0
-E: thepyr0@gmail.com
-I: 414
-
-N: John Pankov
-E: john.pankov@gmail.com
-I: 435
-
-N: Matt Good
-W: http://matt-good.net/
-I: 438
-
-N: Ulrich Klank
-E: ulrich.klank@scitics.de
-I: 448
-
-N: Josiah Carlson
-E: josiah.carlson@gmail.com
-I: 451, 452
-
-N: Raymond Hettinger
-D: namedtuple and lru_cache backward compatible implementations.
-
-N: Jason Kirtland
-D: backward compatible implementation of collections.defaultdict.
-
-M: Ken Seeho
-D: @cached_property decorator
-
-N: crusaderky
-E: crusaderky@gmail.com
-I: 470, 477
-
-E: alex@mroja.net
-I: 471
-
-N: Gautam Singh
-E: gautam.singh@gmail.com
-I: 466
-
-E: lhn@hupfeldtit.dk
-I: 476, 479
-
-N: Francois Charron
-E: francois.charron.1@gmail.com
-I: 474
-
-N: Naveed Roudsari
-E: naveed.roudsari@gmail.com
-I: 421
-
-N: Alexander Grothe
-E: Alexander.Grothe@gmail.com
-I: 497
-
-N: Szigeti Gabor Niif
-E: szigeti.gabor.niif@gmail.com
-I: 446
-
-N: msabramo
-E: msabramo@gmail.com
-I: 492
-
-N: Yaolong Huang
-E: airekans@gmail.com
-W: http://airekans.github.io/
-I: 530
-
-N: Anders Chrigström
-W: https://github.com/anders-chrigstrom
-I: 496
-
-N: spacewander
-W: https://github.com/spacewander
-E: spacewanderlzx@gmail.com
-I: 561, 603
-
-N: Sylvain Mouquet
-E: sylvain.mouquet@gmail.com
-I: 565
-
-N: karthikrev
-I: 568
-
-N: Bruno Binet
-E: bruno.binet@gmail.com
-I: 572
-
-N: Gabi Davar
-C: Israel
-W: https://github.com/mindw
-I: 578, 581, 587
-
-N: spacewanderlzx
-C: Guangzhou,China
-E: spacewanderlzx@gmail.com
-I: 555
-
-N: Fabian Groffen
-I: 611, 618
-
-N: desbma
-W: https://github.com/desbma
-C: France
-I: 628
-
-N: John Burnett
-W: http://www.johnburnett.com/
-C: Irvine, CA, US
-I: 614
-
-N: �rni Már Jónsson
-E: Reykjavik, Iceland
-E: https://github.com/arnimarj
-I: 634
-
-N: Bart van Kleef
-W: https://github.com/bkleef
-I: 664
-
-N: Steven Winfield
-W: https://github.com/stevenwinfield
-I: 672
-
-N: sk6249
-W: https://github.com/sk6249
-I: 670
-
-N: maozguttman
-W: https://github.com/maozguttman
-I: 659
-
-N: wiggin15
-W: https://github.com/wiggin15
-I: 517, 607, 610
-
-N: dasumin
-W: https://github.com/dasumin
-I: 541
-
-N: Mike Sarahan
-W: https://github.com/msarahan
-I: 688
-
-N: Syohei YOSHIDA
-W: https://github.com/syohex
-I: 730
-
-N: Frank Benkstein
-W: https://github.com/fbenkstein
-I: 732, 733
-
-N: Visa Hankala
-E: visa@openbsd.org
-I: 741
-
-N: Sebastian-Gabriel Brestin
-C: Romania
-E: sebastianbrestin@gmail.com
-I: 704
-
-N: Timmy Konick
-W: https://github.com/tijko
-I: 751
-
-N: mpderbec
-W: https://github.com/mpderbec
-I: 660
-
-N: Mozilla Foundation
-D: sample code for process USS memory.
-
-N: wxwright
-W: https://github.com/wxwright
-I: 776
-
-N: Farhan Khan
-E: khanzf@gmail.com
-I: 823
-
-N: Jake Omann
-E: https://github.com/jhomann
-I: 816
-
-N: Jeremy Humble
-W: https://github.com/jhumble
-I: 863
-
-N: Ilya Georgievsky
-W: https://github.com/xBeAsTx
-I: 870
diff --git a/DEVGUIDE.rst b/DEVGUIDE.rst
deleted file mode 100644
index ebd919abd4..0000000000
--- a/DEVGUIDE.rst
+++ /dev/null
@@ -1,166 +0,0 @@
-=====
-Setup
-=====
-
-If you plan on hacking on psutil this is what you're supposed to do first:
-
-- clone the GIT repository::
-
-  $ git clone git@github.com:giampaolo/psutil.git
-
-- install system deps (see `install instructions <https://github.com/giampaolo/psutil/blob/master/INSTALL.rst>`__).
-
-- install development deps; these are useful for running tests (e.g. mock,
-  unittest2), building doc (e.g. sphinx), running linters (flake8), etc. ::
-
-  $ make setup-dev-env
-
-- bear in mind that ``make`` (see `Makefile <https://github.com/giampaolo/psutil/blob/master/Makefile>`_)
-  is the designated tool to run tests, build, install etc. and that it is also
-  available on Windows
-  (see `make.bat <https://github.com/giampaolo/psutil/blob/master/make.bat>`_).
-- bear in mind that both psutil (``make install``) and any other lib
-  (``make setup-dev-env``) is installed as a limited user
-  (``pip install --user ...``), so develop as such (don't use root).
-- (UNIX only) run ``make install-git-hooks``: this will reject your commits
-  if python code is not PEP8 compliant.
-- run ``make test`` to run tests.
-
-============
-Coding style
-============
-
-- python code strictly follows `PEP 8 <https://www.python.org/dev/peps/pep-0008/>`_
-  styling guides and this is enforced by ``make install-git-hooks``.
-- C code strictly follows `PEP 7 <https://www.python.org/dev/peps/pep-0007/>`_
-  styling guides.
-
-========
-Makefile
-========
-
-Some useful make commands::
-
-  $ make install        # install
-  $ make setup-dev-env  # install useful dev libs (pyflakes, unittest2, etc.)
-  $ make test           # run all tests
-  $ make test-memleaks  # run memory leak tests
-  $ make coverage       # run test coverage
-  $ make flake8         # run PEP8 linter
-
-====================
-Adding a new feature
-====================
-
-Usually the files involved when adding a new functionality are:
-
-.. code-block:: plain
-
-    psutil/__init__.py                   # main psutil namespace
-    psutil/_ps{platform}.py              # python platform wrapper
-    psutil/_psutil_{platform}.c          # C platform extension
-    psutil/_psutil_{platform}.h          # C header file
-    psutil/tests/test_process|system.py  # main test suite
-    psutil/tests/test_{platform}.py      # platform specific test suite
-
-Typical process occurring when adding a new functionality (API):
-
-- define the new function in ``psutil/__init__.py``.
-- write the platform specific implementation in ``psutil/_ps{platform}.py``
-  (e.g. ``psutil/_pslinux.py``).
-- if the change requires C, write the C implementation in
-  ``psutil/_psutil_{platform}.c`` (e.g. ``psutil/_psutil_linux.c``).
-- write a generic test in ``psutil/tests/test_system.py`` or
-  ``psutil/tests/test_process.py``.
-- if possible, write a platform specific test in
-  ``psutil/tests/test_{platform}.py`` (e.g. ``test_linux.py``).
-  This usually means testing the return value of the new feature against
-  a system CLI tool.
-- update doc in ``doc/index.py``.
-- update ``HISTORY.rst``.
-- update ``README.rst`` (if necessary).
-- make a pull request.
-
-======================
-Continuous integration
-======================
-
-All of the services listed below are automatically run on ``git push``.
-
-Unit tests
-----------
-
-Tests are automatically run for every GIT push on **Linux**, **OSX** and
-**Windows** by using:
-
-- `Travis <https://travis-ci.org/giampaolo/psutil>`_ (Linux, OSX)
-- `Appveyor <https://ci.appveyor.com/project/giampaolo/psutil>`_ (Windows)
-
-Test files controlling these are
-`.travis.yml <https://github.com/giampaolo/psutil/blob/master/.travis.yml>`_
-and
-`appveyor.yml <https://github.com/giampaolo/psutil/blob/master/appveyor.yml>`_.
-Both services run psutil test suite against all supported python version
-(2.6 - 3.5).
-Two icons in the home page (README) always show the build status:
-
-.. image:: https://api.travis-ci.org/giampaolo/psutil.png?branch=master
-    :target: https://travis-ci.org/giampaolo/psutil
-    :alt: Linux tests (Travis)
-
-.. image:: https://ci.appveyor.com/api/projects/status/qdwvw7v1t915ywr5/branch/master?svg=true
-    :target: https://ci.appveyor.com/project/giampaolo/psutil
-    :alt: Windows tests (Appveyor)
-
-OSX, FreeBSD and Solaris are currently tested manually (sigh!).
-
-Test coverage
--------------
-
-Test coverage is provided by `coveralls.io <https://coveralls.io/github/giampaolo/psutil>`_,
-it is controlled via `.travis.yml <https://github.com/giampaolo/psutil/blob/master/.travis.yml>`_
-and it is updated on every git push.
-An icon in the home page (README) always shows the last coverage percentage:
-
-.. image:: https://coveralls.io/repos/giampaolo/psutil/badge.svg?branch=master&service=github
-    :target: https://coveralls.io/github/giampaolo/psutil?branch=master
-    :alt: Test coverage (coverall.io)
-
-=============
-Documentation
-=============
-
-- doc source code is written in a single file: `/docs/index.rst <https://raw.githubusercontent.com/giampaolo/psutil/master/docs/index.rst>`_.
-- it uses `RsT syntax <http://docutils.sourceforge.net/docs/user/rst/quickref.html>`_
-  and it's built with `sphinx <http://sphinx-doc.org/>`_.
-- doc can be built with ``make setup-dev-env; cd docs; make html``.
-- public doc is hosted on http://pythonhosted.org/psutil/.
-- it is uploaded on every new release with ``make upload-doc``.
-
-=======================
-Releasing a new version
-=======================
-
-These are note for myself (Giampaolo):
-
-- make sure all tests pass and all builds are green.
-- upload source tarball on PYPI with ``make upload-src``.
-- upload exe and wheel files for windows on PYPI with ``make upload-all``.
-  - ...or by using atrifacts hosted on AppVeyor with ``make win-download-exes``
-    and ``make win-upload-exes``,
-- upload updated doc on http://pythonhosted.org/psutil with ``make upload-doc``.
-- GIT tag the new release with ``make git-tag-release``.
-- post on psutil and python-announce mailing lists, twitter, g+, blog.
-
-=============
-FreeBSD notes
-=============
-
-- setup:
-
-.. code-block:: bash
-
-  $ pkg install python python3 gcc git vim screen bash
-  $ chsh -s /usr/local/bin/bash user  # set bash as default shell
-
-- ``/usr/src`` contains the source codes for all installed CLI tools (grep in it).
diff --git a/HISTORY.rst b/HISTORY.rst
index bb7162868e..a5621dc086 100644
--- a/HISTORY.rst
+++ b/HISTORY.rst
@@ -1,1255 +1,3 @@
-Bug tracker at https://github.com/giampaolo/psutil/issues
+History has moved to:
 
-4.3.1 - XXXX-XX-XX
-==================
-
-**Bug fixes**
-
-- #854: Process.as_dict() raises ValueError if passed an erroneous attrs name.
-- #857: [SunOS] Process cpu_times(), cpu_percent(), threads() amd memory_maps()
-  may raise RuntimeError if attempting to query a 64bit process with a 32bit
-  python. "Null" values are returned as a fallback.
-- #858: Process.as_dict() should not return memory_info_ex() because it's
-  deprecated.
-- #863: [Windows] memory_map truncates addresses above 32 bits
-- #866: [Windows] win_service_iter() and services in general are not able to
-  handle unicode service names / descriptions.
-- #869: [Windows] Process.wait() may raise TimeoutExpired with wrong timeout
-  unit (ms instead of sec).
-- #870: [Windows] Handle leak inside psutil_get_process_data.
-
-
-4.3.0 - 2016-06-18
-==================
-
-**Enhancements**
-
-- #819: [Linux] different speedup improvements:
-  Process.ppid() is 20% faster
-  Process.status() is 28% faster
-  Process.name() is 25% faster
-  Process.num_threads is 20% faster on Python 3
-
-**Bug fixes**
-
-- #810: [Windows] Windows wheels are incompatible with pip 7.1.2.
-- #812: [NetBSD] fix compilation on NetBSD-5.x.
-- #823: [NetBSD] virtual_memory() raises TypeError on Python 3.
-- #829: [UNIX] psutil.disk_usage() percent field takes root reserved space
-  into account.
-- #816: [Windows] fixed net_io_counter() values wrapping after 4.3GB in
-  Windows Vista (NT 6.0) and above using 64bit values from newer win APIs.
-
-
-4.2.0 - 2016-05-14
-==================
-
-**Enhancements**
-
-- #795: [Windows] new APIs to deal with Windows services: win_service_iter()
-  and win_service_get().
-- #800: [Linux] psutil.virtual_memory() returns a new "shared" memory field.
-- #819: [Linux] speedup /proc parsing:
-  - Process.ppid() is 20% faster
-  - Process.status() is 28% faster
-  - Process.name() is 25% faster
-  - Process.num_threads is 20% faster on Python 3
-
-**Bug fixes**
-
-- #797: [Linux] net_if_stats() may raise OSError for certain NIC cards.
-- #813: Process.as_dict() should ignore extraneous attribute names which gets
-  attached to the Process instance.
-
-
-4.1.0 - 2016-03-12
-==================
-
-**Enhancements**
-
-- #777: [Linux] Process.open_files() on Linux return 3 new fields: position,
-  mode and flags.
-- #779: Process.cpu_times() returns two new fields, 'children_user' and
-  'children_system' (always set to 0 on OSX and Windows).
-- #789: [Windows] psutil.cpu_times() return two new fields: "interrupt" and
-  "dpc". Same for psutil.cpu_times_percent().
-- #792: new psutil.cpu_stats() function returning number of CPU ctx switches
-  interrupts, soft interrupts and syscalls.
-
-**Bug fixes**
-
-- #774: [FreeBSD] net_io_counters() dropout is no longer set to 0 if the kernel
-  provides it.
-- #776: [Linux] Process.cpu_affinity() may erroneously raise NoSuchProcess.
-  (patch by wxwright)
-- #780: [OSX] psutil does not compile with some gcc versions.
-- #786: net_if_addrs() may report incomplete MAC addresses.
-- #788: [NetBSD] virtual_memory()'s buffers and shared values were set to 0.
-- #790: [OSX] psutil won't compile on OSX 10.4.
-
-
-4.0.0 - 2016-02-17
-==================
-
-**Enhancements**
-
-- #523: [Linux, FreeBSD] disk_io_counters() return a new "busy_time" field.
-- #660: [Windows] make.bat is smarter in finding alternative VS install
-  locations.  (patch by mpderbec)
-- #732: Process.environ().  (patch by Frank Benkstein)
-- #753: [Linux, OSX, Windows] Process USS and PSS (Linux) "real" memory stats.
-  (patch by Eric Rahm)
-- #755: Process.memory_percent() "memtype" parameter.
-- #758: tests now live in psutil namespace.
-- #760: expose OS constants (psutil.LINUX, psutil.OSX, etc.)
-- #756: [Linux] disk_io_counters() return 2 new fields: read_merged_count and
-  write_merged_count.
-- #762: new scripts/procsmem.py script.
-
-**Bug fixes**
-
-- #685: [Linux] virtual_memory() provides wrong results on systems with a lot
-  of physical memory.
-- #704: [Solaris] psutil does not compile on Solaris sparc.
-- #734: on Python 3 invalid UTF-8 data is not correctly handled for process
-  name(), cwd(), exe(), cmdline() and open_files() methods resulting in
-  UnicodeDecodeError exceptions. 'surrogateescape' error handler is now
-  used as a workaround for replacing the corrupted data.
-- #737: [Windows] when the bitness of psutil and the target process was
-  different cmdline() and cwd() could return a wrong result or incorrectly
-  report an AccessDenied error.
-- #741: [OpenBSD] psutil does not compile on mips64.
-- #751: [Linux] fixed call to Py_DECREF on possible Null object.
-- #754: [Linux] cmdline() can be wrong in case of zombie process.
-- #759: [Linux] Process.memory_maps() may return paths ending with " (deleted)"
-- #761: [Windows] psutil.boot_time() wraps to 0 after 49 days.
-- #764: [NetBSD] fix compilation on NetBSD-6.x.
-- #766: [Linux] net_connections() can't handle malformed /proc/net/unix file.
-- #767: [Linux] disk_io_counters() may raise ValueError on 2.6 kernels and it's
-  broken on 2.4 kernels.
-- #770: [NetBSD] disk_io_counters() metrics didn't update.
-
-
-3.4.2 - 2016-01-20
-==================
-
-**Enhancements**
-
-- #728: [Solaris] exposed psutil.PROCFS_PATH constant to change the default
-  location of /proc filesystem.
-
-**Bug fixes**
-
-- #724: [FreeBSD] psutil.virtual_memory().total is incorrect.
-- #730: [FreeBSD] psutil.virtual_memory() crashes.
-
-
-3.4.1 - 2016-01-15
-==================
-
-**Enhancements**
-
-- #557: [NetBSD] added NetBSD support.  (contributed by Ryo Onodera and
-  Thomas Klausner)
-- #708: [Linux] psutil.net_connections() and Process.connections() on Python 2
-  can be up to 3x faster in case of many connections.
-  Also psutil.Process.memory_maps() is slightly faster.
-- #718: process_iter() is now thread safe.
-
-**Bug fixes**
-
-- #714: [OpenBSD] virtual_memory().cached value was always set to 0.
-- #715: don't crash at import time if cpu_times() fail for some reason.
-- #717: [Linux] Process.open_files fails if deleted files still visible.
-- #722: [Linux] swap_memory() no longer crashes if sin/sout can't be determined
-  due to missing /proc/vmstat.
-- #724: [FreeBSD] virtual_memory().total is slightly incorrect.
-
-
-3.3.0 - 2015-11-25
-==================
-
-**Enhancements**
-
-- #558: [Linux] exposed psutil.PROCFS_PATH constant to change the default
-  location of /proc filesystem.
-- #615: [OpenBSD] added OpenBSD support.  (contributed by Landry Breuil)
-
-**Bug fixes**
-
-- #692: [UNIX] Process.name() is no longer cached as it may change.
-
-
-3.2.2 - 2015-10-04
-==================
-
-**Bug fixes**
-
-- #517: [SunOS] net_io_counters failed to detect network interfaces
-  correctly on Solaris 10
-- #541: [FreeBSD] disk_io_counters r/w times were expressed in seconds instead
-  of milliseconds.  (patch by dasumin)
-- #610: [SunOS] fix build and tests on Solaris 10
-- #623: [Linux] process or system connections raises ValueError if IPv6 is not
-  supported by the system.
-- #678: [Linux] can't install psutil due to bug in setup.py.
-- #688: [Windows] compilation fails with MSVC 2015, Python 3.5. (patch by
-  Mike Sarahan)
-
-
-3.2.1 - 2015-09-03
-==================
-
-**Bug fixes**
-
-- #677: [Linux] can't install psutil due to bug in setup.py.
-
-
-3.2.0 - 2015-09-02
-==================
-
-**Enhancements**
-
-- #644: [Windows] added support for CTRL_C_EVENT and CTRL_BREAK_EVENT signals
-  to use with Process.send_signal().
-- #648: CI test integration for OSX. (patch by Jeff Tang)
-- #663: [UNIX] net_if_addrs() now returns point-to-point (VPNs) addresses.
-- #655: [Windows] different issues regarding unicode handling were fixed. On
-  Python 2 all APIs returning a string will now return an encoded version of it
-  by using sys.getfilesystemencoding() codec. The APIs involved are:
-  - psutil.net_if_addrs()
-  - psutil.net_if_stats()
-  - psutil.net_io_counters()
-  - psutil.Process.cmdline()
-  - psutil.Process.name()
-  - psutil.Process.username()
-  - psutil.users()
-
-**Bug fixes**
-
-- #513: [Linux] fixed integer overflow for RLIM_INFINITY.
-- #641: [Windows] fixed many compilation warnings.  (patch by Jeff Tang)
-- #652: [Windows] net_if_addrs() UnicodeDecodeError in case of non-ASCII NIC
-  names.
-- #655: [Windows] net_if_stats() UnicodeDecodeError in case of non-ASCII NIC
-  names.
-- #659: [Linux] compilation error on Suse 10. (patch by maozguttman)
-- #664: [Linux] compilation error on Alpine Linux. (patch by Bart van Kleef)
-- #670: [Windows] segfgault of net_if_addrs() in case of non-ASCII NIC names.
-  (patch by sk6249)
-- #672: [Windows] compilation fails if using Windows SDK v8.0. (patch by
-  Steven Winfield)
-- #675: [Linux] net_connections(); UnicodeDecodeError may occur when listing
-  UNIX sockets.
-
-
-3.1.1 - 2015-07-15
-==================
-
-**Bug fixes**
-
-- #603: [Linux] ionice_set value range is incorrect.  (patch by spacewander)
-- #645: [Linux] psutil.cpu_times_percent() may produce negative results.
-- #656: 'from psutil import *' does not work.
-
-
-3.1.0 - 2015-07-15
-==================
-
-**Enhancements**
-
-- #534: [Linux] disk_partitions() added support for ZFS filesystems.
-- #646: continuous tests integration for Windows with
-  https://ci.appveyor.com/project/giampaolo/psutil.
-- #647: new dev guide:
-  https://github.com/giampaolo/psutil/blob/master/DEVGUIDE.rst
-- #651: continuous code quality test integration with
-  https://scrutinizer-ci.com/g/giampaolo/psutil/
-
-**Bug fixes**
-
-- #340: [Windows] Process.open_files() no longer hangs. Instead it uses a
-  thred which times out and skips the file handle in case it's taking too long
-  to be retrieved.  (patch by Jeff Tang, PR #597)
-- #627: [Windows] Process.name() no longer raises AccessDenied for pids owned
-  by another user.
-- #636: [Windows] Process.memory_info() raise AccessDenied.
-- #637: [UNIX] raise exception if trying to send signal to Process PID 0 as it
-  will affect os.getpid()'s process group instead of PID 0.
-- #639: [Linux] Process.cmdline() can be truncated.
-- #640: [Linux] *connections functions may swallow errors and return an
-  incomplete list of connnections.
-- #642: repr() of exceptions is incorrect.
-- #653: [Windows] Add inet_ntop function for Windows XP to support IPv6.
-- #641: [Windows] Replace deprecated string functions with safe equivalents.
-
-
-3.0.1 - 2015-06-18
-==================
-
-**Bug fixes**
-
-- #632: [Linux] better error message if cannot parse process UNIX connections.
-- #634: [Linux] Proces.cmdline() does not include empty string arguments.
-- #635: [UNIX] crash on module import if 'enum' package is installed on python
-  < 3.4.
-
-
-3.0.0 - 2015-06-13
-==================
-
-**Enhancements**
-
-- #250: new psutil.net_if_stats() returning NIC statistics (isup, duplex,
-  speed, MTU).
-- #376: new psutil.net_if_addrs() returning all NIC addresses a-la ifconfig.
-- #469: on Python >= 3.4 ``IOPRIO_CLASS_*`` and ``*_PRIORITY_CLASS`` constants
-  returned by psutil.Process' ionice() and nice() methods are enums instead of
-  plain integers.
-- #581: add .gitignore. (patch by Gabi Davar)
-- #582: connection constants returned by psutil.net_connections() and
-  psutil.Process.connections() were turned from int to enums on Python > 3.4.
-- #587: Move native extension into the package.
-- #589: Process.cpu_affinity() accepts any kind of iterable (set, tuple, ...),
-  not only lists.
-- #594: all deprecated APIs were removed.
-- #599: [Windows] process name() can now be determined for all processes even
-  when running as a limited user.
-- #602: pre-commit GIT hook.
-- #629: enhanced support for py.test and nose test discovery and tests run.
-- #616: [Windows] Add inet_ntop function for Windows XP.
-
-**Bug fixes**
-
-- #428: [all UNIXes except Linux] correct handling of zombie processes;
-  introduced new ZombieProcess exception class.
-- #512: [BSD] fix segfault in net_connections().
-- #555: [Linux] psutil.users() correctly handles ":0" as an alias for
-  "localhost"
-- #579: [Windows] Fixed open_files() for PID>64K.
-- #579: [Windows] fixed many compiler warnings.
-- #585: [FreeBSD] net_connections() may raise KeyError.
-- #586: [FreeBSD] cpu_affinity() segfaults on set in case an invalid CPU
-  number is provided.
-- #593: [FreeBSD] Process().memory_maps() segfaults.
-- #606: Process.parent() may swallow NoSuchProcess exceptions.
-- #611: [SunOS] net_io_counters has send and received swapped
-- #614: [Linux]: cpu_count(logical=False) return the number of physical CPUs
-  instead of physical cores.
-- #618: [SunOS] swap tests fail on Solaris when run as normal user
-- #628: [Linux] Process.name() truncates process name in case it contains
-  spaces or parentheses.
-
-
-2.2.1 - 2015-02-02
-==================
-
-**Bug fixes**
-
-- #496: [Linux] fix "ValueError: ambiguos inode with multiple PIDs references"
-  (patch by Bruno Binet)
-
-
-2.2.0 - 2015-01-06
-==================
-
-**Enhancements**
-
-- #521: drop support for Python 2.4 and 2.5.
-- #553: new examples/pstree.py script.
-- #564: C extension version mismatch in case the user messed up with psutil
-  installation or with sys.path is now detected at import time.
-- #568: New examples/pidof.py script.
-- #569: [FreeBSD] add support for process CPU affinity.
-
-**Bug fixes**
-
-- #496: [Solaris] can't import psutil.
-- #547: [UNIX] Process.username() may raise KeyError if UID can't be resolved.
-- #551: [Windows] get rid of the unicode hack for net_io_counters() NIC names.
-- #556: [Linux] lots of file handles were left open.
-- #561: [Linux] net_connections() might skip some legitimate UNIX sockets.
-  (patch by spacewander)
-- #565: [Windows] use proper encoding for psutil.Process.username() and
-  psutil.users(). (patch by Sylvain Mouquet)
-- #567: [Linux] in the alternative implementation of CPU affinity PyList_Append
-  and Py_BuildValue return values are not checked.
-- #569: [FreeBSD] fix memory leak in psutil.cpu_count(logical=False).
-- #571: [Linux] Process.open_files() might swallow AccessDenied exceptions and
-  return an incomplete list of open files.
-
-
-2.1.3 - 2014-09-26
-==================
-
-- #536: [Linux]: fix "undefined symbol: CPU_ALLOC" compilation error.
-
-
-2.1.2 - 2014-09-21
-==================
-
-**Enhancements**
-
-- #407: project moved from Google Code to Github; code moved from Mercurial
-  to Git.
-- #492: use tox to run tests on multiple python versions.  (patch by msabramo)
-- #505: [Windows] distribution as wheel packages.
-- #511: new examples/ps.py sample code.
-
-**Bug fixes**
-
-- #340: [Windows] Process.get_open_files() no longer hangs.  (patch by
-  Jeff Tang)
-- #501: [Windows] disk_io_counters() may return negative values.
-- #503: [Linux] in rare conditions Process exe(), open_files() and
-  connections() methods can raise OSError(ESRCH) instead of NoSuchProcess.
-- #504: [Linux] can't build RPM packages via setup.py
-- #506: [Linux] python 2.4 support was broken.
-- #522: [Linux] Process.cpu_affinity() might return EINVAL.  (patch by David
-  Daeschler)
-- #529: [Windows] Process.exe() may raise unhandled WindowsError exception
-  for PIDs 0 and 4.  (patch by Jeff Tang)
-- #530: [Linux] psutil.disk_io_counters() may crash on old Linux distros
-  (< 2.6.5)  (patch by Yaolong Huang)
-- #533: [Linux] Process.memory_maps() may raise TypeError on old Linux distros.
-
-
-2.1.1 - 2014-04-30
-==================
-
-**Bug fixes**
-
-- #446: [Windows] fix encoding error when using net_io_counters() on Python 3.
-  (patch by Szigeti Gabor Niif)
-- #460: [Windows] net_io_counters() wraps after 4G.
-- #491: [Linux] psutil.net_connections() exceptions. (patch by Alexander Grothe)
-
-
-2.1.0 - 2014-04-08
-==================
-
-**Enhancements**
-
-- #387: system-wide open connections a-la netstat.
-
-**Bug fixes**
-
-- #421: [Solaris] psutil does not compile on SunOS 5.10 (patch by Naveed
-  Roudsari)
-- #489: [Linux] psutil.disk_partitions() return an empty list.
-
-
-2.0.0 - 2014-03-10
-==================
-
-**Enhancements**
-
-- #424: [Windows] installer for Python 3.X 64 bit.
-- #427: number of logical and physical CPUs (psutil.cpu_count()).
-- #447: psutil.wait_procs() timeout parameter is now optional.
-- #452: make Process instances hashable and usable with set()s.
-- #453: tests on Python < 2.7 require unittest2 module.
-- #459: add a make file for running tests and other repetitive tasks (also
-  on Windows).
-- #463: make timeout parameter of cpu_percent* functions default to 0.0 'cause
-  it's a common trap to introduce slowdowns.
-- #468: move documentation to readthedocs.com.
-- #477: process cpu_percent() is about 30% faster.  (suggested by crusaderky)
-- #478: [Linux] almost all APIs are about 30% faster on Python 3.X.
-- #479: long deprecated psutil.error module is gone; exception classes now
-  live in "psutil" namespace only.
-
-**Bug fixes**
-
-- #193: psutil.Popen constructor can throw an exception if the spawned process
-  terminates quickly.
-- #340: [Windows] process get_open_files() no longer hangs.  (patch by
-  jtang@vahna.net)
-- #443: [Linux] fix a potential overflow issue for Process.set_cpu_affinity()
-  on systems with more than 64 CPUs.
-- #448: [Windows] get_children() and ppid() memory leak (patch by Ulrich
-  Klank).
-- #457: [POSIX] pid_exists() always returns True for PID 0.
-- #461: namedtuples are not pickle-able.
-- #466: [Linux] process exe improper null bytes handling.  (patch by
-  Gautam Singh)
-- #470: wait_procs() might not wait.  (patch by crusaderky)
-- #471: [Windows] process exe improper unicode handling. (patch by
-  alex@mroja.net)
-- #473: psutil.Popen.wait() does not set returncode attribute.
-- #474: [Windows] Process.cpu_percent() is no longer capped at 100%.
-- #476: [Linux] encoding error for process name and cmdline.
-
-**API changes**
-
-For the sake of consistency a lot of psutil APIs have been renamed.
-In most cases accessing the old names will work but it will cause a
-DeprecationWarning.
-
-- psutil.* module level constants have being replaced by functions:
-
-  +-----------------------+-------------------------------+
-  | Old name              | Replacement                   |
-  +=======================+===============================+
-  | psutil.NUM_CPUS       | psutil.cpu_cpunt()            |
-  +-----------------------+-------------------------------+
-  | psutil.BOOT_TIME      | psutil.boot_time()            |
-  +-----------------------+-------------------------------+
-  | psutil.TOTAL_PHYMEM   | psutil.virtual_memory().total |
-  +-----------------------+-------------------------------+
-
-- Renamed psutil.* functions:
-
-  +--------------------------+-------------------------------+
-  | Old name                 | Replacement                   |
-  +==========================+===============================+
-  | - psutil.get_pid_list()  | psutil.pids()                 |
-  +--------------------------+-------------------------------+
-  | - psutil.get_users()     | psutil.users()                |
-  +--------------------------+-------------------------------+
-  | - psutil.get_boot_time() | psutil.boot_time()            |
-  +--------------------------+-------------------------------+
-
-- All psutil.Process ``get_*`` methods lost the ``get_`` prefix.
-  get_ext_memory_info() renamed to memory_info_ex().
-  Assuming "p = psutil.Process()":
-
-  +--------------------------+----------------------+
-  | Old name                 | Replacement          |
-  +==========================+======================+
-  | p.get_children()         | p.children()         |
-  +--------------------------+----------------------+
-  | p.get_connections()      | p.connections()      |
-  +--------------------------+----------------------+
-  | p.get_cpu_affinity()     | p.cpu_affinity()     |
-  +--------------------------+----------------------+
-  | p.get_cpu_percent()      | p.cpu_percent()      |
-  +--------------------------+----------------------+
-  | p.get_cpu_times()        | p.cpu_times()        |
-  +--------------------------+----------------------+
-  | p.get_ext_memory_info()  | p.memory_info_ex()   |
-  +--------------------------+----------------------+
-  | p.get_io_counters()      | p.io_counters()      |
-  +--------------------------+----------------------+
-  | p.get_ionice()           | p.ionice()           |
-  +--------------------------+----------------------+
-  | p.get_memory_info()      | p.memory_info()      |
-  +--------------------------+----------------------+
-  | p.get_memory_maps()      | p.memory_maps()      |
-  +--------------------------+----------------------+
-  | p.get_memory_percent()   | p.memory_percent()   |
-  +--------------------------+----------------------+
-  | p.get_nice()             | p.nice()             |
-  +--------------------------+----------------------+
-  | p.get_num_ctx_switches() | p.num_ctx_switches() |
-  +--------------------------+----------------------+
-  | p.get_num_fds()          | p.num_fds()          |
-  +--------------------------+----------------------+
-  | p.get_num_threads()      | p.num_threads()      |
-  +--------------------------+----------------------+
-  | p.get_open_files()       | p.open_files()       |
-  +--------------------------+----------------------+
-  | p.get_rlimit()           | p.rlimit()           |
-  +--------------------------+----------------------+
-  | p.get_threads()          | p.threads()          |
-  +--------------------------+----------------------+
-  | p.getcwd()               | p.cwd()              |
-  +--------------------------+----------------------+
-
-- All psutil.Process ``set_*`` methods lost the ``set_`` prefix.
-  Assuming "p = psutil.Process()":
-
-  +----------------------+---------------------------------+
-  | Old name             | Replacement                     |
-  +======================+=================================+
-  | p.set_nice()         | p.nice(value)                   |
-  +----------------------+---------------------------------+
-  | p.set_ionice()       | p.ionice(ioclass, value=None)   |
-  +----------------------+---------------------------------+
-  | p.set_cpu_affinity() | p.cpu_affinity(cpus)            |
-  +----------------------+---------------------------------+
-  | p.set_rlimit()       | p.rlimit(resource, limits=None) |
-  +----------------------+---------------------------------+
-
-- Except for 'pid' all psutil.Process class properties have been turned into
-  methods. This is the only case which there are no aliases.
-  Assuming "p = psutil.Process()":
-
-  +---------------+-----------------+
-  | Old name      | Replacement     |
-  +===============+=================+
-  | p.name        | p.name()        |
-  +---------------+-----------------+
-  | p.parent      | p.parent()      |
-  +---------------+-----------------+
-  | p.ppid        | p.ppid()        |
-  +---------------+-----------------+
-  | p.exe         | p.exe()         |
-  +---------------+-----------------+
-  | p.cmdline     | p.cmdline()     |
-  +---------------+-----------------+
-  | p.status      | p.status()      |
-  +---------------+-----------------+
-  | p.uids        | p.uids()        |
-  +---------------+-----------------+
-  | p.gids        | p.gids()        |
-  +---------------+-----------------+
-  | p.username    | p.username()    |
-  +---------------+-----------------+
-  | p.create_time | p.create_time() |
-  +---------------+-----------------+
-
-- timeout parameter of cpu_percent* functions defaults to 0.0 instead of 0.1.
-- long deprecated psutil.error module is gone; exception classes now live in
-  "psutil" namespace only.
-- Process instances' "retcode" attribute returned by psutil.wait_procs() has
-  been renamed to "returncode" for consistency with subprocess.Popen.
-
-
-1.2.1 - 2013-11-25
-==================
-
-**Bug fixes**
-
-- #348: [Windows XP] fixed "ImportError: DLL load failed" occurring on module
-  import.
-- #425: [Solaris] crash on import due to failure at determining BOOT_TIME.
-- #443: [Linux] can't set CPU affinity on systems with more than 64 cores.
-
-
-1.2.0 - 2013-11-20
-==================
-
-**Enhancements**
-
-- #439: assume os.getpid() if no argument is passed to psutil.Process
-  constructor.
-- #440: new psutil.wait_procs() utility function which waits for multiple
-  processes to terminate.
-
-**Bug fixes**
-
-- #348: [Windows XP/Vista] fix "ImportError: DLL load failed" occurring on
-  module import.
-
-
-1.1.3 - 2013-11-07
-==================
-
-**Bug fixes**
-
-- #442: [Linux] psutil won't compile on certain version of Linux because of
-  missing prlimit(2) syscall.
-
-
-1.1.2 - 2013-10-22
-==================
-
-**Bug fixes**
-
-- #442: [Linux] psutil won't compile on Debian 6.0 because of missing
-  prlimit(2) syscall.
-
-
-1.1.1 - 2013-10-08
-==================
-
-**Bug fixes**
-
-- #442: [Linux] psutil won't compile on kernels < 2.6.36 due to missing
-  prlimit(2) syscall.
-
-
-1.1.0 - 2013-09-28
-==================
-
-**Enhancements**
-
-- #410: host tar.gz and windows binary files are on PYPI.
-- #412: [Linux] get/set process resource limits.
-- #415: [Windows] Process.get_children() is an order of magnitude faster.
-- #426: [Windows] Process.name is an order of magnitude faster.
-- #431: [UNIX] Process.name is slightly faster because it unnecessarily
-  retrieved also process cmdline.
-
-**Bug fixes**
-
-- #391: [Windows] psutil.cpu_times_percent() returns negative percentages.
-- #408: STATUS_* and CONN_* constants don't properly serialize on JSON.
-- #411: [Windows] examples/disk_usage.py may pop-up a GUI error.
-- #413: [Windows] Process.get_memory_info() leaks memory.
-- #414: [Windows] Process.exe on Windows XP may raise ERROR_INVALID_PARAMETER.
-- #416: psutil.disk_usage() doesn't work well with unicode path names.
-- #430: [Linux] process IO counters report wrong number of r/w syscalls.
-- #435: [Linux] psutil.net_io_counters() might report erreneous NIC names.
-- #436: [Linux] psutil.net_io_counters() reports a wrong 'dropin' value.
-
-**API changes**
-
-- #408: turn STATUS_* and CONN_* constants into plain Python strings.
-
-
-1.0.1 - 2013-07-12
-==================
-
-**Bug fixes**
-
-- #405: network_io_counters(pernic=True) no longer works as intended in 1.0.0.
-
-
-1.0.0 - 2013-07-10
-==================
-
-**Enhancements**
-
-- #18:  Solaris support (yay!)  (thanks Justin Venus)
-- #367: Process.get_connections() 'status' strings are now constants.
-- #380: test suite exits with non-zero on failure.  (patch by floppymaster)
-- #391: introduce unittest2 facilities and provide workarounds if unittest2
-  is not installed (python < 2.7).
-
-**Bug fixes**
-
-- #374: [Windows] negative memory usage reported if process uses a lot of
-  memory.
-- #379: [Linux] Process.get_memory_maps() may raise ValueError.
-- #394: [OSX] Mapped memory regions report incorrect file name.
-- #404: [Linux] sched_*affinity() are implicitly declared. (patch by Arfrever)
-
-**API changes**
-
-- Process.get_connections() 'status' field is no longer a string but a
-  constant object (psutil.CONN_*).
-- Process.get_connections() 'local_address' and 'remote_address' fields
-  renamed to 'laddr' and 'raddr'.
-- psutil.network_io_counters() renamed to psutil.net_io_counters().
-
-
-0.7.1 - 2013-05-03
-==================
-
-**Bug fixes**
-
-- #325: [BSD] psutil.virtual_memory() can raise SystemError.
-  (patch by Jan Beich)
-- #370: [BSD] Process.get_connections() requires root.  (patch by John Baldwin)
-- #372: [BSD] different process methods raise NoSuchProcess instead of
-  AccessDenied.
-
-
-0.7.0 - 2013-04-12
-==================
-
-**Enhancements**
-
-- #233: code migrated to Mercurial (yay!)
-- #246: psutil.error module is deprecated and scheduled for removal.
-- #328: [Windows] process IO nice/priority support.
-- #359: psutil.get_boot_time()
-- #361: [Linux] psutil.cpu_times() now includes new 'steal', 'guest' and
-  'guest_nice' fields available on recent Linux kernels.
-  Also, psutil.cpu_percent() is more accurate.
-- #362: cpu_times_percent() (per-CPU-time utilization as a percentage)
-
-**Bug fixes**
-
-- #234: [Windows] disk_io_counters() fails to list certain disks.
-- #264: [Windows] use of psutil.disk_partitions() may cause a message box to
-  appear.
-- #313: [Linux] psutil.virtual_memory() and psutil.swap_memory() can crash on
-  certain exotic Linux flavors having an incomplete /proc interface.
-  If that's the case we now set the unretrievable stats to 0 and raise a
-  RuntimeWarning.
-- #315: [OSX] fix some compilation warnings.
-- #317: [Windows] cannot set process CPU affinity above 31 cores.
-- #319: [Linux] process get_memory_maps() raises KeyError 'Anonymous' on Debian
-  squeeze.
-- #321: [UNIX] Process.ppid property is no longer cached as the kernel may set
-  the ppid to 1 in case of a zombie process.
-- #323: [OSX] disk_io_counters()'s read_time and write_time parameters were
-  reporting microseconds not milliseconds.  (patch by Gregory Szorc)
-- #331: Process cmdline is no longer cached after first acces as it may change.
-- #333: [OSX] Leak of Mach ports on OS X (patch by rsesek@google.com)
-- #337: [Linux] process methods not working because of a poor /proc
-  implementation will raise NotImplementedError rather than RuntimeError
-  and Process.as_dict() will not blow up.  (patch by Curtin1060)
-- #338: [Linux] disk_io_counters() fails to find some disks.
-- #339: [FreeBSD] get_pid_list() can allocate all the memory on system.
-- #341: [Linux] psutil might crash on import due to error in retrieving system
-  terminals map.
-- #344: [FreeBSD] swap_memory() might return incorrect results due to
-  kvm_open(3) not being called. (patch by Jean Sebastien)
-- #338: [Linux] disk_io_counters() fails to find some disks.
-- #351: [Windows] if psutil is compiled with mingw32 (provided installers for
-  py2.4 and py2.5 are) disk_io_counters() will fail. (Patch by m.malycha)
-- #353: [OSX] get_users() returns an empty list on OSX 10.8.
-- #356: Process.parent now checks whether parent PID has been reused in which
-  case returns None.
-- #365: Process.set_nice() should check PID has not been reused by another
-  process.
-- #366: [FreeBSD] get_memory_maps(), get_num_fds(), get_open_files() and
-  getcwd() Process methods raise RuntimeError instead of AccessDenied.
-
-**API changes**
-
-- Process.cmdline property is no longer cached after first access.
-- Process.ppid property is no longer cached after first access.
-- [Linux] Process methods not working because of a poor /proc implementation
-  will raise NotImplementedError instead of RuntimeError.
-- psutil.error module is deprecated and scheduled for removal.
-
-
-0.6.1 - 2012-08-16
-==================
-
-**Enhancements**
-
-- #316: process cmdline property now makes a better job at guessing the process
-  executable from the cmdline.
-
-**Bug fixes**
-
-- #316: process exe was resolved in case it was a symlink.
-- #318: python 2.4 compatibility was broken.
-
-**API changes**
-
-- process exe can now return an empty string instead of raising AccessDenied.
-- process exe is no longer resolved in case it's a symlink.
-
-
-0.6.0 - 2012-08-13
-==================
-
-**Enhancements**
-
-- #216: [POSIX] get_connections() UNIX sockets support.
-- #220: [FreeBSD] get_connections() has been rewritten in C and no longer
-  requires lsof.
-- #222: [OSX] add support for process cwd.
-- #261: process extended memory info.
-- #295: [OSX] process executable path is now determined by asking the OS
-  instead of being guessed from process cmdline.
-- #297: [OSX] the Process methods below were always raising AccessDenied for
-  any process except the current one. Now this is no longer true. Also
-  they are 2.5x faster.
-  - name
-  - get_memory_info()
-  - get_memory_percent()
-  - get_cpu_times()
-  - get_cpu_percent()
-  - get_num_threads()
-- #300: examples/pmap.py script.
-- #301: process_iter() now yields processes sorted by their PIDs.
-- #302: process number of voluntary and involuntary context switches.
-- #303: [Windows] the Process methods below were always raising AccessDenied
-  for any process not owned by current user. Now this is no longer true:
-  - create_time
-  - get_cpu_times()
-  - get_cpu_percent()
-  - get_memory_info()
-  - get_memory_percent()
-  - get_num_handles()
-  - get_io_counters()
-- #305: add examples/netstat.py script.
-- #311: system memory functions has been refactorized and rewritten and now
-  provide a more detailed and consistent representation of the system
-  memory. New psutil.virtual_memory() function provides the following
-  memory amounts:
-  - total
-  - available
-  - percent
-  - used
-  - active [POSIX]
-  - inactive [POSIX]
-  - buffers (BSD, Linux)
-  - cached (BSD, OSX)
-  - wired (OSX, BSD)
-  - shared [FreeBSD]
-  New psutil.swap_memory() provides:
-  - total
-  - used
-  - free
-  - percent
-  - sin (no. of bytes the system has swapped in from disk (cumulative))
-  - sout (no. of bytes the system has swapped out from disk (cumulative))
-  All old memory-related functions are deprecated.
-  Also two new example scripts were added:  free.py and meminfo.py.
-- #312: psutil.network_io_counters() namedtuple includes 4 new fields:
-  errin, errout dropin and dropout, reflecting the number of packets
-  dropped and with errors.
-
-**Bugfixes**
-
-- #298: [OSX and BSD] memory leak in get_num_fds().
-- #299: potential memory leak every time PyList_New(0) is used.
-- #303: [Windows] potential heap corruption in get_num_threads() and
-  get_status() Process methods.
-- #305: [FreeBSD] psutil can't compile on FreeBSD 9 due to removal of utmp.h.
-- #306: at C level, errors are not checked when invoking Py* functions which
-  create or manipulate Python objects leading to potential memory related
-  errors and/or segmentation faults.
-- #307: [FreeBSD] values returned by psutil.network_io_counters() are wrong.
-- #308: [BSD / Windows] psutil.virtmem_usage() wasn't actually returning
-  information about swap memory usage as it was supposed to do. It does
-  now.
-- #309: get_open_files() might not return files which can not be accessed
-  due to limited permissions. AccessDenied is now raised instead.
-
-**API changes**
-
-- psutil.phymem_usage() is deprecated       (use psutil.virtual_memory())
-- psutil.virtmem_usage() is deprecated      (use psutil.swap_memory())
-- psutil.phymem_buffers() on Linux is deprecated  (use psutil.virtual_memory())
-- psutil.cached_phymem() on Linux is deprecated   (use psutil.virtual_memory())
-- [Windows and BSD] psutil.virtmem_usage() now returns information about swap
-  memory instead of virtual memory.
-
-
-0.5.1 - 2012-06-29
-==================
-
-**Enhancements**
-
-- #293: [Windows] process executable path is now determined by asking the OS
-  instead of being guessed from process cmdline.
-
-**Bugfixes**
-
-- #292: [Linux] race condition in process files/threads/connections.
-- #294: [Windows] Process CPU affinity is only able to set CPU #0.
-
-
-0.5.0 - 2012-06-27
-==================
-
-**Enhancements**
-
-- #195: [Windows] number of handles opened by process.
-- #209: psutil.disk_partitions() now provides also mount options.
-- #229: list users currently connected on the system (psutil.get_users()).
-- #238: [Linux, Windows] process CPU affinity (get and set).
-- #242: Process.get_children(recursive=True): return all process
-  descendants.
-- #245: [POSIX] Process.wait() incrementally consumes less CPU cycles.
-- #257: [Windows] removed Windows 2000 support.
-- #258: [Linux] Process.get_memory_info() is now 0.5x faster.
-- #260: process's mapped memory regions. (Windows patch by wj32.64, OSX patch
-  by Jeremy Whitlock)
-- #262: [Windows] psutil.disk_partitions() was slow due to inspecting the
-  floppy disk drive also when "all" argument was False.
-- #273: psutil.get_process_list() is deprecated.
-- #274: psutil no longer requires 2to3 at installation time in order to work
-  with Python 3.
-- #278: new Process.as_dict() method.
-- #281: ppid, name, exe, cmdline and create_time properties of Process class
-  are now cached after being accessed.
-- #282: psutil.STATUS_* constants can now be compared by using their string
-  representation.
-- #283: speedup Process.is_running() by caching its return value in case the
-  process is terminated.
-- #284: [POSIX] per-process number of opened file descriptors.
-- #287: psutil.process_iter() now caches Process instances between calls.
-- #290: Process.nice property is deprecated in favor of new get_nice() and
-  set_nice() methods.
-
-**Bugfixes**
-
-- #193: psutil.Popen constructor can throw an exception if the spawned process
-  terminates quickly.
-- #240: [OSX] incorrect use of free() for Process.get_connections().
-- #244: [POSIX] Process.wait() can hog CPU resources if called against a
-  process which is not our children.
-- #248: [Linux] psutil.network_io_counters() might return erroneous NIC names.
-- #252: [Windows] process getcwd() erroneously raise NoSuchProcess for
-  processes owned by another user.  It now raises AccessDenied instead.
-- #266: [Windows] psutil.get_pid_list() only shows 1024 processes.
-  (patch by Amoser)
-- #267: [OSX] Process.get_connections() - an erroneous remote address was
-  returned. (Patch by Amoser)
-- #272: [Linux] Porcess.get_open_files() - potential race condition can lead to
-  unexpected NoSuchProcess exception.  Also, we can get incorrect reports
-  of not absolutized path names.
-- #275: [Linux] Process.get_io_counters() erroneously raise NoSuchProcess on
-  old Linux versions. Where not available it now raises
-  NotImplementedError.
-- #286: Process.is_running() doesn't actually check whether PID has been
-  reused.
-- #314: Process.get_children() can sometimes return non-children.
-
-**API changes**
-
-- Process.nice property is deprecated in favor of new get_nice() and set_nice()
-  methods.
-- psutil.get_process_list() is deprecated.
-- ppid, name, exe, cmdline and create_time properties of Process class are now
-  cached after being accessed, meaning NoSuchProcess will no longer be raised
-  in case the process is gone in the meantime.
-- psutil.STATUS_* constants can now be compared by using their string
-  representation.
-
-
-0.4.1 - 2011-12-14
-==================
-
-**Bugfixes**
-
-- #228: some example scripts were not working with python 3.
-- #230: [Windows / OSX] memory leak in Process.get_connections().
-- #232: [Linux] psutil.phymem_usage() can report erroneous values which are
-  different than "free" command.
-- #236: [Windows] memory/handle leak in Process's get_memory_info(),
-  suspend() and resume() methods.
-
-
-0.4.0 - 2011-10-29
-==================
-
-**Enhancements**
-
-- #150: network I/O counters. (OSX and Windows patch by Jeremy Whitlock)
-- #154: [FreeBSD] add support for process getcwd()
-- #157: [Windows] provide installer for Python 3.2 64-bit.
-- #198: Process.wait(timeout=0) can now be used to make wait() return
-  immediately.
-- #206: disk I/O counters. (OSX and Windows patch by Jeremy Whitlock)
-- #213: examples/iotop.py script.
-- #217: Process.get_connections() now has a "kind" argument to filter
-  for connections with different criteria.
-- #221: [FreeBSD] Process.get_open_files has been rewritten in C and no longer
-  relies on lsof.
-- #223: examples/top.py script.
-- #227: examples/nettop.py script.
-
-**Bugfixes**
-
-- #135: [OSX] psutil cannot create Process object.
-- #144: [Linux] no longer support 0 special PID.
-- #188: [Linux] psutil import error on Linux ARM architectures.
-- #194: [POSIX] psutil.Process.get_cpu_percent() now reports a percentage over
-  100 on multicore processors.
-- #197: [Linux] Process.get_connections() is broken on platforms not
-  supporting IPv6.
-- #200: [Linux] psutil.NUM_CPUS not working on armel and sparc architectures
-  and causing crash on module import.
-- #201: [Linux] Process.get_connections() is broken on big-endian
-  architectures.
-- #211: Process instance can unexpectedly raise NoSuchProcess if tested for
-  equality with another object.
-- #218: [Linux] crash at import time on Debian 64-bit because of a missing
-  line in /proc/meminfo.
-- #226: [FreeBSD] crash at import time on FreeBSD 7 and minor.
-
-
-0.3.0 - 2011-07-08
-==================
-
-**Enhancements**
-
-- #125: system per-cpu percentage utilization and times.
-- #163: per-process associated terminal (TTY).
-- #171: added get_phymem() and get_virtmem() functions returning system
-  memory information (total, used, free) and memory percent usage.
-  total_* avail_* and used_* memory functions are deprecated.
-- #172: disk usage statistics.
-- #174: mounted disk partitions.
-- #179: setuptools is now used in setup.py
-
-**Bugfixes**
-
-- #159: SetSeDebug() does not close handles or unset impersonation on return.
-- #164: [Windows] wait function raises a TimeoutException when a process
-  returns -1 .
-- #165: process.status raises an unhandled exception.
-- #166: get_memory_info() leaks handles hogging system resources.
-- #168: psutil.cpu_percent() returns erroneous results when used in
-  non-blocking mode.  (patch by Philip Roberts)
-- #178: OSX - Process.get_threads() leaks memory
-- #180: [Windows] Process's get_num_threads() and get_threads() methods can
-  raise NoSuchProcess exception while process still exists.
-
-
-0.2.1 - 2011-03-20
-==================
-
-**Enhancements**
-
-- #64: per-process I/O counters.
-- #116: per-process wait() (wait for process to terminate and return its exit
-  code).
-- #134: per-process get_threads() returning information (id, user and kernel
-  times) about threads opened by process.
-- #136: process executable path on FreeBSD is now determined by asking the
-  kernel instead of guessing it from cmdline[0].
-- #137: per-process real, effective and saved user and group ids.
-- #140: system boot time.
-- #142: per-process get and set niceness (priority).
-- #143: per-process status.
-- #147: per-process I/O nice (priority) - Linux only.
-- #148: psutil.Popen class which tidies up subprocess.Popen and psutil.Process
-  in a unique interface.
-- #152: [OSX] get_process_open_files() implementation has been rewritten
-  in C and no longer relies on lsof resulting in a 3x speedup.
-- #153: [OSX] get_process_connection() implementation has been rewritten
-  in C and no longer relies on lsof resulting in a 3x speedup.
-
-**Bugfixes**
-
-- #83:  process cmdline is empty on OSX 64-bit.
-- #130: a race condition can cause IOError exception be raised on
-  Linux if process disappears between open() and subsequent read() calls.
-- #145: WindowsError was raised instead of psutil.AccessDenied when using
-  process resume() or suspend() on Windows.
-- #146: 'exe' property on Linux can raise TypeError if path contains NULL
-  bytes.
-- #151: exe and getcwd() for PID 0 on Linux return inconsistent data.
-
-**API changes**
-
-- Process "uid" and "gid" properties are deprecated in favor of "uids" and
-  "gids" properties.
-
-
-0.2.0 - 2010-11-13
-==================
-
-**Enhancements**
-
-- #79: per-process open files.
-- #88: total system physical cached memory.
-- #88: total system physical memory buffers used by the kernel.
-- #91: per-process send_signal() and terminate() methods.
-- #95: NoSuchProcess and AccessDenied exception classes now provide "pid",
-  "name" and "msg" attributes.
-- #97: per-process children.
-- #98: Process.get_cpu_times() and Process.get_memory_info now return
-  a namedtuple instead of a tuple.
-- #103: per-process opened TCP and UDP connections.
-- #107: add support for Windows 64 bit. (patch by cjgohlke)
-- #111: per-process executable name.
-- #113: exception messages now include process name and pid.
-- #114: process username Windows implementation has been rewritten in pure
-  C and no longer uses WMI resulting in a big speedup. Also, pywin32 is no
-  longer required as a third-party dependancy. (patch by wj32)
-- #117: added support for Windows 2000.
-- #123: psutil.cpu_percent() and psutil.Process.cpu_percent() accept a
-  new 'interval' parameter.
-- #129: per-process number of threads.
-
-**Bugfixes**
-
-- #80: fixed warnings when installing psutil with easy_install.
-- #81: psutil fails to compile with Visual Studio.
-- #94: suspend() raises OSError instead of AccessDenied.
-- #86: psutil didn't compile against FreeBSD 6.x.
-- #102: orphaned process handles obtained by using OpenProcess in C were
-  left behind every time Process class was instantiated.
-- #111: path and name Process properties report truncated or erroneous
-  values on UNIX.
-- #120: cpu_percent() always returning 100% on OS X.
-- #112: uid and gid properties don't change if process changes effective
-  user/group id at some point.
-- #126: ppid, uid, gid, name, exe, cmdline and create_time properties are
-  no longer cached and correctly raise NoSuchProcess exception if the process
-  disappears.
-
-**API changes**
-
-- psutil.Process.path property is deprecated and works as an alias for "exe"
-  property.
-- psutil.Process.kill(): signal argument was removed - to send a signal to the
-  process use send_signal(signal) method instead.
-- psutil.Process.get_memory_info() returns a nametuple instead of a tuple.
-- psutil.cpu_times() returns a nametuple instead of a tuple.
-- New psutil.Process methods: get_open_files(), get_connections(),
-  send_signal() and terminate().
-- ppid, uid, gid, name, exe, cmdline and create_time properties are no longer
-  cached and raise NoSuchProcess exception if process disappears.
-- psutil.cpu_percent() no longer returns immediately (see issue 123).
-- psutil.Process.get_cpu_percent() and psutil.cpu_percent() no longer returns
-  immediately by default (see issue 123).
-
-
-0.1.3 - 2010-03-02
-==================
-
-**Enhancements**
-
-- #14: per-process username
-- #51: per-process current working directory (Windows and Linux only)
-- #59: Process.is_running() is now 10 times faster
-- #61: added supoprt for FreeBSD 64 bit
-- #71: implemented suspend/resume process
-- #75: python 3 support
-
-**Bugfixes**
-
-- #36: process cpu_times() and memory_info() functions succeeded also for dead
-  processes while a NoSuchProcess exception is supposed to be raised.
-- #48: incorrect size for mib array defined in getcmdargs for BSD
-- #49: possible memory leak due to missing free() on error condition on
-- #50: fixed getcmdargs() memory fragmentation on BSD
-- #55: test_pid_4 was failing on Windows Vista
-- #57: some unit tests were failing on systems where no swap memory is
-  available
-- #58: is_running() is now called before kill() to make sure we are going
-  to kill the correct process.
-- #73: virtual memory size reported on OS X includes shared library size
-- #77: NoSuchProcess wasn't raised on Process.create_time if kill() was
-  used first.
-
-
-0.1.2 - 2009-05-06
-==================
-
-**Enhancements**
-
-- #32: Per-process CPU user/kernel times
-- #33: Process create time
-- #34: Per-process CPU utilization percentage
-- #38: Per-process memory usage (bytes)
-- #41: Per-process memory utilization (percent)
-- #39: System uptime
-- #43: Total system virtual memory
-- #46: Total system physical memory
-- #44: Total system used/free virtual and physical memory
-
-**Bugfixes**
-
-- #36: [Windows] NoSuchProcess not raised when accessing timing methods.
-- #40: test_get_cpu_times() failing on FreeBSD and OS X.
-- #42: [Windows] get_memory_percent() raises AccessDenied.
-
-
-0.1.1 - 2009-03-06
-==================
-
-**Enhancements**
-
-- #4: FreeBSD support for all functions of psutil
-- #9: Process.uid and Process.gid now retrieve process UID and GID.
-- #11: Support for parent/ppid - Process.parent property returns a
-  Process object representing the parent process, and Process.ppid returns
-  the parent PID.
-- #12 & 15:
-  NoSuchProcess exception now raised when creating an object
-  for a nonexistent process, or when retrieving information about a process
-  that has gone away.
-- #21: AccessDenied exception created for raising access denied errors
-  from OSError or WindowsError on individual platforms.
-- #26: psutil.process_iter() function to iterate over processes as
-  Process objects with a generator.
-- #?:  Process objects can now also be compared with == operator for equality
-  (PID, name, command line are compared).
-
-**Bugfixes**
-
-- #16: [Windows] Special case for "System Idle Process" (PID 0) which
-  otherwise would return an "invalid parameter" exception.
-- #17: get_process_list() ignores NoSuchProcess and AccessDenied
-  exceptions during building of the list.
-- #22: [Windows] Process(0).kill() was failing with an unset exception.
-- #23: Special case for pid_exists(0)
-- #24: [Windows] Process(0).kill() now raises AccessDenied exception instead
-  of WindowsError.
-- #30: psutil.get_pid_list() was returning two ins
+- https://psutil.io/changelog/
diff --git a/IDEAS b/IDEAS
deleted file mode 100644
index 9eb7d76266..0000000000
--- a/IDEAS
+++ /dev/null
@@ -1,147 +0,0 @@
-TODO
-====
-
-A collection of ideas and notes about stuff to implement in future versions.
-"#NNN" occurrences refer to bug tracker issues at:
-https://github.com/giampaolo/psutil/issues
-
-PLATFORMS
-=========
-
-- #355 (patch): Android
-- #605 (branch): AIX
-- #276: GNU/Hurd
-- DragonFlyBSD
-- HP-UX
-
-FEATURES
-========
-
-- (Linux): from /proc/pid/stat we can also retrieve process and children guest
-  times (time spent running a virtual CPU for a guest OS).
-
-- #809: (Linux) per-process resource limits.
-
-- (UNIX) process root (different from cwd)
-
-- #782: (UNIX) process num of signals received.
-
-- (Linux) locked files via /proc/locks:
-  https://www.centos.org/docs/5/html/5.2/Deployment_Guide/s2-proc-locks.html
-
-- #371: CPU temperature (apparently OSX and Linux only; on Linux it requires
-  lm-sensors lib).
-
-- #269: NIC rx/tx queue. This should probably go into net_if_stats().
-  Figure out on what platforms this is supported:
-  Linux: yes
-  Others: ?
-
-- Process.threads(): thread names; patch for OSX available at:
-  https://code.google.com/p/plcrashreporter/issues/detail?id=65
-  Sample code:
-  https://github.com/janmojzis/pstree/blob/master/proc_kvm.c
-
-- Asynchronous psutil.Popen (see http://bugs.python.org/issue1191964)
-
-- (Windows) fall back on using WMIC for Process methods returning AccessDenied
-
-- #613: thread names.
-
-- #604: emulate os.getloadavg() on Windows
-
-- scripts/taskmgr-gui.py (using tk).
-
-- system-wide number of open file descriptors:
-  - https://jira.hyperic.com/browse/SIGAR-30
-  - http://www.netadmintools.com/part295.html
-
-- Number of system threads.
-  - Windows: http://msdn.microsoft.com/en-us/library/windows/desktop/ms684824(v=vs.85).aspx
-
-- #357: what CPU a process is on.
-
-- Doc / wiki which compares similarities between UNIX cli tools and psutil.
-  Example:
-  ```
-  df -a  ->  psutil.disk_partitions
-  lsof  ->  psutil.Process.open_files() and psutil.Process.open_connections()
-  killall->  (actual script)
-  tty  ->  psutil.Process.terminal()
-  who  ->  psutil.users()
-  ```
-
-- psutil.proc_tree() something which obtains a {pid:ppid, ...} dict for
-  all running processes in one shot. This can be factored out from
-  Process.children() and exposed as a first class function.
-  PROS: on Windows we can take advantage of _psutil_windows.ppid_map()
-  which is faster than iterating over all pids and calling ppid().
-  CONS: scripts/pstree.py shows this can be easily done in the user code
-  so maybe it's not worth the addition.
-
-- advanced cmdline interface exposing the whole API and providing different
-  kind of outputs (e.g. pprinted, colorized, json).
-
-- [Linux]: process cgroups (http://en.wikipedia.org/wiki/Cgroups). They look
-  similar to prlimit() in terms of functionality but uglier (they should allow
-  limiting per-process network IO resources though, which is great). Needs
-  further reading.
-
-- Python 3.3. exposed different sched.h functions:
-  http://docs.python.org/dev/whatsnew/3.3.html#os
-  http://bugs.python.org/issue12655
-  http://docs.python.org/dev/library/os.html#interface-to-the-scheduler
-  It might be worth to take a look and figure out whether we can include some
-  of those in psutil.
-  Also, we can probably reimplement wait_pid() on POSIX which is currently
-  implemented as a busy-loop.
-
-- os.times() provides 'elapsed' times (cpu_times() might).
-
-- ...also guest_time and cguest_time on Linux.
-
-- Enrich exception classes hierarchy on Python >= 3.3 / post PEP-3151 so that:
-   - NoSuchProcess inherits from ProcessLookupError
-   - AccessDenied inherits from PermissionError
-   - TimeoutExpired inherits from TimeoutError (debatable)
-   See: http://docs.python.org/3/library/exceptions.html#os-exceptions
-
-- Process.threads() might grow an extra "id" parameter so that it can be
-   used as such:
-  ```
-  >>> p = psutil.Process(os.getpid())
-  >>> p.threads(id=psutil.current_thread_id())
-  thread(id=2539, user_time=0.03, system_time=0.02)
-  >>>
-  ```
-  Note: this leads to questions such as "should we have a custom NoSuchThread
-  exception? Also see issue #418.
-  Note #2: this would work with os.getpid() only.
-  psutil.current_thread_id() might be desirable as per issue #418 though.
-
-- should psutil.TimeoutExpired exception have a 'msg' kwarg similar to
-  NoSuchProcess and AccessDenied? Not that we need it, but currently we
-  cannot raise a TimeoutExpired exception with a specific error string.
-
-- process_iter() might grow an "attrs" parameter similar to Process.as_dict()
-  invoke the necessary methods and include the results into a "cache"
-  attribute attached to the returned Process instances so that one can avoid
-  catching NSP and AccessDenied:
-  for p in process_iter(attrs=['cpu_percent']):
-  print(p.cache['cpu_percent'])
-  This also leads questions as whether we should introduce a sorting order.
-
-- round Process.memory_percent() result?
-
-- #550: number of threads per core.
-
-- Have psutil.Process().cpu_affinity([]) be an alias for "all CPUs"?
-
-
-RESOURCES
-=========
-
-- sigar: https://github.com/hyperic/sigar (Java)
-- zabbix: https://zabbix.org/wiki/Get_Zabbix
-- libstatgrab: http://www.i-scream.org/libstatgrab/
-- top: http://www.unixtop.org/
diff --git a/INSTALL.rst b/INSTALL.rst
index 05bbc9c354..3165300fe4 100644
--- a/INSTALL.rst
+++ b/INSTALL.rst
@@ -1,120 +1,3 @@
-*Note: pip is the easiest way to install psutil.
-It is shipped by default with Python 2.7.9+ and 3.4+. If you're using an
-older Python version* `install pip <https://pip.pypa.io/en/latest/installing/>`__
-*first.* If you cloned psutil source code you can also install it with
-``make install-pip``.
+Installation instructions have moved to:
 
-Permission issues
-=================
-
-Except for Linux, the commands below assume you're running as root.
-If you're not and you bump into permission errors you can either:
-
-* prepend ``sudo``, e.g.:
-
-::
-
-    sudo pip install psutil
-
-* install psutil for your user only (not at system level):
-
-::
-
-    pip install --user psutil
-
-Linux
-=====
-
-Ubuntu / Debian (use ``python3-dev`` and ``python3-pip`` for python 3)::
-
-    sudo apt-get install gcc python-dev python-pip
-    pip install psutil
-
-RedHat (use ``python3-devel`` and ``python3-pip`` for python 3)::
-
-    sudo yum install gcc python-devel python-pip
-    pip install psutil
-
-OSX
-===
-
-Install `XcodeTools <https://developer.apple.com/downloads/?name=Xcode>`__
-first, then:
-
-::
-
-    pip install psutil
-
-Windows
-=======
-
-The easiest way to install psutil on Windows is to just use the pre-compiled
-exe/wheel installers on
-`PYPI <https://pypi.python.org/pypi/psutil/#downloads>`__ via pip::
-
-    C:\Python27\python.exe -m pip install psutil
-
-If you want to compile psutil from sources you'll need **Visual Studio**
-(Mingw32 is no longer supported):
-
-* Python 2.6, 2.7: `VS-2008 <http://www.microsoft.com/en-us/download/details.aspx?id=44266>`__
-* Python 3.3, 3.4: `VS-2010 <http://www.visualstudio.com/downloads/download-visual-studio-vs#d-2010-express>`__
-* Python 3.5+: `VS-2015 <http://www.visualstudio.com/en-au/news/vs2015-preview-vs>`__
-
-Compiling 64 bit versions of Python 2.6 and 2.7 with VS 2008 requires
-`Windows SDK and .NET Framework 3.5 SP1 <https://www.microsoft.com/en-us/download/details.aspx?id=3138>`__.
-Once installed run vcvars64.bat, then you can finally compile (see
-`here <http://stackoverflow.com/questions/11072521/>`__).
-To compile / install psutil from sources on Windows run::
-
-    make.bat build
-    make.bat install
-
-FreeBSD
-=======
-
-::
-
-    pkg install python gcc
-    python -m pip install psutil
-
-OpenBSD
-=======
-
-::
-
-    export PKG_PATH=http://ftp.usa.openbsd.org/pub/OpenBSD/`uname -r`/packages/`arch -s`
-    pkg_add -v python gcc
-    python -m pip install psutil
-
-NetBSD
-======
-
-::
-
-    export PKG_PATH="ftp.netbsd.org/pub/pkgsrc/packages/NetBSD/`uname -m`/`uname -r`/All"
-    pkg_add -v pkgin
-    pkgin install python gcc
-    python -m pip install psutil
-
-Solaris
-=======
-
-If ``cc`` compiler is not installed create a symlink to ``gcc``:
-
-::
-
-    sudo ln -s /usr/bin/gcc /usr/local/bin/cc
-
-Install:
-
-::
-
-    pkg install gcc
-    python -m pip install psutil
-
-Dev Guide
-=========
-
-If you plan on hacking on psutil you may want to take a look at the
-`dev guide <https://github.com/giampaolo/psutil/blob/master/DEVGUIDE.rst>`__.
+- https://psutil.io/install/
diff --git a/LICENSE b/LICENSE
index e91b1359a2..cff5eb74e1 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
-psutil is distributed under BSD license reproduced below.
+BSD 3-Clause License
 
-Copyright (c) 2009, Jay Loden, Dave Daeschler, Giampaolo Rodola'
+Copyright (c) 2009, Jay Loden, Dave Daeschler, Giampaolo Rodola
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification,
@@ -8,9 +8,11 @@ are permitted provided that the following conditions are met:
 
  * Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.
+
  * Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.
+
  * Neither the name of the psutil authors nor the names of its contributors
    may be used to endorse or promote products derived from this software without
    specific prior written permission.
diff --git a/MANIFEST.in b/MANIFEST.in
index 67280314b9..40739f4dd9 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,22 +1,204 @@
-include .coveragerc
-include .git-pre-commit
+include .clang-format
+include .dprint.jsonc
 include .gitignore
-include .travis.yml
-include appveyor.yml
-include CREDITS
-include DEVGUIDE.rst
+include CONTRIBUTING.md
 include HISTORY.rst
-include IDEAS
 include INSTALL.rst
 include LICENSE
-include make.bat
-include Makefile
 include MANIFEST.in
+include Makefile
 include README.rst
+include SECURITY.md
+include _bootstrap.py
+include psutil/__init__.py
+include psutil/_common.py
+include psutil/_enums.py
+include psutil/_ntuples.py
+include psutil/_psaix.py
+include psutil/_psbsd.py
+include psutil/_pslinux.py
+include psutil/_psosx.py
+include psutil/_psposix.py
+include psutil/_pssunos.py
+include psutil/_psutil_aix.c
+include psutil/_psutil_bsd.c
+include psutil/_psutil_linux.c
+include psutil/_psutil_osx.c
+include psutil/_psutil_sunos.c
+include psutil/_psutil_windows.c
+include psutil/_pswindows.py
+include psutil/arch/aix/cpu.c
+include psutil/arch/aix/disk.c
+include psutil/arch/aix/ifaddrs.c
+include psutil/arch/aix/ifaddrs.h
+include psutil/arch/aix/init.h
+include psutil/arch/aix/mem.c
+include psutil/arch/aix/net.c
+include psutil/arch/aix/net_kernel_structs.h
+include psutil/arch/aix/proc.c
+include psutil/arch/aix/socks.c
+include psutil/arch/aix/sys.c
+include psutil/arch/all/errors.c
+include psutil/arch/all/init.c
+include psutil/arch/all/init.h
+include psutil/arch/all/pids.c
+include psutil/arch/all/str.c
+include psutil/arch/all/utils.c
+include psutil/arch/bsd/cpu.c
+include psutil/arch/bsd/disk.c
+include psutil/arch/bsd/heap.c
+include psutil/arch/bsd/init.c
+include psutil/arch/bsd/init.h
+include psutil/arch/bsd/mem.c
+include psutil/arch/bsd/net.c
+include psutil/arch/bsd/proc.c
+include psutil/arch/bsd/proc_utils.c
+include psutil/arch/bsd/sys.c
+include psutil/arch/freebsd/cpu.c
+include psutil/arch/freebsd/disk.c
+include psutil/arch/freebsd/init.h
+include psutil/arch/freebsd/mem.c
+include psutil/arch/freebsd/pids.c
+include psutil/arch/freebsd/proc.c
+include psutil/arch/freebsd/proc_socks.c
+include psutil/arch/freebsd/sensors.c
+include psutil/arch/freebsd/sys_socks.c
+include psutil/arch/linux/disk.c
+include psutil/arch/linux/heap.c
+include psutil/arch/linux/init.h
+include psutil/arch/linux/mem.c
+include psutil/arch/linux/net.c
+include psutil/arch/linux/proc.c
+include psutil/arch/netbsd/cpu.c
+include psutil/arch/netbsd/disk.c
+include psutil/arch/netbsd/init.h
+include psutil/arch/netbsd/mem.c
+include psutil/arch/netbsd/pids.c
+include psutil/arch/netbsd/proc.c
+include psutil/arch/netbsd/socks.c
+include psutil/arch/openbsd/cpu.c
+include psutil/arch/openbsd/disk.c
+include psutil/arch/openbsd/init.h
+include psutil/arch/openbsd/mem.c
+include psutil/arch/openbsd/pids.c
+include psutil/arch/openbsd/proc.c
+include psutil/arch/openbsd/socks.c
+include psutil/arch/openbsd/users.c
+include psutil/arch/osx/cpu.c
+include psutil/arch/osx/disk.c
+include psutil/arch/osx/heap.c
+include psutil/arch/osx/init.c
+include psutil/arch/osx/init.h
+include psutil/arch/osx/mem.c
+include psutil/arch/osx/net.c
+include psutil/arch/osx/pids.c
+include psutil/arch/osx/proc.c
+include psutil/arch/osx/proc_utils.c
+include psutil/arch/osx/sensors.c
+include psutil/arch/osx/sys.c
+include psutil/arch/posix/init.c
+include psutil/arch/posix/init.h
+include psutil/arch/posix/net.c
+include psutil/arch/posix/pids.c
+include psutil/arch/posix/proc.c
+include psutil/arch/posix/sysctl.c
+include psutil/arch/posix/users.c
+include psutil/arch/sunos/cpu.c
+include psutil/arch/sunos/disk.c
+include psutil/arch/sunos/environ.c
+include psutil/arch/sunos/init.h
+include psutil/arch/sunos/mem.c
+include psutil/arch/sunos/net.c
+include psutil/arch/sunos/proc.c
+include psutil/arch/sunos/sys.c
+include psutil/arch/windows/cpu.c
+include psutil/arch/windows/disk.c
+include psutil/arch/windows/heap.c
+include psutil/arch/windows/init.c
+include psutil/arch/windows/init.h
+include psutil/arch/windows/mem.c
+include psutil/arch/windows/net.c
+include psutil/arch/windows/ntextapi.h
+include psutil/arch/windows/pids.c
+include psutil/arch/windows/proc.c
+include psutil/arch/windows/proc_handles.c
+include psutil/arch/windows/proc_peb.c
+include psutil/arch/windows/proc_utils.c
+include psutil/arch/windows/security.c
+include psutil/arch/windows/sensors.c
+include psutil/arch/windows/services.c
+include psutil/arch/windows/socks.c
+include psutil/arch/windows/sys.c
+include psutil/arch/windows/wmi.c
+include pyproject.toml
+include scripts/battery.py
+include scripts/cpu_distribution.py
+include scripts/disk_usage.py
+include scripts/fans.py
+include scripts/free.py
+include scripts/ifconfig.py
+include scripts/internal/README
+include scripts/internal/bench_oneshot.py
+include scripts/internal/bench_oneshot_2.py
+include scripts/internal/cfarm-test.sh
+include scripts/internal/convert_readme.py
+include scripts/internal/docs/build_versions.py
+include scripts/internal/docs/find_adopters.py
+include scripts/internal/docs/new_blog_post.py
+include scripts/internal/docs/refresh_adoption_stats.py
+include scripts/internal/docs/rst_unused_targets.py
+include scripts/internal/download_wheels.py
+include scripts/internal/find_broken_links.py
+include scripts/internal/generate_manifest.py
+include scripts/internal/git_pre_commit.py
+include scripts/internal/install-pydeps.sh
+include scripts/internal/install-sysdeps.sh
+include scripts/internal/install_pip.py
+include scripts/internal/print_access_denied.py
+include scripts/internal/print_announce.py
+include scripts/internal/print_api_speed.py
+include scripts/internal/print_dist.py
+include scripts/internal/print_downloads.py
+include scripts/internal/print_hashes.py
+include scripts/internal/print_sysinfo.py
+include scripts/internal/purge_installation.py
+include scripts/iotop.py
+include scripts/killall.py
+include scripts/meminfo.py
+include scripts/netstat.py
+include scripts/nettop.py
+include scripts/pidof.py
+include scripts/pmap.py
+include scripts/procinfo.py
+include scripts/procsmem.py
+include scripts/ps.py
+include scripts/pstree.py
+include scripts/sensors.py
+include scripts/temperatures.py
+include scripts/top.py
+include scripts/who.py
+include scripts/winservices.py
 include setup.py
-include tox.ini
-recursive-exclude docs/_build *
-recursive-include .ci *
-recursive-include docs *
-recursive-include psutil *.py *.c *.h README*
-recursive-include scripts *.py
+include tests/README.md
+include tests/__init__.py
+include tests/conftest.py
+include tests/test_aix.py
+include tests/test_bsd.py
+include tests/test_connections.py
+include tests/test_contracts.py
+include tests/test_heap.py
+include tests/test_linux.py
+include tests/test_memleaks.py
+include tests/test_misc.py
+include tests/test_osx.py
+include tests/test_posix.py
+include tests/test_process.py
+include tests/test_process_all.py
+include tests/test_scripts.py
+include tests/test_sudo.py
+include tests/test_sunos.py
+include tests/test_system.py
+include tests/test_testutils.py
+include tests/test_type_hints.py
+include tests/test_unicode.py
+include tests/test_windows.py
diff --git a/Makefile b/Makefile
index b23249cd0d..87a16ce10b 100644
--- a/Makefile
+++ b/Makefile
@@ -1,129 +1,191 @@
-# Shortcuts for various tasks (UNIX only).
-# To use a specific Python version run: "make install PYTHON=python3.3"
-
-# You can set these variables from the command line.
-PYTHON = python
-TSCRIPT = psutil/tests/runner.py
-
-# For internal use.
-DEPS = coverage \
-	flake8 \
-	futures \
-	ipdb \
-	mock==1.0.1 \
-	nose \
-	pep8 \
-	pyflakes \
-	requests \
-	sphinx \
-	sphinx-pypi-upload \
-	unittest2
-
-all: test
+# Shortcuts for various development tasks.
+#
+# - To use this on Windows install Git For Windows first, then launch a Git
+#   Bash Shell.
+# - To use a specific Python version run: `make install PYTHON=python3.13`.
+# - To append an argument to a command use ARGS, e.g: `make test ARGS="-k
+#   some_test`.
+# - Needs GNU make >= 4.0, and must also parse with BSD make, which runs
+#   `make ci-test` on the *BSD CI. BSD make dies on a `:` inside `$(...)`,
+#   so keep those out of file scope. Other GNU-only bits are fine as long
+#   as they stay in targets the BSDs don't run.
+
+# Configurable
+PYTHON = python3
+ARGS =
+FILES =
+
+PYTHON_ENV_VARS = PYTHONWARNINGS=always PYTHONUNBUFFERED=1 PSUTIL_DEBUG=1 PSUTIL_TESTING=1 PYTEST_DISABLE_PLUGIN_AUTOLOAD=1
+SUDO = $(if $(filter $(OS),Windows_NT),,sudo -E)
+DPRINT = ~/.dprint/bin/dprint
+INSTALL_PYDEPS = PYTHON=$(PYTHON) ./scripts/internal/install-pydeps.sh
+
+# `make` called with no args is like `make help`
+.DEFAULT_GOAL := help
+.PHONY: build test
+
+# install git hook (skipped in worktrees, where .git is a file)
+_ := $(shell test -d .git && mkdir -p .git/hooks/ && ln -sf ../../scripts/internal/git_pre_commit.py .git/hooks/pre-commit && chmod +x .git/hooks/pre-commit)
 
 # ===================================================================
 # Install
 # ===================================================================
 
-clean:
-	rm -f `find . -type f -name \*.py[co]`
-	rm -f `find . -type f -name \*.so`
-	rm -f `find . -type f -name \*.~`
-	rm -f `find . -type f -name \*.orig`
-	rm -f `find . -type f -name \*.bak`
-	rm -f `find . -type f -name \*.rej`
-	rm -rf `find . -type d -name __pycache__`
-	rm -rf *.core
-	rm -rf *.egg-info
-	rm -rf *\$testfile*
-	rm -rf .coverage
-	rm -rf .tox
-	rm -rf build/
-	rm -rf dist/
-	rm -rf docs/_build/
-	rm -rf htmlcov/
-	rm -rf tmp/
-
-build: clean
-	$(PYTHON) setup.py build
-	@# copies *.so files in ./psutil directory in order to allow
-	@# "import psutil" when using the interactive interpreter from within
-	@# this directory.
-	$(PYTHON) setup.py build_ext -i
-	rm -rf tmp
-
-install: build
-	$(PYTHON) setup.py develop --user
-	rm -rf tmp
-
-uninstall:
-	cd ..; $(PYTHON) -m pip uninstall -y -v psutil
-
-install-pip:
-	# Install PIP (only if necessary).
-	$(PYTHON) -c "import sys, ssl, os, pkgutil, tempfile, atexit; \
-				sys.exit(0) if pkgutil.find_loader('pip') else None; \
-				pyexc = 'from urllib.request import urlopen' if sys.version_info[0] == 3 else 'from urllib2 import urlopen'; \
-				exec(pyexc); \
-				context = ssl._create_unverified_context() if hasattr(ssl, '_create_unverified_context') else None; \
-				kw = dict(context=context) if context else {}; \
-				req = urlopen('https://bootstrap.pypa.io/get-pip.py', **kw); \
-				data = req.read(); \
-				f = tempfile.NamedTemporaryFile(suffix='.py'); \
-				atexit.register(f.close); \
-				f.write(data); \
-				f.flush(); \
-				print('downloaded %s' % f.name); \
-				code = os.system('%s %s --user' % (sys.executable, f.name)); \
-				sys.exit(code);"
-
-# Install useful deps which are nice to have while developing / testing.
-setup-dev-env: install-git-hooks install-pip
-	$(PYTHON) -m pip install --user --upgrade pip
-	$(PYTHON) -m pip install --user --upgrade $(DEPS)
+clean:  ## Remove all build files.
+	@rm -rfv `find . \
+		-type d -name __pycache__ \
+		-o -type f -name \*.bak \
+		-o -type f -name \*.orig \
+		-o -type f -name \*.pyc \
+		-o -type f -name \*.pyd \
+		-o -type f -name \*.pyo \
+		-o -type f -name \*.rej \
+		-o -type f -name \*.so \
+		-o -type f -name \*.~ \
+		-o -name \*@psutil-\*`
+	@rm -rfv \
+		*.core \
+		*.egg-info \
+		*\@psutil-* \
+		.coverage \
+		.failed-tests.txt \
+		.pytest_cache \
+		.ruff_cache/ \
+		.tests \
+		build/ \
+		dist/ \
+		docs/_build/ \
+		htmlcov/ \
+		pytest-cache-files* \
+		wheelhouse
+
+build:  ## Compile (in parallel) without installing.
+	@# "build_ext -i" copies compiled *.so files in ./psutil directory in order
+	@# to allow "import psutil" when using the interactive interpreter from
+	@# within  this directory.
+	$(PYTHON_ENV_VARS) $(PYTHON) setup.py build_ext --inplace
+	$(PYTHON_ENV_VARS) $(PYTHON) -c "import psutil"  # make sure it actually worked
+
+install:  ## Install this package as current user in edit / development mode.
+	# --no-build-isolation: reuse setuptools installed above instead of
+	# downloading another copy into a temporary build env.
+	$(PYTHON_ENV_VARS) $(INSTALL_PYDEPS) --no-build-isolation --editable .
+	$(PYTHON_ENV_VARS) $(PYTHON) -c "import psutil"  # make sure it actually worked
+
+uninstall:  ## Uninstall this package via pip.
+	cd ..; $(PYTHON_ENV_VARS) $(PYTHON) -m pip uninstall -y -v psutil || true
+	$(PYTHON_ENV_VARS) $(PYTHON) scripts/internal/purge_installation.py
+
+install-sysdeps:  ## Install system deps needed to compile psutil.
+	./scripts/internal/install-sysdeps.sh
+
+install-sysdeps-test:  ## Install CLI tools needed to run unit tests.
+	./scripts/internal/install-sysdeps.sh --test-only
+
+# ---
+
+install-pydeps-build:  ## Install python deps necessary to compile psutil.
+	$(INSTALL_PYDEPS) --group build
+
+install-pydeps-test:  ## Install python deps necessary to run unit tests.
+	$(INSTALL_PYDEPS) --group test
+
+install-pydeps-lint:  ## Install python deps necessary to run linters.
+	$(INSTALL_PYDEPS) --group lint
+
+install-pydeps-docs:  ## Install python deps necessary to build the doc.
+	$(INSTALL_PYDEPS) --group docs
+
+install-pydeps-dev:  ## Install python deps meant for local development.
+	$(INSTALL_PYDEPS) --group dev
 
 # ===================================================================
 # Tests
 # ===================================================================
 
-# Run all tests.
-test: install
-	$(PYTHON) $(TSCRIPT)
+# - cache dir on Windows often causes "Permission denied" errors
+# - drop instafail on CI: conftest.py already repeats failures at the end,
+#   and instafail is only useful while developing locally
+_PYTEST_EXTRA = `{ if [ "$$OS" = "Windows_NT" ]; then printf '%s ' '-o cache_dir=/tmp/pytest-psutil-cache'; fi; if [ -n "$$CI" ]; then printf '%s ' '-p no:instafail'; fi; }`
 
-# Test psutil process-related APIs.
-test-process: install
-	$(PYTHON) -m unittest -v psutil.tests.test_process
+RUN_TEST = $(PYTHON_ENV_VARS) $(PYTHON) -m pytest --durations=5 $(_PYTEST_EXTRA)
+RUN_TEST_MEMLEAKS = PYTHONMALLOC=malloc $(RUN_TEST) -k test_memleaks.py
 
-# Test psutil system-related APIs.
-test-system: install
-	$(PYTHON) -m unittest -v psutil.tests.test_system
+# --- main
 
-# Test misc.
-test-misc: install
-	$(PYTHON) psutil/tests/test_misc.py
+test:  ## Run all tests (except memleak tests).
+	# To run a specific test do `make test ARGS=tests/test_process.py::TestProcess::test_cmdline`
+	$(RUN_TEST) $(ARGS)
 
-# Test memory leaks.
-test-memleaks: install
-	$(PYTHON) psutil/tests/test_memory_leaks.py
+test-parallel:  ## Run all tests (except memleak tests) in parallel.
+	$(RUN_TEST) -n auto --dist loadgroup -m 'not isolated' $(ARGS)
+	$(RUN_TEST) -m isolated $(ARGS)
 
-# Run specific platform tests only.
-test-platform: install
-	$(PYTHON) psutil/tests/test_`$(PYTHON) -c 'import psutil; print([x.lower() for x in ("LINUX", "BSD", "OSX", "SUNOS", "WINDOWS") if getattr(psutil, x)][0])'`.py
+test-memleaks:  ## Run memory leak tests.
+	$(RUN_TEST_MEMLEAKS) $(ARGS)
 
-# Run a specific test by name; e.g. "make test-by-name disk_" will run
-# all test methods containing "disk_" in their name.
-# Requires "pip install nose".
-test-by-name: install
-	@$(PYTHON) -m nose psutil/tests/*.py --nocapture -v -m $(filter-out $@,$(MAKECMDGOALS))
+test-memleaks-parallel:  ## Run memory leak tests in parallel.
+	$(RUN_TEST_MEMLEAKS) -n auto $(ARGS)
 
-# Same as above but for test_memory_leaks.py script.
-test-memleaks-by-name: install
-	@$(PYTHON) -m nose test/test_memory_leaks.py --nocapture -v -m $(filter-out $@,$(MAKECMDGOALS))
+# --- individual
 
-coverage: install
-	# Note: coverage options are controlled by .coveragerc file
+test-process:  ## Run process-related tests.
+	$(RUN_TEST) -k "test_process.py or test_proc or test_pid or Process or pids or pid_exists" $(ARGS)
+
+test-process-all:  ## Run tests which iterate over all process PIDs.
+	$(RUN_TEST) -k test_process_all.py $(ARGS)
+
+test-system:  ## Run system-related API tests.
+	$(RUN_TEST) -k "test_system.py or test_sys or System or disk or sensors or net_io_counters or net_if_addrs or net_if_stats or users or pids or win_service_ or boot_time" $(ARGS)
+
+test-misc:  ## Run miscellaneous tests.
+	$(RUN_TEST) -k "test_misc.py or Misc" $(ARGS)
+
+test-scripts:  ## Run scripts tests.
+	$(RUN_TEST) -k test_scripts.py $(ARGS)
+
+test-testutils:  ## Run test utils tests.
+	$(RUN_TEST) -k test_testutils.py $(ARGS)
+
+test-unicode:  ## Test APIs dealing with strings.
+	$(RUN_TEST) -k test_unicode.py $(ARGS)
+
+test-contracts:  ## APIs sanity tests.
+	$(RUN_TEST) -k test_contracts.py $(ARGS)
+
+test-docs:  ## Run doc sanity tests (outside testpaths, run on demand).
+	$(MAKE) -C docs test ARGS="$(ARGS)"
+
+test-bots:  ## Run GitHub bot tests (outside testpaths, run on demand).
+	$(PYTHON) -m pytest -o addopts="" .github/workflows/tests/ $(ARGS)
+
+test-type-hints:  ## Test type hints
+	$(RUN_TEST) -k test_type_hints.py $(ARGS)
+
+test-connections:  ## Test psutil.net_connections() and Process.net_connections().
+	$(RUN_TEST) -k "test_connections.py or net_" $(ARGS)
+
+test-heap:  ## Test psutil.heap_*() APIs.
+	$(RUN_TEST) -k "test_heap.py or heap_" $(ARGS)
+
+test-posix:  ## POSIX specific tests.
+	$(RUN_TEST) -k "test_posix.py or posix_ or Posix" $(ARGS)
+
+test-platform:  ## Run specific platform tests only.
+	$(RUN_TEST) -k test_`$(PYTHON) -c 'import psutil; print([x.lower() for x in ("LINUX", "BSD", "OSX", "SUNOS", "WINDOWS", "AIX") if getattr(psutil, x)][0])'`.py $(ARGS)
+
+# --- special
+
+test-sudo:  ## Run tests requiring root privileges.
+	# Use unittest runner because pytest may not be installed as root.
+	$(SUDO) $(PYTHON_ENV_VARS) $(PYTHON) -m unittest -v tests.test_sudo
+
+test-last-failed:  ## Re-run tests which failed on last run
+	$(RUN_TEST) --last-failed $(ARGS)
+
+coverage:  ## Run test coverage.
 	rm -rf .coverage htmlcov
-	$(PYTHON) -m coverage run $(TSCRIPT)
+	$(PYTHON_ENV_VARS) $(PYTHON) -m coverage run -m pytest $(ARGS)
 	$(PYTHON) -m coverage report
 	@echo "writing results to htmlcov/index.html"
 	$(PYTHON) -m coverage html
@@ -133,48 +195,231 @@ coverage: install
 # Linters
 # ===================================================================
 
-pep8:
-	@git ls-files | grep \\.py$ | xargs $(PYTHON) -m pep8
+# Return a shell pipeline that outputs one file per line. Uses
+# $(FILES) if set, else "git ls-files" with given pattern(s).
+_ls = $(if $(FILES), printf '%s\n' $(FILES), git ls-files $(1))
+
+ruff:  ## Run ruff linter.
+	@$(call _ls,'*.py') | xargs $(PYTHON) -m ruff check --output-format=concise
+
+black:  ## Run black formatter.
+	@$(call _ls,'*.py') | xargs $(PYTHON) -m black --check --safe
+
+lint-c:  ## Run C linter.
+	@$(call _ls,'*.c' '*.h') | xargs -P0 -I{} clang-format --dry-run --Werror {}
 
-pyflakes:
-	@export PYFLAKES_NODOCTEST=1 && \
-		git ls-files | grep \\.py$ | xargs $(PYTHON) -m pyflakes
+dprint:  ## Run linter for .md / .json / .yml / .js / .css files.
+	@$(DPRINT) check
 
-flake8:
-	@git ls-files | grep \\.py$ | xargs $(PYTHON) -m flake8
+lint-rst:  ## Run linter for .rst files.
+	@$(call _ls,'*.rst') | xargs $(PYTHON) scripts/internal/docs/rst_unused_targets.py
+	@$(call _ls,'*.rst') | xargs sphinx-lint --enable all --disable line-too-long
+	@$(call _ls,'*.rst') | xargs rstwrap --check
+
+lint-toml:  ## Run linter for pyproject.toml.
+	@$(call _ls,'*.toml') | xargs toml-sort --check
+
+lint-all:  ## Run all linters in parallel
+	$(MAKE) -j \
+		black \
+		ruff \
+		lint-c \
+		dprint \
+		lint-rst \
+		lint-toml
+
+# --- not mandatory linters (just run from time to time)
+
+pylint:  ## Python pylint
+	@$(call _ls,'*.py') | xargs $(PYTHON) -m pylint --rcfile=pyproject.toml --jobs=0 $(ARGS)
+
+vulture:  ## Find unused code
+	@$(call _ls,'*.py') | xargs $(PYTHON) -m vulture $(ARGS)
 
 # ===================================================================
-# GIT
+# Fixers
 # ===================================================================
 
-# git-tag a new release
-git-tag-release:
-	git tag -a release-`python -c "import setup; print(setup.get_version())"` -m `git rev-list HEAD --count`:`git rev-parse --short HEAD`
-	git push --follow-tags
+fix-black:  ## Reformat python code with black.
+	@$(call _ls,'*.py') | xargs $(PYTHON) -m black
 
-# install GIT pre-commit hook
-install-git-hooks:
-	ln -sf ../../.git-pre-commit .git/hooks/pre-commit
-	chmod +x .git/hooks/pre-commit
+fix-ruff:  ## Fix ruff errors.
+	@$(call _ls,'*.py') | xargs $(PYTHON) -m ruff check --fix --output-format=concise $(ARGS)
+
+fix-c:  ## Reformat C code with clang-format.
+	@$(call _ls,'*.c' '*.h') | xargs -P0 -I{} clang-format -i {}  # parallel exec
+
+fix-toml:  ## Fix pyproject.toml
+	@$(call _ls,'*.toml') | xargs toml-sort
+
+fix-rst:  ## Re-wrap .rst files.
+	@$(call _ls,'*.rst') | xargs rstwrap
+
+fix-dprint:  ## Reformat .md / .json / .yml / .js / .css files.
+	@$(DPRINT) fmt
+
+fix-all:  ## Run all code fixers.
+	$(MAKE) fix-ruff
+	$(MAKE) fix-black
+	$(MAKE) fix-c
+	$(MAKE) fix-rst
+	$(MAKE) fix-toml
+	$(MAKE) fix-dprint
+
+# ===================================================================
+# CI jobs
+# ===================================================================
+
+ci-lint:  ## Run all linters on GitHub CI.
+	$(MAKE) install-pydeps-lint
+	test -x $(DPRINT) || curl -fsSL https://dprint.dev/install.sh | sh
+	$(DPRINT) --version
+	clang-format --version
+	$(MAKE) lint-all
+
+ci-test:  ## Run tests on GitHub CI.
+	$(MAKE) install-sysdeps
+	# Editable install: it builds in-place, and having psutil already
+	# installed stops pip from pulling it from PyPI for psleak.
+	$(INSTALL_PYDEPS) --editable .
+	$(MAKE) install-pydeps-test
+	$(MAKE) print-sysinfo
+	# Warm pywin32's gen_py cache: concurrent first imports of wmi in
+	# the pytest workers corrupt it (EOFError from gencache).
+	if [ "$$OS" = "Windows_NT" ]; then $(PYTHON) -c "import wmi"; fi
+	$(MAKE) test-parallel
+
+ci-check-dist:  ## Run all sanity checks re. to the package distribution.
+	$(INSTALL_PYDEPS) setuptools virtualenv twine check-manifest validate-pyproject[all] abi3audit
+	$(MAKE) create-sdist
+	mv wheelhouse/* dist/
+	$(MAKE) check-dist
+	$(PYTHON) scripts/internal/print_dist.py --check
 
 # ===================================================================
 # Distribution
 # ===================================================================
 
-# Upload source tarball on https://pypi.python.org/pypi/psutil.
-upload-src: clean
-	$(PYTHON) setup.py sdist upload
+# --- create
+
+generate-manifest:  ## Generates MANIFEST.in file.
+	$(PYTHON) scripts/internal/generate_manifest.py > MANIFEST.in
+
+create-sdist:  ## Create tar.gz source distribution.
+	$(MAKE) generate-manifest
+	$(PYTHON_ENV_VARS) $(PYTHON) setup.py sdist
+
+create-wheels:  ## Create .whl files
+	$(PYTHON_ENV_VARS) $(PYTHON) setup.py bdist_wheel
+
+download-wheels:  ## Download latest wheels hosted on github.
+	$(PYTHON) scripts/internal/download_wheels.py --tokenfile=~/.github.api.key
+	$(MAKE) print-dist
+
+create-dist:  ## Create .tar.gz + .whl distribution.
+	$(MAKE) create-sdist
+	$(MAKE) download-wheels
+
+# --- check
+
+check-manifest:  ## Check sanity of MANIFEST.in file.
+	$(PYTHON) -m check_manifest -v
+
+check-pyproject:  ## Check sanity of pyproject.toml file.
+	$(PYTHON) -m validate_pyproject -v pyproject.toml
+
+check-sdist:  ## Check sanity of source distribution.
+	$(PYTHON_ENV_VARS) $(PYTHON) -m virtualenv --clear --no-wheel --quiet build/venv
+	$(PYTHON_ENV_VARS) build/venv/bin/python -m pip install -v --isolated --quiet dist/*.tar.gz
+	$(PYTHON_ENV_VARS) build/venv/bin/python -c "import os; os.chdir('build/venv'); import psutil"
+	$(PYTHON) -m twine check --strict dist/*.tar.gz
+
+check-wheels:  ## Check sanity of wheels.
+	$(PYTHON) -m abi3audit --verbose --strict dist/*-abi3-*.whl
+	$(PYTHON) -m twine check --strict dist/*.whl
+
+check-dist:  ## Run all sanity checks re. to the package distribution.
+	$(MAKE) -j \
+		check-manifest \
+		check-pyproject \
+		check-sdist \
+		check-wheels
+
+# --- release
+
+pre-release:  ## Check if we're ready to produce a new release.
+	$(MAKE) clean
+	$(MAKE) create-dist
+	$(MAKE) check-dist
+	$(MAKE) install
+	@$(PYTHON) -c \
+		"import requests, sys; \
+		from packaging.version import parse; \
+		from psutil import __version__; \
+		res = requests.get('https://pypi.org/pypi/psutil/json', timeout=5); \
+		versions = sorted(res.json()['releases'], key=parse, reverse=True); \
+		sys.exit('version %r already exists on PYPI' % __version__) if __version__ in versions else 0"
+	@ver=$$($(PYTHON) -c "from psutil import __version__; print(__version__)"); \
+		grep -q "$$ver" docs/changelog.rst || { echo "ERR: version $$ver not found in docs/changelog.rst"; exit 1; }; \
+		grep -q "$$ver" docs/timeline.rst || { echo "ERR: version $$ver not found in docs/timeline.rst"; exit 1; }
+	$(MAKE) print-hashes
+	$(MAKE) print-dist
+
+release:  ## Upload a new release.
+	$(PYTHON) -m twine upload dist/*.tar.gz
+	$(PYTHON) -m twine upload dist/*.whl
+	$(MAKE) git-tag-release
+
+git-tag-release:  ## Git-tag a new release.
+	git tag -a v`$(PYTHON) -c "import setup; print(setup.get_version())"` -m `git rev-list HEAD --count`:`git rev-parse --short HEAD`
+	git push --follow-tags
+
+# ===================================================================
+# Printers
+# ===================================================================
+
+print-announce:  ## Print announce of new release.
+	@$(PYTHON) scripts/internal/print_announce.py
+
+print-access-denied: ## Print AD exceptions
+	$(PYTHON) scripts/internal/print_access_denied.py
+
+print-api-speed:  ## Benchmark all API calls
+	$(PYTHON) scripts/internal/print_api_speed.py $(ARGS)
+
+print-downloads:  ## Print PYPI download statistics
+	$(PYTHON) scripts/internal/print_downloads.py
+
+print-hashes:  ## Prints hashes of files in dist/ directory
+	$(PYTHON) scripts/internal/print_hashes.py
+
+print-sysinfo:  ## Prints system info
+	$(PYTHON) scripts/internal/print_sysinfo.py
+
+print-dist:  ## Print downloaded wheels / tar.gz
+	$(PYTHON) scripts/internal/print_dist.py
+
+# ===================================================================
+# Misc
+# ===================================================================
+
+grep-todos:  ## Look for TODOs in the source files.
+	git grep -EIn "TODO|FIXME|XXX"
+
+bench-oneshot:  ## Benchmarks for oneshot() ctx manager (see #799).
+	$(PYTHON) scripts/internal/bench_oneshot.py
+
+bench-oneshot-2:  ## Same as above but using perf module (more precise).
+	$(PYTHON) scripts/internal/bench_oneshot_2.py
+
+find-broken-links:  ## Look for broken links in source files (except docs/).
+	git ls-files | grep -v '^docs/' | xargs $(PYTHON) -Wa scripts/internal/find_broken_links.py
 
-# Build and upload doc on https://pythonhosted.org/psutil/.
-# Requires "pip install sphinx-pypi-upload".
-upload-doc:
-	cd docs; make html
-	$(PYTHON) setup.py upload_sphinx --upload-dir=docs/_build/html
+_CI_JOBS = $(patsubst .github/workflows/%.yml,%,$(shell grep -l workflow_dispatch .github/workflows/*.yml))
 
-# download exes/wheels hosted on appveyor
-win-download-exes:
-	$(PYTHON) .ci/appveyor/download_exes.py --user giampaolo --project psutil
+ci-run:  ## Manually run a CI workflow, e.g. `make ci-run JOB=bsd`
+	@echo "$(_CI_JOBS)" | tr ' ' '\n' | grep -qx "$(JOB)" || { echo "Usage: make ci-run JOB=<$$(echo $(_CI_JOBS) | tr ' ' '|')>"; exit 1; }
+	gh workflow run $(JOB).yml --ref $$(git rev-parse --abbrev-ref HEAD)
 
-# upload exes/wheels in dist/* directory to PYPI
-win-upload-exes:
-	$(PYTHON) -m twine upload dist/*
+help: ## Display callable targets.
+	@awk -F':.*?## ' '/^[a-zA-Z0-9_.-]+:.*?## / {printf "\033[36m%-24s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST) | sort
diff --git a/README.rst b/README.rst
index eed2483272..ed6f6777cd 100644
--- a/README.rst
+++ b/README.rst
@@ -1,407 +1,192 @@
-.. image:: https://img.shields.io/travis/giampaolo/psutil/master.svg?maxAge=3600&label=Linux%20/%20OSX
-    :target: https://travis-ci.org/giampaolo/psutil
-    :alt: Linux tests (Travis)
-
-.. image:: https://img.shields.io/appveyor/ci/giampaolo/psutil/master.svg?maxAge=3600&label=Windows
-    :target: https://ci.appveyor.com/project/giampaolo/psutil
-    :alt: Windows tests (Appveyor)
-
-.. image:: https://coveralls.io/repos/github/giampaolo/psutil/badge.svg?branch=master
-    :target: https://coveralls.io/github/giampaolo/psutil?branch=master
-    :alt: Test coverage (coverall.io)
-
-.. image:: https://img.shields.io/pypi/v/psutil.svg?label=version
-    :target: https://pypi.python.org/pypi/psutil/
-    :alt: Latest version
-
-.. image:: https://img.shields.io/github/stars/giampaolo/psutil.svg
-    :target: https://github.com/giampaolo/psutil/
-    :alt: Github stars
-
-.. image:: https://img.shields.io/pypi/l/psutil.svg
-    :target: https://pypi.python.org/pypi/psutil/
-    :alt: License
-
-===========
-Quick links
-===========
-
-- `Home page <https://github.com/giampaolo/psutil>`_
-- `Install <https://github.com/giampaolo/psutil/blob/master/INSTALL.rst>`_
-- `Documentation <http://pythonhosted.org/psutil/>`_
-- `Download <https://pypi.python.org/pypi?:action=display&name=psutil#downloads>`_
-- `Forum <http://groups.google.com/group/psutil/topics>`_
-- `Blog <http://grodola.blogspot.com/search/label/psutil>`_
-- `Development guide <https://github.com/giampaolo/psutil/blob/master/DEVGUIDE.rst>`_
-- `What's new <https://github.com/giampaolo/psutil/blob/master/HISTORY.rst>`_
+.. <PYPI-EXCLUDE>
 
-=======
-Summary
+.. raw:: html
+
+    <div align="center">
+        <a href="https://github.com/giampaolo/psutil"><img src="https://github.com/giampaolo/psutil/raw/master/docs/_static/images/logo-psutil-readme.svg" alt="psutil" /></a>
+        <p align="center">Process and System Utilities for Python</p>
+        <a href="https://psutil.io/"><b>Documentation</b></a>&nbsp;&nbsp;&nbsp;
+        <a href="https://psutil.io/blog/"><b>Blog</b></a>&nbsp;&nbsp;&nbsp;
+        <a href="https://psutil.io/adoption/"><b>Who uses psutil</b></a>&nbsp;&nbsp;&nbsp;
+    </div>
+
+    <br/>
+
+    <div align="center">
+      <a href="https://clickpy.clickhouse.com/dashboard/psutil"><img src="https://static.pepy.tech/badge/psutil/month" alt="Downloads"></a>
+
+      <a href="https://repology.org/metapackage/python:psutil/versions"><img src="https://repology.org/badge/tiny-repos/python:psutil.svg" alt="Binary packages"></a>
+
+      <a href="https://pypi.org/project/psutil"><img src="https://img.shields.io/pypi/v/psutil.svg?label=pypi&color=yellowgreen" alt="Latest version"></a>
+    </div>
+
+    <div align="center">
+      <a href="https://github.com/giampaolo/psutil/actions?query=workflow%3Atests"><img src="https://img.shields.io/github/actions/workflow/status/giampaolo/psutil/.github/workflows/tests.yml.svg?label=Linux%2C%20macOS%2C%20Win" alt="Linux, macOS, Windows"></a>
+
+      <a href="https://github.com/giampaolo/psutil/actions?query=workflow%3Absd"><img src="https://img.shields.io/github/actions/workflow/status/giampaolo/psutil/.github/workflows/bsd.yml.svg?label=BSD" alt="FreeBSD, NetBSD, OpenBSD"></a>
+
+      <a href="https://github.com/giampaolo/psutil/actions?query=workflow%3Adocs"><img src="https://img.shields.io/github/actions/workflow/status/giampaolo/psutil/.github/workflows/docs.yml.svg?label=docs" alt="Documentation"></a>
+    </div>
+
+.. </PYPI-EXCLUDE>
+
+About
+=====
+
+psutil is a cross-platform library for retrieving information about running
+**processes** and **system utilization** (CPU, memory, disks, network, sensors)
+in Python. It is useful mainly for **system monitoring**, **profiling**,
+**limiting process resources**, and **managing running processes**. It
+implements many functionalities offered by UNIX command line tool such as
+*ps, top, free, iotop, netstat, ifconfig, lsof* and others (see
+`shell equivalents`_). Psutil supports the following platforms:
+
+- **Linux**
+- **Windows**
+- **macOS**
+- **FreeBSD, OpenBSD**, **NetBSD**
+- **Sun Solaris**
+- **AIX**
+
+Adoption
+========
+
+psutil is among the
+`top 100 <https://clickpy.clickhouse.com/dashboard/psutil>`__ most-downloaded
+packages on PyPI, with **390+ million** downloads per month and **780,000+**
+`GitHub repositories <https://github.com/giampaolo/psutil/network/dependents>`__
+using it. See also `adoptions <https://psutil.io/adoption/>`__ and
+`alternatives <https://psutil.io/alternatives/>`__.
+
+Install
 =======
 
-psutil (process and system utilities) is a cross-platform library for
-retrieving information on **running processes** and **system utilization**
-(CPU, memory, disks, network) in Python. It is useful mainly for **system
-monitoring**, **profiling and limiting process resources** and **management of
-running processes**. It implements many functionalities offered by command line
-tools such as: ps, top, lsof, netstat, ifconfig, who, df, kill, free, nice,
-ionice, iostat, iotop, uptime, pidof, tty, taskset, pmap. It currently supports
-**Linux, Windows, OSX, Sun Solaris, FreeBSD, OpenBSD** and **NetBSD**,
-both **32-bit** and **64-bit** architectures, with Python versions from **2.6
-to 3.5** (users of Python 2.4 and 2.5 may use
-`2.1.3 <https://pypi.python.org/pypi?name=psutil&version=2.1.3&:action=files>`__ version).
-`PyPy <http://pypy.org/>`__ is also known to work.
-
-====================
-Example applications
-====================
-
-- https://github.com/nicolargo/glances
-- https://github.com/google/grr
-- https://github.com/Jahaja/psdash
-- https://github.com/giampaolo/psutil/tree/master/scripts
+.. code-block::
+
+    pip install psutil
+
+For platform-specific details see `installation <https://psutil.io/install/>`_.
+
+Documentation
+=============
+
+psutil documentation is available at https://psutil.io.
+
+.. <PYPI-EXCLUDE>
+
+Sponsors
+========
+
+.. raw:: html
+
+    <table border="0" cellpadding="10" cellspacing="0" class="sponsor-table">
+      <tr>
+        <td align="center" style="vertical-align: middle;">
+          <a href="https://tidelift.com/subscription/pkg/pypi-psutil?utm_source=pypi-psutil&utm_medium=referral&utm_campaign=readme"><img width="160" src="https://raw.githubusercontent.com/giampaolo/psutil/refs/heads/master/docs/_static/images/logo-tidelift.svg" class="sponsor-logo"></a>
+        </td>
+        <td align="center" style="vertical-align: middle;">
+          <a href="https://sansec.io/"><img width="145" src="https://raw.githubusercontent.com/giampaolo/psutil/refs/heads/master/docs/_static/images/logo-sansec.svg" class="sponsor-logo"></a>
+        </td>
+        <td align="center" style="vertical-align: middle;">
+          <a href="https://www.apivoid.com/"><img width="130" src="https://raw.githubusercontent.com/giampaolo/psutil/refs/heads/master/docs/_static/images/logo-apivoid.svg" class="sponsor-logo"></a>
+        </td>
+      </tr>
+    </table>
+
+    <div style="text-align: center;"><sup><a href="https://psutil.io/funding/">add your logo</a></sup></div>
+
+.. </PYPI-EXCLUDE>
 
-==============
 Example usages
 ==============
 
-CPU
-===
+For the full API with more examples, see the
+`API overview <https://psutil.io/api-overview/>`_ and
+`API reference <https://psutil.io/api/>`_.
+
+**CPU**
 
 .. code-block:: python
 
     >>> import psutil
-    >>> psutil.cpu_times()
-    scputimes(user=3961.46, nice=169.729, system=2150.659, idle=16900.540, iowait=629.59, irq=0.0, softirq=19.42, steal=0.0, guest=0, nice=0.0)
-    >>>
-    >>> for x in range(3):
-    ...     psutil.cpu_percent(interval=1)
-    ...
-    4.0
-    5.9
-    3.8
-    >>>
-    >>> for x in range(3):
-    ...     psutil.cpu_percent(interval=1, percpu=True)
-    ...
+    >>> psutil.cpu_percent(interval=1, percpu=True)
     [4.0, 6.9, 3.7, 9.2]
-    [7.0, 8.5, 2.4, 2.1]
-    [1.2, 9.0, 9.9, 7.2]
-    >>>
-    >>> for x in range(3):
-    ...     psutil.cpu_times_percent(interval=1, percpu=False)
-    ...
-    scputimes(user=1.5, nice=0.0, system=0.5, idle=96.5, iowait=1.5, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
-    scputimes(user=1.0, nice=0.0, system=0.0, idle=99.0, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
-    scputimes(user=2.0, nice=0.0, system=0.0, idle=98.0, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
-    >>>
-    >>> psutil.cpu_count()
-    4
     >>> psutil.cpu_count(logical=False)
     2
-    >>>
-    >>> psutil.cpu_stats()
-    scpustats(ctx_switches=20455687, interrupts=6598984, soft_interrupts=2134212, syscalls=0)
+    >>> psutil.cpu_freq()
+    scpufreq(current=931.42, min=800.0, max=3500.0)
 
-Memory
-======
+**Memory**
 
 .. code-block:: python
 
     >>> psutil.virtual_memory()
-    svmem(total=10367352832, available=6472179712, percent=37.6, used=8186245120, free=2181107712, active=4748992512, inactive=2758115328, buffers=790724608, cached=3500347392, shared=787554304)
+    svmem(total=10367352832, available=6472179712, percent=37.6, used=8186245120, free=2181107712, ...)
     >>> psutil.swap_memory()
     sswap(total=2097147904, used=296128512, free=1801019392, percent=14.1, sin=304193536, sout=677842944)
-    >>>
 
-Disks
-=====
+**Disks**
 
 .. code-block:: python
 
     >>> psutil.disk_partitions()
     [sdiskpart(device='/dev/sda1', mountpoint='/', fstype='ext4', opts='rw,nosuid'),
-     sdiskpart(device='/dev/sda2', mountpoint='/home', fstype='ext, opts='rw')]
-    >>>
+     sdiskpart(device='/dev/sda2', mountpoint='/home', fstype='ext', opts='rw')]
     >>> psutil.disk_usage('/')
     sdiskusage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)
-    >>>
-    >>> psutil.disk_io_counters(perdisk=False)
-    sdiskio(read_count=719566, write_count=1082197, read_bytes=18626220032, write_bytes=24081764352, read_time=5023392, write_time=63199568, read_merged_count=619166, write_merged_count=812396, busy_time=4523412)
-    >>>
 
-Network
-=======
+**Network**
 
 .. code-block:: python
 
     >>> psutil.net_io_counters(pernic=True)
-    {'eth0': netio(bytes_sent=485291293, bytes_recv=6004858642, packets_sent=3251564, packets_recv=4787798, errin=0, errout=0, dropin=0, dropout=0),
-     'lo': netio(bytes_sent=2838627, bytes_recv=2838627, packets_sent=30567, packets_recv=30567, errin=0, errout=0, dropin=0, dropout=0)}
-    >>>
-    >>> psutil.net_connections()
-    [pconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 48776), raddr=('93.186.135.91', 80), status='ESTABLISHED', pid=1254),
-     pconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 43761), raddr=('72.14.234.100', 80), status='CLOSING', pid=2987),
-     pconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 60759), raddr=('72.14.234.104', 80), status='ESTABLISHED', pid=None),
-     pconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 51314), raddr=('72.14.234.83', 443), status='SYN_SENT', pid=None)
+    {'eth0': netio(bytes_sent=485291293, bytes_recv=6004858642, ...),
+     'lo': netio(bytes_sent=2838627, bytes_recv=2838627, ...)}
+    >>> psutil.net_connections(kind='tcp')
+    [sconn(fd=115, family=2, type=1, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status='ESTABLISHED', pid=1254),
      ...]
-    >>>
-    >>> psutil.net_if_addrs()
-    {'lo': [snic(family=<AddressFamily.AF_INET: 2>, address='127.0.0.1', netmask='255.0.0.0', broadcast='127.0.0.1', ptp=None),
-            snic(family=<AddressFamily.AF_INET6: 10>, address='::1', netmask='ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', broadcast=None, ptp=None),
-            snic(family=<AddressFamily.AF_LINK: 17>, address='00:00:00:00:00:00', netmask=None, broadcast='00:00:00:00:00:00', ptp=None)],
-     'wlan0': [snic(family=<AddressFamily.AF_INET: 2>, address='192.168.1.3', netmask='255.255.255.0', broadcast='192.168.1.255', ptp=None),
-               snic(family=<AddressFamily.AF_INET6: 10>, address='fe80::c685:8ff:fe45:641%wlan0', netmask='ffff:ffff:ffff:ffff::', broadcast=None, ptp=None),
-               snic(family=<AddressFamily.AF_LINK: 17>, address='c4:85:08:45:06:41', netmask=None, broadcast='ff:ff:ff:ff:ff:ff', ptp=None)]}
-    >>>
-    >>> psutil.net_if_stats()
-    {'eth0': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=100, mtu=1500),
-     'lo': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN: 0>, speed=0, mtu=65536)}
 
-Other system info
-=================
+**Sensors**
 
 .. code-block:: python
 
-    >>> psutil.users()
-    [user(name='giampaolo', terminal='pts/2', host='localhost', started=1340737536.0),
-     user(name='giampaolo', terminal='pts/3', host='localhost', started=1340737792.0)]
-    >>>
-    >>> psutil.boot_time()
-    1365519115.0
-    >>>
+    >>> psutil.sensors_temperatures()
+    {'coretemp': [shwtemp(label='Physical id 0', current=52.0, high=100.0, critical=100.0),
+                  shwtemp(label='Core 0', current=45.0, high=100.0, critical=100.0)]}
+    >>> psutil.sensors_battery()
+    sbattery(percent=93, secsleft=16628, power_plugged=False)
 
-Process management
-==================
+**Processes**
 
 .. code-block:: python
 
-    >>> import psutil
-    >>> psutil.pids()
-    [1, 2, 3, 4, 5, 6, 7, 46, 48, 50, 51, 178, 182, 222, 223, 224,
-     268, 1215, 1216, 1220, 1221, 1243, 1244, 1301, 1601, 2237, 2355,
-     2637, 2774, 3932, 4176, 4177, 4185, 4187, 4189, 4225, 4243, 4245,
-     4263, 4282, 4306, 4311, 4312, 4313, 4314, 4337, 4339, 4357, 4358,
-     4363, 4383, 4395, 4408, 4433, 4443, 4445, 4446, 5167, 5234, 5235,
-     5252, 5318, 5424, 5644, 6987, 7054, 7055, 7071]
-    >>>
     >>> p = psutil.Process(7055)
     >>> p.name()
-    'python'
+    'python3'
     >>> p.exe()
-    '/usr/bin/python'
-    >>> p.cwd()
-    '/home/giampaolo'
-    >>> p.cmdline()
-    ['/usr/bin/python', 'main.py']
-    >>>
-    >>> p.status()
-    'running'
-    >>> p.username()
-    'giampaolo'
-    >>> p.create_time()
-    1267551141.5019531
-    >>> p.terminal()
-    '/dev/pts/0'
-    >>>
-    >>> p.uids()
-    puids(real=1000, effective=1000, saved=1000)
-    >>> p.gids()
-    pgids(real=1000, effective=1000, saved=1000)
-    >>>
-    >>> p.cpu_times()
-    pcputimes(user=1.02, system=0.31, children_user=0.32, children_system=0.1)
+    '/usr/bin/python3'
     >>> p.cpu_percent(interval=1.0)
     12.1
-    >>> p.cpu_affinity()
-    [0, 1, 2, 3]
-    >>> p.cpu_affinity([0])  # set
-    >>>
-    >>> p.memory_percent()
-    0.63423
-    >>>
     >>> p.memory_info()
-    pmem(rss=10915840, vms=67608576, shared=3313664, text=2310144, lib=0, data=7262208, dirty=0)
-    >>>
-    >>> p.memory_full_info()  # "real" USS memory usage (Linux, OSX, Win only)
-    pfullmem(rss=10199040, vms=52133888, shared=3887104, text=2867200, lib=0, data=5967872, dirty=0, uss=6545408, pss=6872064, swap=0)
-    >>>
-    >>> p.memory_maps()
-    [pmmap_grouped(path='/lib/x8664-linux-gnu/libutil-2.15.so', rss=32768, size=2125824, pss=32768, shared_clean=0, shared_dirty=0, private_clean=20480, private_dirty=12288, referenced=32768, anonymous=12288, swap=0),
-     pmmap_grouped(path='/lib/x8664-linux-gnu/libc-2.15.so', rss=3821568, size=3842048, pss=3821568, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=3821568, referenced=3575808, anonymous=3821568, swap=0),
-     pmmap_grouped(path='/lib/x8664-linux-gnu/libcrypto.so.0.1', rss=34124, rss=32768, size=2134016, pss=15360, shared_clean=24576, shared_dirty=0, private_clean=0, private_dirty=8192, referenced=24576, anonymous=8192, swap=0),
-     pmmap_grouped(path='[heap]',  rss=32768, size=139264, pss=32768, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=32768, referenced=32768, anonymous=32768, swap=0),
-     pmmap_grouped(path='[stack]', rss=2465792, size=2494464, pss=2465792, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=2465792, referenced=2277376, anonymous=2465792, swap=0),
-     ...]
-    >>>
-    >>> p.io_counters()
-    pio(read_count=478001, write_count=59371, read_bytes=700416, write_bytes=69632)
-    >>>
+    pmem(rss=3164160, vms=4410163, shared=897433, text=302694, data=2422374)
+    >>> p.net_connections(kind='tcp')
+    [pconn(fd=115, family=2, type=1, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status='ESTABLISHED')]
     >>> p.open_files()
-    [popenfile(path='/home/giampaolo/svn/psutil/setup.py', fd=3, position=0, mode='r', flags=32768),
-     popenfile(path='/var/log/monitd', fd=4, position=235542, mode='a', flags=33793)]
-    >>>
-    >>> p.connections()
-    [pconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 48776), raddr=('93.186.135.91', 80), status='ESTABLISHED'),
-     pconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 43761), raddr=('72.14.234.100', 80), status='CLOSING'),
-     pconn(fd=119, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 60759), raddr=('72.14.234.104', 80), status='ESTABLISHED'),
-     pconn(fd=123, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 51314), raddr=('72.14.234.83', 443), status='SYN_SENT')]
-    >>>
-    >>> p.num_threads()
-    4
-    >>> p.num_fds()
-    8
-    >>> p.threads()
-    [pthread(id=5234, user_time=22.5, system_time=9.2891),
-     pthread(id=5235, user_time=0.0, system_time=0.0),
-     pthread(id=5236, user_time=0.0, system_time=0.0),
-     pthread(id=5237, user_time=0.0707, system_time=1.1)]
-    >>>
-    >>> p.num_ctx_switches()
-    pctxsw(voluntary=78, involuntary=19)
-    >>>
-    >>> p.nice()
-    0
-    >>> p.nice(10)  # set
-    >>>
-    >>> p.ionice(psutil.IOPRIO_CLASS_IDLE)  # IO priority (Win and Linux only)
-    >>> p.ionice()
-    pionice(ioclass=<IOPriority.IOPRIO_CLASS_IDLE: 3>, value=0)
-    >>>
-    >>> p.rlimit(psutil.RLIMIT_NOFILE, (5, 5))  # set resource limits (Linux only)
-    >>> p.rlimit(psutil.RLIMIT_NOFILE)
-    (5, 5)
-    >>>
-    >>> p.environ()
-    {'LC_PAPER': 'it_IT.UTF-8', 'SHELL': '/bin/bash', 'GREP_OPTIONS': '--color=auto',
-    'XDG_CONFIG_DIRS': '/etc/xdg/xdg-ubuntu:/usr/share/upstart/xdg:/etc/xdg', 'COLORTERM': 'gnome-terminal',
-     ...}
-    >>>
-    >>> p.suspend()
-    >>> p.resume()
+    [popenfile(path='/home/giampaolo/monit.py', fd=3, position=0, mode='r', flags=32768)]
     >>>
-    >>> p.terminate()
-    >>> p.wait(timeout=3)
-    0
-    >>>
-    >>> psutil.test()
-    USER         PID %CPU %MEM     VSZ     RSS TTY        START    TIME  COMMAND
-    root           1  0.0  0.0   24584    2240            Jun17   00:00  init
-    root           2  0.0  0.0       0       0            Jun17   00:00  kthreadd
-    root           3  0.0  0.0       0       0            Jun17   00:05  ksoftirqd/0
+    >>> for p in psutil.process_iter(['pid', 'name']):
+    ...     print(p.pid, p.name())
     ...
-    giampaolo  31475  0.0  0.0   20760    3024 /dev/pts/0 Jun19   00:00  python2.4
-    giampaolo  31721  0.0  2.2  773060  181896            00:04   10:30  chrome
-    root       31763  0.0  0.0       0       0            00:05   00:00  kworker/0:1
-    >>>
-
-Further process APIs
-====================
-
-.. code-block:: python
-
-    >>> for p in psutil.process_iter():
-    ...     print(p)
+    1 systemd
+    2 kthreadd
+    3 ksoftirqd/0
     ...
-    psutil.Process(pid=1, name='init')
-    psutil.Process(pid=2, name='kthreadd')
-    psutil.Process(pid=3, name='ksoftirqd/0')
-    ...
-    >>>
-    >>> def on_terminate(proc):
-    ...     print("process {} terminated".format(proc))
-    ...
-    >>> # waits for multiple processes to terminate
-    >>> gone, alive = psutil.wait_procs(procs_list, timeout=3, callback=on_terminate)
-    >>>
-
-Windows services
-================
 
-.. code-block:: python
-
-    >>> list(psutil.win_service_iter())
-    [<WindowsService(name='AeLookupSvc', display_name='Application Experience') at 38850096>,
-     <WindowsService(name='ALG', display_name='Application Layer Gateway Service') at 38850128>,
-     <WindowsService(name='APNMCP', display_name='Ask Update Service') at 38850160>,
-     <WindowsService(name='AppIDSvc', display_name='Application Identity') at 38850192>,
-     ...]
-    >>> s = psutil.win_service_get('alg')
-    >>> s.as_dict()
-    {'binpath': 'C:\\Windows\\System32\\alg.exe',
-     'description': 'Provides support for 3rd party protocol plug-ins for Internet Connection Sharing',
-     'display_name': 'Application Layer Gateway Service',
-     'name': 'alg',
-     'pid': None,
-     'start_type': 'manual',
-     'status': 'stopped',
-     'username': 'NT AUTHORITY\\LocalService'}
-
-======
-Donate
-======
-
-A lot of time and effort went into making psutil as it is right now.
-If you feel psutil is useful to you or your business and want to support its future development please consider donating me (`Giampaolo Rodola' <http://grodola.blogspot.com/p/about.html>`_) some money.
-I only ask for a small donation, but of course I appreciate any amount.
-
-.. image:: http://www.paypal.com/en_US/i/btn/x-click-but04.gif
-    :target: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=A9ZS7PKKRM3S8
-    :alt: Donate via PayPal
+.. _`shell equivalents`: https://psutil.io/shell-equivalents/
 
-Don't want to donate money? Then maybe you could `write me a recommendation on Linkedin <http://www.linkedin.com/in/grodola>`_.
+.. <PYPI-EXCLUDE>
 
-============
-Mailing list
-============
-
-http://groups.google.com/group/psutil/
-
-========
-Timeline
-========
+License
+=======
 
-- 2016-06-18: `psutil-4.3.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-4.3.0.tar.gz>`_
-- 2016-05-15: `psutil-4.2.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-4.2.0.tar.gz>`_
-- 2016-03-12: `psutil-4.1.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-4.1.0.tar.gz>`_
-- 2016-02-17: `psutil-4.0.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-4.0.0.tar.gz>`_
-- 2016-01-20: `psutil-3.4.2.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-3.4.2.tar.gz>`_
-- 2016-01-15: `psutil-3.4.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-3.4.1.tar.gz>`_
-- 2015-11-25: `psutil-3.3.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-3.3.0.tar.gz>`_
-- 2015-10-04: `psutil-3.2.2.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-3.2.2.tar.gz>`_
-- 2015-09-03: `psutil-3.2.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-3.2.1.tar.gz>`_
-- 2015-09-02: `psutil-3.2.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-3.2.0.tar.gz>`_
-- 2015-07-15: `psutil-3.1.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-3.1.1.tar.gz>`_
-- 2015-07-15: `psutil-3.1.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-3.1.0.tar.gz>`_
-- 2015-06-18: `psutil-3.0.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-3.0.1.tar.gz>`_
-- 2015-06-13: `psutil-3.0.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-3.0.0.tar.gz>`_
-- 2015-02-02: `psutil-2.2.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-2.2.1.tar.gz>`_
-- 2015-01-06: `psutil-2.2.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-2.2.0.tar.gz>`_
-- 2014-09-26: `psutil-2.1.3.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-2.1.3.tar.gz>`_
-- 2014-09-21: `psutil-2.1.2.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-2.1.2.tar.gz>`_
-- 2014-04-30: `psutil-2.1.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-2.1.1.tar.gz>`_
-- 2014-04-08: `psutil-2.1.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-2.1.0.tar.gz>`_
-- 2014-03-10: `psutil-2.0.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-2.0.0.tar.gz>`_
-- 2013-11-25: `psutil-1.2.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-1.2.1.tar.gz>`_
-- 2013-11-20: `psutil-1.2.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-1.2.0.tar.gz>`_
-- 2013-11-07: `psutil-1.1.3.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-1.1.3.tar.gz>`_
-- 2013-10-22: `psutil-1.1.2.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-1.1.2.tar.gz>`_
-- 2013-10-08: `psutil-1.1.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-1.1.1.tar.gz>`_
-- 2013-09-28: `psutil-1.1.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-1.1.0.tar.gz>`_
-- 2013-07-12: `psutil-1.0.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-1.0.1.tar.gz>`_
-- 2013-07-10: `psutil-1.0.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-1.0.0.tar.gz>`_
-- 2013-05-03: `psutil-0.7.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.7.1.tar.gz>`_
-- 2013-04-12: `psutil-0.7.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.7.0.tar.gz>`_
-- 2012-08-16: `psutil-0.6.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.6.1.tar.gz>`_
-- 2012-08-13: `psutil-0.6.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.6.0.tar.gz>`_
-- 2012-06-29: `psutil-0.5.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.5.1.tar.gz>`_
-- 2012-06-27: `psutil-0.5.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.5.0.tar.gz>`_
-- 2011-12-14: `psutil-0.4.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.4.1.tar.gz>`_
-- 2011-10-29: `psutil-0.4.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.4.0.tar.gz>`_
-- 2011-07-08: `psutil-0.3.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.3.0.tar.gz>`_
-- 2011-03-20: `psutil-0.2.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.2.1.tar.gz>`_
-- 2010-11-13: `psutil-0.2.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.2.0.tar.gz>`_
-- 2010-03-02: `psutil-0.1.3.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.1.3.tar.gz>`_
-- 2009-05-06: `psutil-0.1.2.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.1.2.tar.gz>`_
-- 2009-03-06: `psutil-0.1.1.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.1.1.tar.gz>`_
-- 2009-01-27: `psutil-0.1.0.tar.gz <https://pypi.python.org/packages/source/p/psutil/psutil-0.1.0.tar.gz>`_
+BSD-3
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000000..fda8e36955
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,10 @@
+# Security Policy
+
+If you have discovered a security vulnerability in this project, please report
+it privately. **Do not disclose it as a public issue**. This gives me time to
+fix the issue before public exposure, reducing the chance that an exploit will
+be used before a patch is released.
+
+To report a security vulnerability use the
+[Tidelift security contact](https://tidelift.com/security). Tidelift will
+coordinate the fix and the disclosure of the reported problem.
diff --git a/_bootstrap.py b/_bootstrap.py
new file mode 100644
index 0000000000..7a1da56fd4
--- /dev/null
+++ b/_bootstrap.py
@@ -0,0 +1,41 @@
+# Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Bootstrap utilities for loading psutil modules without psutil
+being installed.
+"""
+
+import ast
+import importlib.util
+import os
+import pathlib
+
+ROOT_DIR = pathlib.Path(__file__).resolve().parent
+
+
+def load_module(path):
+    """Load a Python module by file path without importing it
+    as part of a package.
+    """
+    name = os.path.splitext(os.path.basename(path))[0]
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def get_version():
+    """Extract __version__ from psutil/__init__.py using AST
+    (no imports needed).
+    """
+    path = ROOT_DIR / "psutil" / "__init__.py"
+    with open(path, encoding="utf-8") as f:
+        mod = ast.parse(f.read())
+    for node in mod.body:
+        if isinstance(node, ast.Assign):
+            for target in node.targets:
+                if getattr(target, "id", None) == "__version__":
+                    return ast.literal_eval(node.value)
+    msg = "could not find __version__"
+    raise RuntimeError(msg)
diff --git a/appveyor.yml b/appveyor.yml
deleted file mode 100644
index 5299720454..0000000000
--- a/appveyor.yml
+++ /dev/null
@@ -1,93 +0,0 @@
-os: Visual Studio 2015
-
-environment:
-
-  global:
-    # SDK v7.0 MSVC Express 2008's SetEnv.cmd script will fail if the
-    # /E:ON and /V:ON options are not enabled in the batch script intepreter
-    # See: http://stackoverflow.com/a/13751649/163740
-    WITH_COMPILER: "cmd /E:ON /V:ON /C .\\.ci\\appveyor\\run_with_compiler.cmd"
-
-  matrix:
-    # Pre-installed Python versions, which Appveyor may upgrade to
-    # a later point release.
-
-    # 32 bits
-
-    - PYTHON: "C:\\Python27"
-      PYTHON_VERSION: "2.7.x"
-      PYTHON_ARCH: "32"
-
-    - PYTHON: "C:\\Python33"
-      PYTHON_VERSION: "3.3.x"
-      PYTHON_ARCH: "32"
-
-    - PYTHON: "C:\\Python34"
-      PYTHON_VERSION: "3.4.x"
-      PYTHON_ARCH: "32"
-
-    - PYTHON: "C:\\Python35"
-      PYTHON_VERSION: "3.5.x"
-      PYTHON_ARCH: "32"
-
-    # 64 bits
-
-    - PYTHON: "C:\\Python27-x64"
-      PYTHON_VERSION: "2.7.x"
-      PYTHON_ARCH: "64"
-
-    - PYTHON: "C:\\Python33-x64"
-      PYTHON_VERSION: "3.3.x"
-      PYTHON_ARCH: "64"
-
-    - PYTHON: "C:\\Python34-x64"
-      PYTHON_VERSION: "3.4.x"
-      PYTHON_ARCH: "64"
-
-    - PYTHON: "C:\\Python35-x64"
-      PYTHON_VERSION: "3.5.x"
-      PYTHON_ARCH: "64"
-      ARCH: x86_64
-      VS_VER: "2015"
-      INSTANCENAME: "SQL2012SP1"
-
-    # Also build on a Python version not pre-installed by Appveyor.
-    # See: https://github.com/ogrisel/python-appveyor-demo/issues/10
-
-    # - PYTHON: "C:\\Python266"
-    #   PYTHON_VERSION: "2.6.6"
-    #   PYTHON_ARCH: "32"
-
-init:
-  - "ECHO %PYTHON% %PYTHON_VERSION% %PYTHON_ARCH%"
-
-install:
-  - "powershell .ci\\appveyor\\install.ps1"
-  # - ps: (new-object net.webclient).DownloadFile('https://raw.github.com/pypa/pip/master/contrib/get-pip.py', 'C:/get-pip.py')
-  - "%WITH_COMPILER% %PYTHON%/python.exe -m pip --version"
-  - "%WITH_COMPILER% %PYTHON%/python.exe -m pip install --upgrade --user unittest2 ipaddress pypiwin32 wmi wheel"
-  - "%WITH_COMPILER% %PYTHON%/python.exe -m pip freeze"
-  - "%WITH_COMPILER% %PYTHON%/python.exe setup.py build"
-  - "%WITH_COMPILER% %PYTHON%/python.exe setup.py build build_ext -i"
-  - "%WITH_COMPILER% %PYTHON%/python.exe setup.py develop"
-  # 1.0.1 is the latest release supporting python 2.6
-  - "%WITH_COMPILER% %PYTHON%/Scripts/pip.exe install mock==1.0.1"
-
-build: off
-
-test_script:
-  - "%WITH_COMPILER% %PYTHON%/python -V"
-  - "%WITH_COMPILER% %PYTHON%/python psutil/tests/runner.py"
-
-after_test:
-  - "%WITH_COMPILER% %PYTHON%/python setup.py bdist_wheel"
-  - "%WITH_COMPILER% %PYTHON%/python setup.py bdist_wininst"
-
-artifacts:
-  - path: dist\*
-
-# on_success:
-#   - might want to upload the content of dist/*.whl to a public wheelhouse
-
-skip_commits:
-  message: skip-ci
diff --git a/docs/404.rst b/docs/404.rst
new file mode 100644
index 0000000000..a5e981cc3d
--- /dev/null
+++ b/docs/404.rst
@@ -0,0 +1,26 @@
+:orphan:
+
+404 - Page not found
+====================
+
+.. code-block:: pytb
+
+   Traceback (most recent call last):
+     File "<browser>", line 1, in <module>
+       fetch_page(url)
+   psutil.NoSuchProcess: process no longer exists (pid=404)
+
+The page you're looking for doesn't exist. Or it does, as a
+:class:`~psutil.ZombieProcess` we can't reap.
+
+What now?
+---------
+
+- Hit ``Ctrl + K`` (or ``Cmd + K``) to open the search box.
+- Jump to the :doc:`install guide <install>`, :doc:`API reference <api>`,
+  :doc:`FAQ <faq>` or :doc:`recipes <recipes>`.
+- Read the :doc:`blog <blog>` for posts and release notes.
+- If you got here from a link that *should* work, please
+  `open an issue on GitHub`_.
+
+.. _open an issue on GitHub: https://github.com/giampaolo/psutil/issues/new?title=Broken+link%3A+
diff --git a/docs/DEVNOTES.md b/docs/DEVNOTES.md
new file mode 100644
index 0000000000..7382ca785a
--- /dev/null
+++ b/docs/DEVNOTES.md
@@ -0,0 +1,223 @@
+A collection of ideas and notes about stuff to implement in future versions.
+
+## Inconsistencies
+
+(the "too late" section)
+
+- `PROCFS_PATH` should have been `set_procfs_path()`.
+
+- `virtual_memory()` should have been `memory_virtual()`.
+
+- `swap_memory()` should have been `memory_swap()`.
+
+- Named tuples are problematic. Positional unpacking of named tuples could be
+  deprecated. Return frozen dataclasses (with a common base class) instead of
+  `typing.NamedTuple`. The base class would keep `_fields`, `_asdict()` and
+  `len()` for compat, but `__iter__` and `__getitem__` would emit
+  DeprecationWarning. Main concern: `isinstance(x, tuple)` would break.
+
+## Rejected ideas
+
+- #550: threads per core
+- #1667: `process_iter(new_only=True)`
+
+## Features
+
+- #2794: enrich `Process.wait()` return value with exit code enums.
+
+- `net_if_addrs()` could return AF_BLUETOOTH interfaces. E.g.
+  https://pypi.org/project/netifaces does this.
+
+- Use `resource.getrusage()` to get current process CPU times (it has more
+  precision).
+
+- (UNIX) `Process.root()` (different from `cwd()`).
+
+- (Linux) locked files via /proc/locks:
+  https://www.centos.org/docs/5/html/5.2/Deployment_Guide/s2-proc-locks.html
+
+- #269: NIC rx/tx queue. This should probably go into `net_if_stats()`. Figure
+  out on what platforms this is supported. Linux: yes. Others?
+
+- Asynchronous `psutil.Popen` (see http://bugs.python.org/issue1191964)
+
+- (Windows) fall back on using WMIC for Process methods returning
+  `AccessDenied`.
+
+- #613: thread names; patch for macOS available at:
+  https://code.google.com/p/plcrashreporter/issues/detail?id=65 Sample code:
+  https://github.com/janmojzis/pstree/blob/master/proc_kvm.c
+
+- `scripts/taskmgr-gui.py` (using tk).
+
+- system-wide number of open file descriptors:
+  - https://jira.hyperic.com/browse/SIGAR-30
+
+- Number of system threads.
+  - Windows:
+    http://msdn.microsoft.com/en-us/library/windows/desktop/ms684824(v=vs.85).aspx
+
+- `psutil.proc_tree()` something which obtains a `{pid:ppid, ...}` struct for
+  all running processes in one shot. This can be factored out from
+  `Process.children()` and exposed as a first class function. PROS: on Windows
+  we can take advantage of `ppid_map()`, which is faster than iterating over
+  all PIDs. CONS: `scripts/pstree.py` shows this can be easily done in the user
+  code, so maybe it's not worth the addition.
+
+- advanced cmdline interface exposing the whole API and providing different
+  kind of outputs (e.g. pprinted, colorized, json).
+
+- Linux: process cgroups (http://en.wikipedia.org/wiki/Cgroups). They look
+  similar to `prlimit()` in terms of functionality but, uglier (they should
+  allow limiting per-process network IO resources though, which is great).
+  Needs further reading.
+
+- Python 3.3. exposed different sched.h functions:
+  http://docs.python.org/dev/whatsnew/3.3.html#os
+  http://bugs.python.org/issue12655
+  http://docs.python.org/dev/library/os.html#interface-to-the-scheduler It It
+  might be worth to take a look and figure out whether we can include some of
+  those in psutil.
+
+- `os.times()` provides `elapsed` times (`Process.cpu_times()` might as well?).
+
+- Enrich exception classes hierarchy on Python >= 3.3 / post PEP-3151 so that:
+  - `NoSuchProcess` inherits from `ProcessLookupError`
+  - `AccessDenied` inherits from `PermissionError`
+  - `TimeoutExpired inherits` from TimeoutError (debatable) See:
+    http://docs.python.org/3/library/exceptions.html#os-exceptions
+
+- `Process.threads()` might grow an extra "id" parameter so that it can be used
+  as:
+
+  ```python
+  >>> p = psutil.Process(os.getpid())
+  >>> p.threads(id=psutil.current_thread_id())
+  thread(id=2539, user_time=0.03, system_time=0.02)
+  >>>
+  ```
+
+  Note: this leads to questions such as "should we have a custom `NoSuchThread`
+  exception? Also see issue #418. Also note: this would work with `os.getpid()`
+  only. `psutil.current_thread_id()` might be desirable as per issue #418
+  though.
+
+- should `TimeoutExpired` exception have a 'msg' kwarg similar to
+  `NoSuchProcess` and `AccessDenied`? Not that we need it, but currently we
+  cannot raise a `TimeoutExpired` exception with a specific error string.
+
+- round `Process.memory_percent() result?
+
+## Resources
+
+- zabbix: https://zabbix.org/wiki/Get_Zabbix
+- netdata: https://github.com/netdata/netdata
+
+## System tools source code
+
+Source code of system monitoring tools (ps, top, vmstat, etc.) on various
+platforms. Useful as a reference when implementing or verifying psutil's
+platform-specific code.
+
+### Linux
+
+- **procps-ng** (ps, top, free, vmstat, kill, uptime, w, who, pgrep, pmap,
+  pstree, pwdx, watch): https://gitlab.com/procps-ng/procps
+- **sysstat** (iostat, mpstat, pidstat, sar):
+  https://github.com/sysstat/sysstat
+- **iproute2** (ss, ip): https://github.com/iproute2/iproute2
+- **net-tools** (ifconfig, netstat, arp, route):
+  https://net-tools.sourceforge.io/
+- **util-linux** (mount, findmnt, taskset, ionice, renice, prlimit, lscpu,
+  lsblk): https://github.com/util-linux/util-linux
+- **GNU coreutils** (df, nproc): https://github.com/coreutils/coreutils
+- **lsof**: https://github.com/lsof-org/lsof
+- **lm-sensors** (sensors): https://github.com/lm-sensors/lm-sensors
+- **smem**: https://www.selenic.com/smem/
+
+### macOS
+
+Apple open-source distributions: https://github.com/apple-oss-distributions/
+
+- **ps**: https://github.com/apple-oss-distributions/adv_cmds
+- **top**: https://github.com/apple-oss-distributions/top
+- **sysctl**: https://github.com/apple-oss-distributions/system_cmds
+- **netstat, ifconfig**:
+  https://github.com/apple-oss-distributions/network_cmds
+- **lsof**: https://github.com/apple-oss-distributions/lsof
+
+### FreeBSD
+
+Repository: https://github.com/freebsd/freebsd-src
+
+- **ps**: https://github.com/freebsd/freebsd-src/tree/main/bin/ps
+- **top**: https://github.com/freebsd/freebsd-src/tree/main/usr.bin/top
+- **vmstat**: https://github.com/freebsd/freebsd-src/tree/main/usr.bin/vmstat
+- **systat**: https://github.com/freebsd/freebsd-src/tree/main/usr.bin/systat
+- **netstat**: https://github.com/freebsd/freebsd-src/tree/main/usr.bin/netstat
+- **iostat**: https://github.com/freebsd/freebsd-src/tree/main/usr.sbin/iostat
+- **procstat**:
+  https://github.com/freebsd/freebsd-src/tree/main/usr.bin/procstat
+- **ifconfig**: https://github.com/freebsd/freebsd-src/tree/main/sbin/ifconfig
+- **cpuset**: https://github.com/freebsd/freebsd-src/tree/main/bin/cpuset
+- **pgrep**: https://github.com/freebsd/freebsd-src/tree/main/bin/pkill
+- **swapinfo**:
+  https://github.com/freebsd/freebsd-src/tree/main/usr.sbin/swapinfo
+
+### NetBSD
+
+Repository: https://github.com/NetBSD/src
+
+- **ps**: https://github.com/NetBSD/src/tree/trunk/bin/ps
+- **top**: https://github.com/NetBSD/src/tree/trunk/external/bsd/top
+- **vmstat**: https://github.com/NetBSD/src/tree/trunk/usr.bin/vmstat
+- **systat**: https://github.com/NetBSD/src/tree/trunk/usr.bin/systat
+- **netstat**: https://github.com/NetBSD/src/tree/trunk/usr.bin/netstat
+- **ifconfig**: https://github.com/NetBSD/src/tree/trunk/sbin/ifconfig
+- **pgrep**: https://github.com/NetBSD/src/tree/trunk/bin/pgrep
+
+### OpenBSD
+
+Repository: https://github.com/openbsd/src
+
+- **ps**: https://github.com/openbsd/src/tree/master/bin/ps
+- **top**: https://github.com/openbsd/src/tree/master/usr.bin/top
+- **vmstat**: https://github.com/openbsd/src/tree/master/usr.bin/vmstat
+- **systat**: https://github.com/openbsd/src/tree/master/usr.bin/systat
+- **netstat**: https://github.com/openbsd/src/tree/master/usr.bin/netstat
+- **ifconfig**: https://github.com/openbsd/src/tree/master/sbin/ifconfig
+- **pgrep**: https://github.com/openbsd/src/tree/master/bin/pgrep
+- **swapctl**: https://github.com/openbsd/src/tree/master/sbin/swapctl
+
+### Other tools
+
+- **zabbix**: https://github.com/zabbix/zabbix/
+- **htop**: https://github.com/htop-dev/htop
+- **btop**: https://github.com/aristocratos/btop/
+
+## Stats
+
+- https://pepy.tech/projects/psutil
+- https://clickpy.clickhouse.com/dashboard/psutil
+- https://pypistats.org/packages/psutil
+
+## Doc
+
+### Blog
+
+Example sites using sphinx ablog:
+
+- ablog: https://ablog.readthedocs.io/en/stable/blog.html (dogfoods its own
+  extension)
+- SunPy (solar-physics Python library): https://sunpy.org/blog.html
+- sgkit (genetics toolkit): https://sgkit-dev.github.io/sgkit/latest/blog.html
+- Nuitka (Python-to-C compiler): https://nuitka.net/blog.html
+- Executable Books Project (Jupyter Book / MyST):
+  https://executablebooks.org/en/latest/blog/
+- Adriaan Rol (quantum researcher personal site): https://adriaanrol.com/
+- Jean-Pierre Chauvel (personal tech blog): https://www.chauvel.org/blog/
+
+### Nice sites
+
+- Nice home: https://pnpm.io/
+- https://vite.dev/
diff --git a/docs/Makefile b/docs/Makefile
index a69fc329e5..c206dbb2de 100644
--- a/docs/Makefile
+++ b/docs/Makefile
@@ -1,173 +1,66 @@
 # Makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line.
-PYTHON        = python
-SPHINXOPTS    =
-SPHINXBUILD   = $(PYTHON) -m sphinx
-PAPER         =
-BUILDDIR      = _build
-
-# Internal variables.
-PAPEROPT_a4     = -D latex_paper_size=a4
-PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-# the i18n builder cannot share the environment and doctrees with the others
-I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
-
-.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
-
-help:
-	@echo "Please use \`make <target>' where <target> is one of"
-	@echo "  html       to make standalone HTML files"
-	@echo "  dirhtml    to make HTML files named index.html in directories"
-	@echo "  singlehtml to make a single large HTML file"
-	@echo "  pickle     to make pickle files"
-	@echo "  json       to make JSON files"
-	@echo "  htmlhelp   to make HTML files and a HTML help project"
-	@echo "  qthelp     to make HTML files and a qthelp project"
-	@echo "  devhelp    to make HTML files and a Devhelp project"
-	@echo "  epub       to make an epub"
-	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
-	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
-	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
-	@echo "  text       to make text files"
-	@echo "  man        to make manual pages"
-	@echo "  texinfo    to make Texinfo files"
-	@echo "  info       to make Texinfo files and run them through makeinfo"
-	@echo "  gettext    to make PO message catalogs"
-	@echo "  changes    to make an overview of all changed/added/deprecated items"
-	@echo "  xml        to make Docutils-native XML files"
-	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
-	@echo "  linkcheck  to check all external links for integrity"
-	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
-
-clean:
+
+PYTHON = python3
+PYTHONWARNINGS = always,ignore:::sphinx_sitemap,ignore:::matplotlib.projections,ignore:::notfound.extension
+SPHINXBUILD = PYTHONWARNINGS="$(PYTHONWARNINGS)" $(PYTHON) -m sphinx
+SPHINXAUTOBUILD = PYTHONWARNINGS="$(PYTHONWARNINGS)" sphinx-autobuild
+SPHINXOPTS = --fail-on-warning --jobs=auto
+BUILDDIR = _build
+DOCTREES = $(BUILDDIR)/doctrees
+OUTDIR = $(BUILDDIR)/html
+DIRHTML = -b dirhtml -d $(DOCTREES) . $(OUTDIR)
+# "make autoreload" gets its own dir. Sharing one with the other targets makes
+# them delete files from under each other.
+LIVEDIR = $(BUILDDIR)/live
+LIVE_DIRHTML = -b dirhtml -d $(LIVEDIR)/doctrees . $(LIVEDIR)/html
+
+# --- build
+
+clean:  ## Remove all build files
 	rm -rf $(BUILDDIR)
 
-html:
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
-
-dirhtml:
-	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
-	@echo
-	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
-
-singlehtml:
-	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
-	@echo
-	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
-
-pickle:
-	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
-	@echo
-	@echo "Build finished; now you can process the pickle files."
-
-json:
-	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
-	@echo
-	@echo "Build finished; now you can process the JSON files."
-
-htmlhelp:
-	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
-	@echo
-	@echo "Build finished; now you can run HTML Help Workshop with the" \
-	      ".hhp project file in $(BUILDDIR)/htmlhelp."
-
-qthelp:
-	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
-	@echo
-	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
-	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
-	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/psutil.qhcp"
-	@echo "To view the help file:"
-	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/psutil.qhc"
-
-devhelp:
-	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
-	@echo
-	@echo "Build finished."
-	@echo "To view the help file:"
-	@echo "# mkdir -p $$HOME/.local/share/devhelp/psutil"
-	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/psutil"
-	@echo "# devhelp"
-
-epub:
-	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
-	@echo
-	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
-
-latex:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo
-	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
-	@echo "Run \`make' in that directory to run these through (pdf)latex" \
-	      "(use \`make latexpdf' here to do that automatically)."
-
-latexpdf:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through pdflatex..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-latexpdfja:
-	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
-	@echo "Running LaTeX files through platex and dvipdfmx..."
-	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
-	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
-
-text:
-	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
-	@echo
-	@echo "Build finished. The text files are in $(BUILDDIR)/text."
-
-man:
-	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
-	@echo
-	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
-
-texinfo:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo
-	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
-	@echo "Run \`make' in that directory to run these through makeinfo" \
-	      "(use \`make info' here to do that automatically)."
-
-info:
-	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
-	@echo "Running Texinfo files through makeinfo..."
-	make -C $(BUILDDIR)/texinfo info
-	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
-
-gettext:
-	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
-	@echo
-	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
-
-changes:
-	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
-	@echo
-	@echo "The overview file is in $(BUILDDIR)/changes."
-
-linkcheck:
-	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
-	@echo
-	@echo "Link check complete; look for any errors in the above output " \
-	      "or in $(BUILDDIR)/linkcheck/output.txt."
-
-doctest:
-	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
-	@echo "Testing of doctests in the sources finished, look at the " \
-	      "results in $(BUILDDIR)/doctest/output.txt."
-
-xml:
-	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
-	@echo
-	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
-
-pseudoxml:
-	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
-	@echo
-	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
+html:  ## Generate doc in HTML format. Warnings are turned into failures.
+	$(SPHINXBUILD) $(SPHINXOPTS) $(DIRHTML)
+
+autoreload:  ## Rebuild HTML + live-reload browser on file changes (requires sphinx-autobuild)
+	$(SPHINXAUTOBUILD) $(SPHINXOPTS) $(LIVE_DIRHTML)
+
+autoreload-hard:  ## Same as above but re-writes all files on every refresh
+	rm -rf $(LIVEDIR)
+	$(SPHINXAUTOBUILD) $(SPHINXOPTS) -a $(LIVE_DIRHTML)
+
+versions:  ## Build past doc releases into the current build (needs `html` first)
+	$(PYTHON) ../scripts/internal/docs/build_versions.py $(OUTDIR)
+
+# --- checkers
+
+check-links:  ## Check links. Prints only broken URLs / warnings.
+	$(SPHINXBUILD) $(SPHINXOPTS) --quiet -b linkcheck -d $(DOCTREES) . $(BUILDDIR)/linkcheck
+	@echo "Link check complete; full report in $(BUILDDIR)/linkcheck/output.txt."
+
+check-codeautolink:  ## Report sphinx-codeautolink resolution failures (non-fatal).
+	$(SPHINXBUILD) --jobs=auto \
+		-D codeautolink_warn_on_failed_resolve=1 \
+		-D codeautolink_warn_on_missing_inventory=1 \
+		-b dirhtml -d $(BUILDDIR)/codeautolink/doctrees . $(BUILDDIR)/codeautolink/html
+
+# --- tests
+
+test:  ## Run doc sanity tests.
+	$(PYTHON) -m pytest test_docs.py $(ARGS)
+
+test-online-doc:  ## Smoke tests against the live docs site.
+	PSUTIL_DOCS_ONLINE=1 $(PYTHON) -m pytest test_docs_online.py -v
+
+# --- tools
+
+blog-post:  ## Create a new blog post skeleton
+	@test -n "$(SLUG)" || { echo "Usage: make blog-post SLUG=<slug> [TITLE=<text>] [TAGS=<csv>]"; exit 1; }
+	$(PYTHON) ../scripts/internal/docs/new_blog_post.py "$(SLUG)"$(if $(TITLE), --title "$(TITLE)")$(if $(TAGS), --tags "$(TAGS)")
+
+refresh-adoption-stats:  ## Refresh PyPI/GitHub stats in adoption.rst and README.rst
+	$(PYTHON) ../scripts/internal/docs/refresh_adoption_stats.py
+	$(MAKE) -C .. fix-rst
+
+help: ## Display callable targets.
+	@awk -F':.*?## ' '/^[a-zA-Z0-9_.-]+:.*?## / {printf "\033[36m%-24s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST) | sort
diff --git a/docs/README b/docs/README
deleted file mode 100644
index 3aaea8a5ba..0000000000
--- a/docs/README
+++ /dev/null
@@ -1,15 +0,0 @@
-About
-=====
-
-This directory contains the reStructuredText (reST) sources to the psutil
-documentation.  You don't need to build them yourself, prebuilt versions are
-available at https://pythonhosted.org/psutil/.
-In case you want, you need to install sphinx first:
-
-    $ pip install sphinx
-
-Then run:
-
-    $ make html
-
-You'll then have an HTML version of the doc at _build/html/index.html.
\ No newline at end of file
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000000..11077f42d1
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,64 @@
+# psutil documentation
+
+This directory is a self-contained Sphinx project that builds the psutil docs
+published at https://psutil.io/. It has grown well past a plain API reference
+(custom theme, a blog, social cards, its own test suite and deploy pipeline),
+so this file is the map.
+
+## Build & preview
+
+    make html          # one-off build into _build/html
+    make autoreload    # live-reload server at 127.0.0.1:8000
+
+`make html` turns warnings into errors, same as CI.
+
+## Layout
+
+- `*.rst`: the doc sources. `api.rst` is the hand-written API reference;
+  `index.rst` is the home page.
+- `blog/`: blog posts, managed by the ablog extension + comments provided via
+  giscus.
+- `conf.py`: Sphinx config: extensions, the theme, `html_baseurl`, OpenGraph /
+  sitemap / feed settings.
+- `_templates/`: the custom theme, built on Sphinx's `basic` theme (topbar,
+  sidebar, footer, layout).
+- `_static/css/`, `_static/js/`: styles and vanilla JS (no framework).
+- `_ext/`: small local Sphinx extensions.
+- `_extra/robots.txt`: copied verbatim to the site root.
+- `versions.json`: the version selector's menu (see below).
+
+## Notable choices
+
+- master is served at the site root (no `/en/`, no `/latest/`); frozen past
+  releases live under `/<version>/`, listed in `versions.json`.
+- Built with the `dirhtml` builder, so URLs are extensionless directories
+  (`psutil.io/faq/`, no `.html`).
+- Self-hosted on GitHub Pages under the custom domain psutil.io.
+- Fonts, CSS and JS are all self-hosted; no external assets.
+- Social cards, sitemap and Atom feed are generated at build time and rooted at
+  `html_baseurl`.
+
+## Freezing a doc version
+
+Add an entry to `versions.json`:
+
+    { "name": "8.0", "url": "/8.0/", "note": "release", "ref": "v8.0.0" }
+
+Entries with a `ref` are rebuilt from it on every deploy and get an "old
+version" banner. Nothing is stored, and tags publish nothing on their own.
+Deleting the entry unpublishes it.
+
+## Tests
+
+- `test_docs.py`: offline checks on the built HTML (canonical / OG tags,
+  sitemap, feed, blog metadata, no external assets, ...). Run with `make test`.
+- `test_docs_online.py`: smoke tests against the live site (reachability,
+  http->https, 404 page, metadata). Run with `make test-online-doc` (sets
+  `PSUTIL_DOCS_ONLINE=1`).
+
+## Deploy
+
+`.github/workflows/docs.yml` runs on pushes / PRs that touch `docs/`: lint
+(`make lint-rst`) -> offline tests -> build -> build past versions -> deploy to
+GitHub Pages -> live-site tests. Deploy and the live tests run only on push to
+master, never on PRs.
diff --git a/docs/_ext/ablog_extras.py b/docs/_ext/ablog_extras.py
new file mode 100644
index 0000000000..43a20bed0e
--- /dev/null
+++ b/docs/_ext/ablog_extras.py
@@ -0,0 +1,49 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Ablog tweaks."""
+
+import pathlib
+import xml.etree.ElementTree as ET
+
+SITEMAP_NS = "http://www.sitemaps.org/schemas/sitemap/0.9"
+
+
+def merge_ablog_posts(app, env, docnames, other):
+    if hasattr(other, "ablog_posts"):
+        if not hasattr(env, "ablog_posts"):
+            env.ablog_posts = {}
+        env.ablog_posts.update(other.ablog_posts)
+
+
+def dedupe_sitemap(app, exception):
+    # ablog re-renders the blog index on top of blog.rst, so
+    # sphinx-sitemap sees that page twice and lists its URL twice.
+    if exception:
+        return
+    path = pathlib.Path(app.outdir) / app.config.sitemap_filename
+    if not path.is_file():
+        return
+    ET.register_namespace("", SITEMAP_NS)
+    tree = ET.parse(path)
+    root = tree.getroot()
+    seen = set()
+    for url in list(root):
+        loc = url.findtext(f"{{{SITEMAP_NS}}}loc")
+        if loc in seen:
+            root.remove(url)
+        else:
+            seen.add(loc)
+    tree.write(path, encoding="utf-8", xml_declaration=True)
+
+
+def setup(app):
+    app.connect("env-merge-info", merge_ablog_posts)
+    # priority > 500 so this runs after sphinx-sitemap writes the file.
+    app.connect("build-finished", dedupe_sitemap, priority=600)
+    # Ablog stores posts on the build environment but doesn't merge
+    # them back when Sphinx builds in parallel, so worker results get
+    # dropped. See https://github.com/sunpy/ablog/pull/330.
+    app.extensions["ablog"].parallel_read_safe = True
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/availability.py b/docs/_ext/availability.py
new file mode 100644
index 0000000000..99e7d8705c
--- /dev/null
+++ b/docs/_ext/availability.py
@@ -0,0 +1,100 @@
+# noqa: CPY001
+
+# Slightly adapted from CPython's:
+# https://github.com/python/cpython/blob/main/Doc/tools/extensions/availability.py
+# Copyright (c) PSF
+# Licensed under the Python Software Foundation License Version 2.
+
+"""Support for `.. availability:: …` directive, to document platform
+availability.
+"""
+
+from docutils import nodes
+from sphinx.locale import _ as sphinx_gettext
+from sphinx.util import logging
+from sphinx.util.docutils import SphinxDirective
+
+logger = logging.getLogger(__name__)
+
+_PLATFORMS = frozenset({
+    "AIX",
+    "BSD",
+    "FreeBSD",
+    "Linux",
+    "Linux with glibc",
+    "macOS",
+    "NetBSD",
+    "OpenBSD",
+    "POSIX",
+    "SunOS",
+    "UNIX",
+    "Windows",
+})
+
+_LIBC = frozenset({
+    "glibc",
+    "musl",
+})
+
+KNOWN_PLATFORMS = _PLATFORMS | _LIBC
+
+
+class Availability(SphinxDirective):
+    has_content = True
+    required_arguments = 1
+    optional_arguments = 0
+    final_argument_whitespace = True
+
+    def run(self):
+        title = sphinx_gettext("Availability")
+        sep = nodes.Text(" ")
+        parsed, msgs = self.state.inline_text(self.arguments[0], self.lineno)
+        pnode = nodes.paragraph(
+            title, "", nodes.emphasis(title, title + ":"), sep, *parsed, *msgs
+        )
+        self.set_source_info(pnode)
+        cnode = nodes.container("", pnode, classes=["availability"])
+        self.set_source_info(cnode)
+        if self.content:
+            self.state.nested_parse(self.content, self.content_offset, cnode)
+        self.parse_platforms()
+
+        return [cnode]
+
+    def parse_platforms(self):
+        """Parse platform information from arguments
+
+        Arguments is a comma-separated string of platforms. A platform may
+        be prefixed with "not " to indicate that a feature is not available.
+        Example:
+           .. availability:: Windows, Linux >= 4.2, not glibc
+        """
+        platforms = {}
+        for arg in self.arguments[0].rstrip(".").split(","):
+            arg = arg.strip()
+            platform, _, version = arg.partition(" >= ")
+            if platform.startswith("not "):
+                version = False
+                platform = platform.removeprefix("not ")
+            elif not version:
+                version = True
+            platforms[platform] = version
+
+        unknown = set(platforms).difference(KNOWN_PLATFORMS)
+        if unknown:
+            logger.warning(
+                "Unknown platform%s or syntax '%s' in '.. availability:: %s', "
+                "see %s:KNOWN_PLATFORMS for a set of known platforms.",
+                "s" if len(platforms) != 1 else "",
+                " ".join(sorted(unknown)),
+                self.arguments[0],
+                __file__,
+                location=self.get_location(),
+            )
+
+        return platforms
+
+
+def setup(app):
+    app.add_directive("availability", Availability)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/changelog_anchors.py b/docs/_ext/changelog_anchors.py
new file mode 100644
index 0000000000..2598a3cc6e
--- /dev/null
+++ b/docs/_ext/changelog_anchors.py
@@ -0,0 +1,46 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Sphinx extension for adding anchors to each section in changelog.rst.
+
+This script gets called on `make html`, and adds numeric anchors for
+version titles (e.g., `7.2.3 — 2026-02-08` -> #723). It also registers
+them as Sphinx labels so that :ref:`722` cross-references resolve
+correctly.
+"""
+
+import re
+
+from docutils import nodes
+
+VERSION_RE = re.compile(r"^(\d+\.\d+\.\d+)")
+
+
+def add_version_anchors(app, doctree):
+    docname = app.env.docname
+    if docname != "changelog":
+        return
+
+    labels = app.env.domaindata.setdefault('std', {}).setdefault('labels', {})
+    anonlabels = app.env.domaindata['std'].setdefault('anonlabels', {})
+
+    for node in doctree.findall(nodes.section):
+        title = node.next_node(nodes.title)
+        if not title:
+            continue
+
+        text = title.astext()
+        m = VERSION_RE.match(text)
+        if m:
+            anchor = m.group(1).replace(".", "")
+            if anchor not in node["ids"]:
+                node["ids"].insert(0, anchor)
+            if anchor not in labels:
+                labels[anchor] = ("changelog", anchor, text)
+                anonlabels[anchor] = ("changelog", anchor)
+
+
+def setup(app):
+    app.connect("doctree-read", add_version_anchors)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/check_python_syntax.py b/docs/_ext/check_python_syntax.py
new file mode 100644
index 0000000000..1758535b48
--- /dev/null
+++ b/docs/_ext/check_python_syntax.py
@@ -0,0 +1,45 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Sphinx extension that checks the Python syntax of code blocks in the
+documentation. This script gets called on `make html`.
+"""
+
+import ast
+
+import docutils.nodes
+import sphinx.errors
+
+
+def check_python_blocks(app, doctree, docname):
+    path = app.env.doc2path(docname)
+
+    for node in doctree.findall(docutils.nodes.literal_block):
+        lang = node.get("language")
+        if lang not in {"python", "py"}:
+            continue
+
+        code = node.astext()
+
+        # skip empty blocks
+        if not code.strip():
+            continue
+
+        # skip REPL examples containing >>>
+        if ">>>" in code:
+            continue
+
+        try:
+            ast.parse(code, feature_version=(3, 8))
+        except SyntaxError as err:
+            lineno = node.line or "?"
+            msg = (
+                f"invalid Python syntax in {path}:{lineno}:\n\n{code}\n\n{err}"
+            )
+            raise sphinx.errors.SphinxError(msg) from None
+
+
+def setup(app):
+    app.connect("doctree-resolved", check_python_blocks)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/field_role.py b/docs/_ext/field_role.py
new file mode 100644
index 0000000000..c1b475a63b
--- /dev/null
+++ b/docs/_ext/field_role.py
@@ -0,0 +1,22 @@
+# Copyright (c) 2009, Giampaolo Rodola. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Sphinx extension providing the :field:`name` role for marking named
+tuple fields in the API doc.
+"""
+
+from docutils import nodes
+
+
+def field_role(
+    name, rawtext, text, lineno, inliner, options=None, content=None
+):
+    """Render :field:`name` as inline code (monospace bold)."""
+    node = nodes.literal(rawtext, text, classes=["ntuple-field"])
+    return [node], []
+
+
+def setup(app):
+    app.add_role("field", field_role)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/genindex_filter.py b/docs/_ext/genindex_filter.py
new file mode 100644
index 0000000000..6a84797238
--- /dev/null
+++ b/docs/_ext/genindex_filter.py
@@ -0,0 +1,57 @@
+# Copyright (c) 2009, Giampaolo Rodola. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Post-process genindex.html to clean up index entry labels.
+
+Transforms:
+    <a href="...">NAME (qualifier)</a>
+
+Into:
+    <a href="...">NAME</a> <span class="index-qualifier">(qualifier)</span>
+
+Also shortens verbose Sphinx qualifiers:
+  (in module psutil)    → (function) if NAME ends with "()", else (constant)
+  (class in psutil)     → (class)
+  (exception in psutil) → (exception)
+"""
+
+import pathlib
+import re
+
+# Matches <a href="...">NAME (qualifier)</a> where NAME does not start
+# with "(" — leaving pure-paren sub-entries like "(psutil.Foo method)" alone.
+REGEX = re.compile(r'<a href="([^"]+)">([^(<][^<]*?) (\([^)]+\))</a>')
+
+
+def replace(m):
+    href, name, qualifier = m.group(1), m.group(2), m.group(3)
+    if qualifier == "(in module psutil)":
+        qualifier = "(function)" if name.endswith("()") else "(constant)"
+    elif qualifier == "(class in psutil)":
+        qualifier = "(class)"
+    elif qualifier == "(exception in psutil)":
+        qualifier = "(exception)"
+    return (
+        f'<a href="{href}">{name}</a> <span'
+        f' class="index-qualifier">{qualifier}</span>'
+    )
+
+
+def on_build_finished(app, exception):
+    # format (not name) so this also runs under dirhtml, which writes
+    # genindex/index.html rather than genindex.html.
+    if exception or app.builder.format != "html":
+        return
+    genindex = pathlib.Path(app.builder.get_outfilename("genindex"))
+    if not genindex.exists():
+        return
+    original = genindex.read_text(encoding="utf-8")
+    processed = REGEX.sub(replace, original)
+    if processed != original:
+        genindex.write_text(processed, encoding="utf-8")
+
+
+def setup(app):
+    app.connect("build-finished", on_build_finished)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/giscus.py b/docs/_ext/giscus.py
new file mode 100644
index 0000000000..241224bddf
--- /dev/null
+++ b/docs/_ext/giscus.py
@@ -0,0 +1,31 @@
+# Copyright (c) 2009, Giampaolo Rodola. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Feed the giscus config and a per-page "is this a blog post" flag to
+the HTML templates, so _templates/comments.html can render the comment
+widget on post pages only.
+"""
+
+CONFIG_VALUES = (
+    "giscus_repo",
+    "giscus_repo_id",
+    "giscus_category",
+    "giscus_category_id",
+)
+
+
+def add_giscus_context(app, pagename, templatename, context, doctree):
+    is_post = pagename in getattr(app.env, "ablog_posts", {})
+    # A bare ":no_comments:" field at the top of a post opts it out.
+    meta = app.env.metadata.get(pagename, {})
+    context["is_blog_post"] = is_post and "no_comments" not in meta
+    for name in CONFIG_VALUES:
+        context[name] = getattr(app.config, name)
+
+
+def setup(app):
+    for name in CONFIG_VALUES:
+        app.add_config_value(name, "", "html")
+    app.connect("html-page-context", add_giscus_context)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/glossary_toc.py b/docs/_ext/glossary_toc.py
new file mode 100644
index 0000000000..78f268db96
--- /dev/null
+++ b/docs/_ext/glossary_toc.py
@@ -0,0 +1,27 @@
+# Copyright (c) 2009, Giampaolo Rodola. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Inject glossary terms into the Jinja context to enable rendering of
+the right-side TOC on /glossary.
+"""
+
+from docutils import nodes
+
+
+def on_html_page_context(app, page_name, template_name, context, doctree):
+    if page_name != "glossary":
+        return
+    glossary_doctree = app.env.get_doctree("glossary")
+    terms = []
+    for term in glossary_doctree.findall(nodes.term):
+        ids = term.get("ids") or []
+        if ids:
+            terms.append({"id": ids[0], "text": term.astext()})
+    terms.sort(key=lambda t: t["text"].lower())
+    context["glossary_terms"] = terms
+
+
+def setup(app):
+    app.connect("html-page-context", on_html_page_context)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/label_role.py b/docs/_ext/label_role.py
new file mode 100644
index 0000000000..7b536d2c74
--- /dev/null
+++ b/docs/_ext/label_role.py
@@ -0,0 +1,30 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Sphinx role providing the changelog labels, e.g. :label:`critical`."""
+
+from docutils import nodes
+
+LABELS = ("breaking", "critical", "build-fail", "memleak")
+
+
+def label_role(
+    name, rawtext, text, lineno, inliner, options=None, content=None
+):
+    label = text.strip().lower()
+    if label not in LABELS:
+        msg = inliner.reporter.error(
+            f"unknown label {text!r}, expected one of {', '.join(LABELS)}",
+            line=lineno,
+        )
+        return [inliner.problematic(rawtext, rawtext, msg)], [msg]
+    node = nodes.inline(
+        rawtext, label, classes=["cl-label", f"cl-label-{label}"]
+    )
+    return [node], []
+
+
+def setup(app):
+    app.add_role("label", label_role)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/notfound_extras.py b/docs/_ext/notfound_extras.py
new file mode 100644
index 0000000000..936d3f24cd
--- /dev/null
+++ b/docs/_ext/notfound_extras.py
@@ -0,0 +1,56 @@
+# Copyright (c) 2009, Giampaolo Rodola. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Make the custom 404 page work under dirhtml + static hosting.
+
+Two gaps sphinx-notfound-page / dirhtml leave, both about URLs on the
+404 page:
+
+- notfound absolutizes the 404's chrome and images but leaves body
+  cross-references (:doc:, :class:) relative. Those break when the 404
+  is served from a deep path, so absolutize them too, reusing
+  notfound's own helper.
+- dirhtml writes the 404 as ``404/index.html``. GitHub Pages and
+  Starlette (sphinx-autobuild) serve the custom 404 from ``/404.html``
+  at the root, so materialize it there.
+"""
+
+import shutil
+from pathlib import Path
+
+from docutils import nodes
+from notfound.utils import replace_uris
+
+
+def absolutize_404_links(app, doctree, docname):
+    if docname == app.config.notfound_pagename:
+        replace_uris(app, doctree, nodes.reference, "refuri")
+
+
+def absolutize_404_content_root(app, pagename, templatename, context, doctree):
+    # data-content_root is relative; JS (search, highlight) uses it to
+    # build URLs. On the 404, served from any depth, it must be
+    # absolute or those URLs resolve against the wrong base.
+    if pagename == app.config.notfound_pagename:
+        context["content_root"] = app.config.notfound_urls_prefix
+
+
+def write_root_404(app, exception):
+    if exception is not None:
+        return
+    name = app.config.notfound_pagename
+    src = Path(app.outdir) / name / "index.html"
+    if src.is_file():
+        shutil.copyfile(src, Path(app.outdir) / f"{name}.html")
+
+
+def setup(app):
+    app.connect("doctree-resolved", absolutize_404_links)
+    app.connect("html-page-context", absolutize_404_content_root)
+    app.connect("build-finished", write_root_404)
+    return {
+        "version": "0.1",
+        "parallel_read_safe": True,
+        "parallel_write_safe": True,
+    }
diff --git a/docs/_ext/opengraph_override.py b/docs/_ext/opengraph_override.py
new file mode 100644
index 0000000000..74eac575db
--- /dev/null
+++ b/docs/_ext/opengraph_override.py
@@ -0,0 +1,151 @@
+# Copyright (c) 2009, Giampaolo Rodola. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Bridge ablog and sphinxext-opengraph for social-card metadata."""
+
+import html
+import re
+
+import sphinxext.opengraph
+
+BLOG_DESCRIPTION = "Psutil blog: releases, deep dives, war stories"
+HOME_OG_TITLE = "psutil: Process and System Utilities for Python"
+DESCRIPTION_OVERRIDE = {}
+
+STATIC_DESCRIPTIONS = {
+    "index": (
+        "psutil is a cross-platform Python library for retrieving "
+        "information on running processes and system utilization: CPU, "
+        "memory, disks, network and sensors."
+    ),
+    "api": "psutil full API reference.",
+    "install": "How to install psutil.",
+}
+
+VIEWPORT_RE = re.compile(r'\s*<meta name="viewport"[^>]*>', re.IGNORECASE)
+OG_TITLE_RE = re.compile(r'(<meta property="og:title" content=")[^"]*(")')
+
+original_get_description = sphinxext.opengraph.get_description
+
+
+def patched_get_description(doctree, desc_len, known_titles=None):
+    text = DESCRIPTION_OVERRIDE.get("current")
+    if text is None:
+        return original_get_description(doctree, desc_len, known_titles)
+    text = html.escape(text, quote=True)
+    if desc_len and len(text) > desc_len:
+        text = text[: desc_len - 3] + "..."
+    return text
+
+
+def capture_post_summary(app, pagename, templatename, context, doctree):
+    # Get post's summary (the body of the .. post:: directive) and use
+    # it in the og preview.
+    DESCRIPTION_OVERRIDE.pop("current", None)
+    static = STATIC_DESCRIPTIONS.get(pagename)
+    if static:
+        DESCRIPTION_OVERRIDE["current"] = static
+        return
+    posts = (getattr(app.env, "ablog_posts", {}) or {}).get(pagename) or []
+    if not posts:
+        return
+    excerpt_nodes = posts[0].get("excerpt")
+    if not excerpt_nodes:
+        return
+    text = " ".join(n.astext() for n in excerpt_nodes if hasattr(n, "astext"))
+    text = " ".join(text.split())
+    if text:
+        DESCRIPTION_OVERRIDE["current"] = text
+
+
+def set_og_type_article(app, pagename, templatename, context, doctree):
+    # sphinxext-opengraph hardcodes og:type="website" globally. Override
+    # it to "article" for blog posts so social platforms classify them.
+    if pagename in getattr(app.env, "ablog_posts", {}):
+        meta = context.get("meta")
+        if meta is None:
+            meta = {}
+            context["meta"] = meta
+        meta["og:type"] = "article"
+
+
+def blog_index_meta(app, pagename):
+    """Title and description for an ablog-generated index page."""
+    blog_path = app.config.blog_path
+    if pagename == blog_path:
+        return app.config.project + " blog", BLOG_DESCRIPTION
+    m = re.fullmatch(re.escape(blog_path) + r"/(\d{4})", pagename)
+    if m:
+        year = m.group(1)
+        return (
+            f"{app.config.project} blog: {year}",
+            f"psutil blog posts published in {year}.",
+        )
+    return None
+
+
+def emit_blog_index_meta(app, pagename, templatename, context, doctree):
+    # ablog renders the blog index and the year archives without a
+    # doctree, so sphinxext-opengraph skips them: no description, no
+    # og:* tags at all.
+    meta = blog_index_meta(app, pagename)
+    if meta is None:
+        return
+    og_title, description = meta
+    project = app.config.project
+    base = app.config.html_baseurl.rstrip("/") + "/"
+    fields = [
+        ("name", "description", description),
+        ("property", "og:title", og_title),
+        ("property", "og:type", "website"),
+        # Builder-derived: dirhtml serves this as blog/, not blog.html.
+        ("property", "og:url", base + app.builder.get_target_uri(pagename)),
+        ("property", "og:site_name", project),
+        ("property", "og:description", description),
+        ("property", "og:image", base + "_static/images/logo-psutil.png"),
+        (
+            "property",
+            "og:image:alt",
+            (
+                "psutil blog: articles on processes, system monitoring "
+                "and psutil development"
+            ),
+        ),
+        ("name", "twitter:card", "summary"),
+    ]
+    tags = "\n".join(
+        f'<meta {attr}="{key}" content="{val}" />' for attr, key, val in fields
+    )
+    if pagename == app.config.blog_path:
+        context["feed_title"] = app.config.blog_title or "Blog"
+    context["metatags"] = context.get("metatags", "") + tags + "\n"
+
+
+def finalize_head(app, pagename, templatename, context, doctree):
+    tags = context.get("metatags")
+    if not tags:
+        return
+    deduped = VIEWPORT_RE.sub("", tags)
+    if pagename == app.config.master_doc:
+        deduped = OG_TITLE_RE.sub(
+            r"\g<1>" + html.escape(HOME_OG_TITLE, quote=True) + r"\g<2>",
+            deduped,
+        )
+    if deduped != tags:
+        context["metatags"] = deduped
+
+
+def setup(app):
+    sphinxext.opengraph.get_description = patched_get_description
+
+    # priority < 500 ensures we run before sphinxext-opengraph.
+    app.connect("html-page-context", capture_post_summary, priority=300)
+    app.connect("html-page-context", set_og_type_article, priority=400)
+    app.connect("html-page-context", emit_blog_index_meta)
+    app.connect("html-page-context", finalize_head, priority=600)
+    return {
+        "version": "0.1",
+        "parallel_read_safe": True,
+        "parallel_write_safe": True,
+    }
diff --git a/docs/_ext/post_banner.py b/docs/_ext/post_banner.py
new file mode 100644
index 0000000000..8c907b77ae
--- /dev/null
+++ b/docs/_ext/post_banner.py
@@ -0,0 +1,163 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Insert a metadata banner (date + author + tags + reading time)
+right below the H1 of each blog post.
+
+Ablog's sidebar exposes post metadata, but nothing appears near the
+title on the post page itself. This extension walks post doctrees
+and inserts a small container after the first section's title.
+"""
+
+import math
+
+from ablog.blog import Blog
+from docutils import nodes
+
+# Conservative words-per-minute estimate for technical prose. Code
+# blocks are excluded from the word count.
+WPM = 200
+SKIP_NODES = (
+    nodes.literal_block,
+    nodes.doctest_block,
+    nodes.comment,
+    nodes.raw,
+    nodes.system_message,
+)
+
+
+def count_words(node):
+    if isinstance(node, SKIP_NODES):
+        return 0
+    if isinstance(node, nodes.Text):
+        return len(node.astext().split())
+    return sum(count_words(c) for c in node.children)
+
+
+def reading_minutes(doctree):
+    return max(1, math.ceil(count_words(doctree) / WPM))
+
+
+def tag_ref(app, blog, docname, label, text, classes=None):
+    """Return a nodes.reference from `docname` to the tag page for
+    `label`.
+    """
+    coll = blog.tags[label]
+    # Let the builder compute this: dirhtml serves each page as a
+    # directory, so a hand-rolled relpath + ".html" lands a level off
+    # and points at a file that doesn't exist.
+    target = app.builder.get_relative_uri(docname, coll.docname)
+    return nodes.reference(
+        text, text, refuri=target, internal=True, classes=classes or []
+    )
+
+
+def featured_inline(app, blog, post, docname):
+    tags = [str(t) for t in post.get("tags") or []]
+    if "featured" not in tags:
+        return None
+    # Reference must live inside a TextElement (sphinx html5 asserts
+    # this). Wrap in an inline like tags_inline does.
+    container = nodes.inline()
+    container += tag_ref(
+        app, blog, docname, "featured", "Featured", ["post-meta-featured"]
+    )
+    return container
+
+
+def author_inline(post):
+    authors = post.get("author") or []
+    if not authors:
+        return None
+    text = ", ".join(str(a) for a in authors)
+    return nodes.inline(text, text, classes=["post-meta-author"])
+
+
+def date_inline(post):
+    date = post.get("date")
+    if not date:
+        return None
+    text = date.strftime("%b %d, %Y")
+    return nodes.inline(text, text, classes=["post-meta-date"])
+
+
+def readtime_inline(doctree):
+    text = f"{reading_minutes(doctree)} min read"
+    return nodes.inline(text, text, classes=["post-meta-readtime"])
+
+
+def tags_inline(app, blog, post, docname):
+    tags = [t for t in post.get("tags") or [] if str(t) != "featured"]
+    if not tags:
+        return None
+    container = nodes.inline(classes=["post-meta-tags"])
+    for label in sorted(tags, key=str):
+        container += tag_ref(app, blog, docname, label, str(blog.tags[label]))
+    return container
+
+
+def find_title_position(doctree):
+    """Return (section, title_index) for the first section with a
+    title, or (None, None) if none exists.
+    """
+    section = next(iter(doctree.findall(nodes.section)), None)
+    if section is None:
+        return None, None
+    idx = next(
+        (
+            i
+            for i, c in enumerate(section.children)
+            if isinstance(c, nodes.title)
+        ),
+        None,
+    )
+    return (section, idx) if idx is not None else (None, None)
+
+
+class post_banner(nodes.container, nodes.Invisible):
+    """Container subclass marked as docutils Invisible. The HTML
+    writer still renders it as a <div> (via the visit/depart
+    functions registered below), but sphinxext-opengraph's
+    description parser skips isinstance(node, nodes.Invisible)
+    nodes, so the banner text does not leak into og:description.
+    """
+
+
+def visit_post_banner(self, node):
+    self.visit_container(node)
+
+
+def depart_post_banner(self, node):
+    self.depart_container(node)
+
+
+def insert_banner(app, doctree, docname):
+    posts = getattr(app.env, "ablog_posts", {}).get(docname)
+    if not posts:
+        return
+    post = posts[0]
+
+    section, title_idx = find_title_position(doctree)
+    if section is None:
+        return
+
+    blog = Blog(app)
+    banner = post_banner(classes=["post-meta-banner"])
+    for child in (
+        featured_inline(app, blog, post, docname),
+        author_inline(post),
+        date_inline(post),
+        readtime_inline(doctree),
+        tags_inline(app, blog, post, docname),
+    ):
+        if child is not None:
+            banner += child
+
+    section.insert(title_idx + 1, banner)
+
+
+def setup(app):
+    app.add_node(post_banner, html=(visit_post_banner, depart_post_banner))
+    app.connect("doctree-resolved", insert_banner)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/proc_role.py b/docs/_ext/proc_role.py
new file mode 100644
index 0000000000..1e6af386c6
--- /dev/null
+++ b/docs/_ext/proc_role.py
@@ -0,0 +1,32 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Sphinx role linking `/proc/<file>` paths to Debian's man-pages.
+E.g. :proc:`/proc/meminfo`, :proc:`/proc/pid/statm`.
+"""
+
+from docutils import nodes
+
+URL = "https://manpages.debian.org/{}(5)"
+
+
+def proc_role(
+    name, rawtext, text, lineno, inliner, options=None, content=None
+):
+    path = text.strip()
+    # /proc/[pid]/stat -> proc_pid_stat
+    parts = []
+    for seg in path.lstrip("/").split("/"):
+        s = seg.strip("[]").lower()
+        parts.append("pid" if s == "pid" else s)
+    page = "_".join(parts)
+    url = URL.format(page)
+    ref = nodes.reference(rawtext, "", refuri=url, classes=["proc"])
+    ref += nodes.literal(text=path)
+    return [ref], []
+
+
+def setup(app):
+    app.add_role("proc", proc_role)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_ext/substitutions.py b/docs/_ext/substitutions.py
new file mode 100644
index 0000000000..2034645a32
--- /dev/null
+++ b/docs/_ext/substitutions.py
@@ -0,0 +1,39 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Expand {{name}} tokens in the .rst sources.
+
+For values that would otherwise be hardcoded and go stale. Docutils
+substitutions (|name|) can't be used: they don't expand inside
+`raw:: html` blocks, and the home page stats live in one. This runs
+on the raw text, before parsing, so tokens work anywhere.
+"""
+
+import datetime
+
+# Date of the first commit. A constant so the build doesn't shell out
+# to git (and doesn't depend on a full clone); test_docs.py checks it
+# against the real history.
+FIRST_COMMIT = datetime.date(2008, 4, 22)
+
+
+def years_in_development(today=None):
+    today = today or datetime.date.today()
+    years = today.year - FIRST_COMMIT.year
+    if (today.month, today.day) < (FIRST_COMMIT.month, FIRST_COMMIT.day):
+        years -= 1
+    return years
+
+
+def substitute(app, docname, source):
+    values = {"years_in_development": years_in_development()}
+    text = source[0]
+    for name, value in values.items():
+        text = text.replace("{{" + name + "}}", str(value))
+    source[0] = text
+
+
+def setup(app):
+    app.connect("source-read", substitute)
+    return {"parallel_read_safe": True, "parallel_write_safe": True}
diff --git a/docs/_extra/robots.txt b/docs/_extra/robots.txt
new file mode 100644
index 0000000000..47df22042a
--- /dev/null
+++ b/docs/_extra/robots.txt
@@ -0,0 +1,4 @@
+User-agent: *
+Allow: /
+
+Sitemap: https://psutil.io/sitemap.xml
diff --git a/docs/_sponsors.html b/docs/_sponsors.html
new file mode 100644
index 0000000000..a6c938ea8b
--- /dev/null
+++ b/docs/_sponsors.html
@@ -0,0 +1,65 @@
+<table border="0" cellpadding="10" cellspacing="0" class="sponsor-table">
+  <tr>
+    <td align="center" style="vertical-align: middle;">
+      <a href="https://tidelift.com/subscription/pkg/pypi-psutil?utm_source=pypi-psutil&utm_medium=referral&utm_campaign=readme" aria-label="Tidelift">
+        <?xml version="1.0" encoding="utf-8"?>
+        <svg width="160" version="1.1" id="Artwork" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="2 2 187 29" xml:space="preserve">
+          <style type="text/css">
+            .st0{fill:#4B5168;}
+            .st1{fill:#F6914D;}
+            :root[data-theme="dark"] .st0{fill:#c8cad0;}
+          </style>
+          <g>
+            <path class="st0" d="M33.4,27.7V5.3c0-2.3,0-2.3,2.4-2.3c2.4,0,2.4,0,2.4,2.3v22.4c0,2.3,0,2.3-2.4,2.3C33.4,29.9,33.4,29.9,33.4,27.7z"/>
+            <path class="st0" d="M45,26.4V6.6c0-3.6,0-3.6,3.6-3.6h5.8c7.8,0,12.5,3.9,13,10.2c0.2,2.2,0.2,3.4,0,5.5c-0.5,6.3-5.3,11.2-13,11.2h-5.8C45,29.9,45,29.9,45,26.4z M54.3,25.4c5.3,0,8-3,8.3-7.1c0.1-1.8,0.1-2.8,0-4.6c-0.3-4.2-3-6.1-8.3-6.1h-4.5v17.8H54.3z"/>
+            <path class="st0" d="M73.8,26.4V6.6c0-3.6,0-3.6,3.6-3.6h13.5c2.3,0,2.3,0,2.3,2.2c0,2.2,0,2.2-2.3,2.2H78.6v6.9h11c2.2,0,2.2,0,2.2,2.1c0,2.1,0,2.1-2.2,2.1h-11v6.9h12.3c2.3,0,2.3,0,2.3,2.2c0,2.3,0,2.3-2.3,2.3H77.4C73.8,29.9,73.8,29.9,73.8,26.4z"/>
+            <path class="st0" d="M100,26.4v-21c0-2.3,0-2.3,2.4-2.3c2.4,0,2.4,0,2.4,2.3v20.2h11.9c2.4,0,2.4,0,2.4,2.2c0,2.2,0,2.2-2.4,2.2h-13.1C100,29.9,100,29.9,100,26.4z"/>
+            <path class="st0" d="M125.8,27.7V5.3c0-2.3,0-2.3,2.4-2.3c2.4,0,2.4,0,2.4,2.3v22.4c0,2.3,0,2.3-2.4,2.3C125.8,29.9,125.8,29.9,125.8,27.7z"/>
+            <path class="st0" d="M137.4,27.7V6.6c0-3.6,0-3.6,3.6-3.6h13.5c2.3,0,2.3,0,2.3,2.2c0,2.2,0,2.2-2.3,2.2h-12.2v7.2h11.3c2.3,0,2.3,0,2.3,2.2c0,2.2,0,2.2-2.3,2.2h-11.3v8.6c0,2.3,0,2.3-2.4,2.3S137.4,29.9,137.4,27.7z"/>
+            <path class="st0" d="M24.2,3.1H5.5c-2.4,0-2.4,0-2.4,2.2c0,2.2,0,2.2,2.4,2.2h7v4.7v3.2l4.8-3.7v-1.1V7.5h7c2.4,0,2.4,0,2.4-2.2C26.6,3.1,26.6,3.1,24.2,3.1z"/>
+            <path class="st1" d="M12.5,20v7.6c0,2.3,0,2.3,2.4,2.3c2.4,0,2.4,0,2.4-2.3V16.3L12.5,20z"/>
+            <g>
+              <path class="st0" d="M165.9,3.1h18.7c2.4,0,2.4,0,2.4,2.2c0,2.2,0,2.2-2.4,2.2h-7v4.7v3.2l-4.8-3.7v-1.1V7.5h-7c-2.4,0-2.4,0-2.4-2.2C163.5,3.1,163.5,3.1,165.9,3.1z"/>
+              <path class="st1" d="M177.6,20v7.6c0,2.3,0,2.3-2.4,2.3c-2.4,0-2.4,0-2.4-2.3V16.3L177.6,20z"/>
+            </g>
+          </g>
+        </svg>
+      </a>
+    </td>
+    <td align="center" style="vertical-align: middle;">
+      <a href="https://sansec.io/" aria-label="Sansec">
+        <svg width="145" viewBox="0 0 186 34.854" xmlns="http://www.w3.org/2000/svg">
+          <style>.s-dark{fill:#1d2227;}:root[data-theme="dark"] .s-dark{fill:#c8cad0;}</style>
+          <g class="s-dark"><path d="m0 26.351 6.117-2.823c.941 2.319 2.756 4.5 5.983 4.5 2.252 0 4.3-1.109 4.3-3.731 0-2.017-1.109-2.958-4.336-4.235l-2.117-.807c-4.537-1.815-8.705-4.3-8.705-9.814.002-5.841 4.909-9.441 10.791-9.441a11.935 11.935 0 0 1 11.192 7.226l-5.579 3.159c-1.479-2.588-3.193-3.664-5.31-3.664-2.05 0-3.63.941-3.63 2.857 0 1.479.874 2.622 4.4 4.067l2.286.907c6.117 2.386 8.84 5.176 8.84 9.848 0 7.058-6.319 10.453-12.033 10.453-5.981.001-10.922-3.528-12.199-8.502z"/><path d="m80.7 39.906c0-8.671 6.218-12.906 11.864-12.906 4.4 0 6.991 2.386 7.361 3.294h.134v-2.823h7.394v24.838h-7.393v-2.824h-.134c-.37.907-2.958 3.294-7.361 3.294-5.647 0-11.865-4.235-11.865-12.873zm19.528 0a6.1 6.1 0 1 0 -12.2 0 6.1 6.1 0 1 0 12.2 0z" transform="translate(-53.576 -17.925)"/><path d="m199.7 37.688v14.621h-7.4v-13.309c0-3.092-1.58-5.411-4.638-5.411-2.991 0-4.571 2.286-4.571 5.411v13.31h-7.391v-24.839h7.394v3.159a8.293 8.293 0 0 1 7.327-3.63c5.008 0 9.279 3.092 9.279 10.688z" transform="translate(-116.647 -17.925)"/><path d="m257.6 45.655 5.882-1.58a3.591 3.591 0 0 0 3.6 2.857c1.344 0 2.588-.672 2.588-2.05 0-.807-.471-1.58-2.117-2.117l-3.327-1.244c-4.1-1.479-5.882-4.168-5.882-7.26 0-4.638 4.168-7.361 9.041-7.361 4.672 0 8.066 2.622 8.94 6.655l-5.819 1.445a2.888 2.888 0 0 0 -2.857-2.353c-1.445 0-2.151.874-2.151 1.714 0 .807.471 1.58 2.151 2.117l3.092 1.143c2.689.907 6.218 2.756 6.218 7.26 0 5.008-4.235 7.831-9.781 7.831-5.041.001-8.805-2.318-9.578-7.057z" transform="translate(-171.02 -17.859)"/><path d="m347.171 42.763h-17.679c1.008 2.689 3.5 4 6.789 4a9.5 9.5 0 0 0 5.983-1.916l3.327 3.5a12.629 12.629 0 0 1 -10.117 4.437c-6.89 0-13.074-4.672-13.074-12.839 0-8.4 6.252-12.94 12.671-12.94 6.285-.005 13.68 4.395 12.1 15.758zm-17.814-5.31h11.327a5.345 5.345 0 0 0 -5.546-4.235 5.693 5.693 0 0 0 -5.781 4.235z" transform="translate(-214.04 -17.925)"/></g>
+          <path d="m505.48 31.2a12.836 12.836 0 0 0 -9.68-4.4v25.813a12.836 12.836 0 0 0 9.68-4.4 12.818 12.818 0 0 1 0-17.007z" fill="#00a19a" transform="translate(-329.16 -17.792)"/>
+          <path d="m524.6 31.2a12.818 12.818 0 0 1 0 17.007 12.836 12.836 0 0 0 9.68 4.4v-25.807a12.89 12.89 0 0 0 -9.68 4.4z" fill="#fc0" transform="translate(-348.28 -17.792)"/>
+          <path d="m518.227 39.9a12.819 12.819 0 0 0 0 17.007 12.818 12.818 0 0 0 0-17.007z" fill="#3f1f71" transform="translate(-341.906 -26.489)"/>
+          <path class="s-dark" d="m425.175 48.376a13.086 13.086 0 0 1 -2.722-4.974 6.412 6.412 0 0 1 -5.21 2.722 5.886 5.886 0 0 1 -5.915-6.252 5.857 5.857 0 0 1 5.915-6.151 6.458 6.458 0 0 1 5.176 2.689 12.879 12.879 0 0 1 2.756-5.075c.235-.269.5-.538.773-.807a11.972 11.972 0 0 0 -8.705-3.528c-6.655 0-13.243 4.437-13.243 12.839 0 8.5 6.588 12.94 13.242 12.94a12.11 12.11 0 0 0 8.739-3.6z" transform="translate(-268.214 -17.925)"/>
+        </svg>
+      </a>
+    </td>
+    <td align="center" style="vertical-align: middle;">
+      <a href="https://www.apivoid.com/" aria-label="APIVoid">
+        <svg width="130" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 400 120">
+          <defs>
+            <style>.a-dark{fill:#130f40;}:root[data-theme="dark"] .a-dark{fill:#c8cad0;}</style>
+            <linearGradient id="apivoid-a">
+              <stop offset="0" stop-color="#ee5b24"/>
+              <stop offset=".5" stop-color="#f38321"/>
+              <stop offset="1" stop-color="#f79e1f"/>
+            </linearGradient>
+            <linearGradient xlink:href="#apivoid-a" id="apivoid-b" x1="416.183" x2="416.183" y1="409.143" y2="267.974" gradientTransform="matrix(.79919 0 0 .79919 -253.764 -207.28)" gradientUnits="userSpaceOnUse"/>
+          </defs>
+          <path fill="url(#apivoid-b)" d="M149.65 6.916c-2.023 0-3.802.769-5.339 2.306-1.456 1.456-2.183 3.235-2.183 5.338s.727 3.884 2.183 5.34c1.537 1.456 3.316 2.184 5.339 2.184 2.103 0 3.883-.728 5.34-2.184 1.536-1.456 2.305-3.237 2.305-5.34 0-2.103-.769-3.882-2.306-5.338-1.456-1.537-3.236-2.306-5.34-2.306zm0 22.568c-2.023 0-3.802.769-5.339 2.306-1.456 1.456-2.183 3.196-2.183 5.218v45.864c0 2.022.727 3.802 2.183 5.338 1.537 1.456 3.316 2.186 5.339 2.186 2.103 0 3.883-.73 5.34-2.186 1.536-1.536 2.305-3.316 2.305-5.338V37.008c0-2.022-.769-3.762-2.306-5.218-1.456-1.537-3.236-2.306-5.34-2.306zm-70.234.122c-2.022 0-3.801.768-5.338 2.305-1.456 1.456-2.185 3.236-2.185 5.339v75.106c0 2.103.729 3.884 2.185 5.34 1.537 1.537 3.316 2.304 5.338 2.304 2.103 0 3.883-.767 5.339-2.304 1.536-1.456 2.305-3.237 2.305-5.34V86.148c4.692 2.75 9.748 4.126 15.167 4.126 8.413 0 15.572-2.953 21.477-8.858 5.905-5.905 8.857-13.064 8.857-21.477 0-8.332-2.952-15.45-8.857-21.355-5.905-5.986-13.064-8.978-21.477-8.978zm-49.081.122c-8.413 0-15.572 2.951-21.477 8.856C2.953 44.49 0 51.648 0 60.061c0 8.331 2.953 15.45 8.858 21.355 5.905 5.905 13.023 8.899 21.355 8.98h22.931c2.023 0 3.763-.73 5.219-2.186 1.537-1.537 2.305-3.316 2.305-5.338V60.061c0-8.413-2.953-15.572-8.858-21.477-5.905-5.905-13.063-8.856-21.475-8.856zm71.892 15.045c4.207 0 7.765 1.496 10.677 4.49 2.993 2.911 4.49 6.47 4.49 10.676s-1.497 7.807-4.49 10.8c-2.912 2.912-6.47 4.367-10.677 4.367-4.206 0-7.805-1.455-10.798-4.367-2.912-2.993-4.369-6.594-4.369-10.8s1.457-7.765 4.369-10.677c2.993-2.993 6.592-4.489 10.798-4.489zm-71.892.122c4.206 0 7.764 1.496 10.676 4.49 2.993 2.911 4.49 6.47 4.49 10.676s-1.497 7.805-4.49 10.798c-2.912 2.912-6.47 4.37-10.676 4.37s-7.807-1.458-10.8-4.37c-2.912-2.993-4.368-6.592-4.368-10.798 0-4.207 1.456-7.765 4.368-10.677 2.993-2.993 6.594-4.49 10.8-4.49z"/>
+          <path class="a-dark" d="M392.354 0c-2.022 0-3.801.769-5.338 2.306-1.456 1.456-2.184 3.235-2.184 5.338v26.21c-4.691-2.751-9.748-4.126-15.167-4.126-8.413 0-15.57 2.951-21.475 8.856-5.905 5.905-8.858 13.064-8.858 21.477 0 8.332 2.953 15.49 8.858 21.477 5.905 5.905 13.062 8.858 21.475 8.858h22.69c2.102 0 3.883-.73 5.34-2.186 1.536-1.536 2.305-3.357 2.305-5.46V7.644c0-2.103-.769-3.882-2.306-5.338C396.238.769 394.457 0 392.354 0Zm-72.462 6.916c-2.022 0-3.801.769-5.338 2.306-1.456 1.456-2.186 3.235-2.186 5.338s.73 3.884 2.186 5.34c1.537 1.456 3.316 2.184 5.338 2.184 2.103 0 3.882-.728 5.338-2.184 1.537-1.456 2.306-3.237 2.306-5.34 0-2.103-.769-3.882-2.306-5.338-1.456-1.537-3.235-2.306-5.338-2.306zm0 22.568c-2.022 0-3.801.769-5.338 2.306-1.456 1.456-2.186 3.196-2.186 5.218v45.864c0 2.022.73 3.802 2.186 5.338 1.537 1.456 3.316 2.186 5.338 2.186 2.103 0 3.882-.73 5.338-2.186 1.537-1.536 2.306-3.316 2.306-5.338V37.008c0-2.022-.769-3.762-2.306-5.218-1.456-1.537-3.235-2.306-5.338-2.306zm-142.418.244c-2.103 0-3.923.768-5.46 2.305-1.456 1.456-2.183 3.194-2.183 5.217 0 1.132.242 2.184.727 3.154l22.448 45.5c1.456 2.994 3.761 4.492 6.916 4.492 3.236 0 5.58-1.498 7.037-4.491l22.447-45.5c.485-.971.729-2.023.729-3.155 0-2.023-.769-3.76-2.306-5.217-1.456-1.537-3.236-2.305-5.34-2.305-3.154 0-5.458 1.496-6.914 4.489l-15.653 31.547-15.531-31.547c-1.456-2.993-3.762-4.49-6.917-4.49zm93.003 0c-8.413 0-15.572 2.951-21.477 8.856-5.905 5.905-8.856 13.064-8.856 21.477 0 8.412 2.951 15.571 8.856 21.476 5.905 5.905 13.064 8.859 21.477 8.859 8.412 0 15.571-2.954 21.476-8.859 5.905-5.905 8.857-13.064 8.857-21.476 0-8.413-2.952-15.572-8.857-21.477-5.905-5.905-13.064-8.856-21.476-8.856zm0 15.167c4.206 0 7.766 1.496 10.678 4.49 2.993 2.911 4.49 6.47 4.49 10.676s-1.497 7.805-4.49 10.798c-2.912 2.912-6.472 4.37-10.678 4.37-4.207 0-7.806-1.458-10.799-4.37-2.912-2.993-4.369-6.592-4.369-10.798s1.457-7.765 4.37-10.677c2.992-2.993 6.591-4.489 10.798-4.489zm99.188 0c4.206 0 7.766 1.496 10.678 4.49 2.993 2.911 4.49 6.47 4.49 10.676s-1.497 7.805-4.49 10.798c-2.912 2.912-6.472 4.37-10.678 4.37s-7.806-1.458-10.799-4.37c-2.912-2.993-4.367-6.592-4.367-10.798s1.455-7.765 4.367-10.677c2.993-2.993 6.593-4.489 10.799-4.489z"/>
+        </svg>
+      </a>
+    </td>
+  </tr>
+</table>
+
+<div class="sponsor-cta-wrap">
+  <!-- Absolute: this file is included from both / and /funding/, which
+       sit at different depths, so a relative href can't serve both. -->
+  <a class="sponsor-cta" href="/funding/">Add your logo</a>
+</div>
diff --git a/docs/_static/copybutton.js b/docs/_static/copybutton.js
deleted file mode 100644
index 5d82c672be..0000000000
--- a/docs/_static/copybutton.js
+++ /dev/null
@@ -1,57 +0,0 @@
-$(document).ready(function() {
-    /* Add a [>>>] button on the top-right corner of code samples to hide
-     * the >>> and ... prompts and the output and thus make the code
-     * copyable. */
-    var div = $('.highlight-python .highlight,' +
-                '.highlight-python3 .highlight')
-    var pre = div.find('pre');
-
-    // get the styles from the current theme
-    pre.parent().parent().css('position', 'relative');
-    var hide_text = 'Hide the prompts and output';
-    var show_text = 'Show the prompts and output';
-    var border_width = pre.css('border-top-width');
-    var border_style = pre.css('border-top-style');
-    var border_color = pre.css('border-top-color');
-    var button_styles = {
-        'cursor':'pointer', 'position': 'absolute', 'top': '0', 'right': '0',
-        'border-color': border_color, 'border-style': border_style,
-        'border-width': border_width, 'color': border_color, 'text-size': '75%',
-        'font-family': 'monospace', 'padding-left': '0.2em', 'padding-right': '0.2em',
-        'border-radius': '0 3px 0 0'
-    }
-
-    // create and add the button to all the code blocks that contain >>>
-    div.each(function(index) {
-        var jthis = $(this);
-        if (jthis.find('.gp').length > 0) {
-            var button = $('<span class="copybutton">&gt;&gt;&gt;</span>');
-            button.css(button_styles)
-            button.attr('title', hide_text);
-            jthis.prepend(button);
-        }
-        // tracebacks (.gt) contain bare text elements that need to be
-        // wrapped in a span to work with .nextUntil() (see later)
-        jthis.find('pre:has(.gt)').contents().filter(function() {
-            return ((this.nodeType == 3) && (this.data.trim().length > 0));
-        }).wrap('<span>');
-    });
-
-    // define the behavior of the button when it's clicked
-    $('.copybutton').toggle(
-        function() {
-            var button = $(this);
-            button.parent().find('.go, .gp, .gt').hide();
-            button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'hidden');
-            button.css('text-decoration', 'line-through');
-            button.attr('title', show_text);
-        },
-        function() {
-            var button = $(this);
-            button.parent().find('.go, .gp, .gt').show();
-            button.next('pre').find('.gt').nextUntil('.gp, .go').css('visibility', 'visible');
-            button.css('text-decoration', 'none');
-            button.attr('title', hide_text);
-        });
-});
-
diff --git a/docs/_static/css/admonitions.css b/docs/_static/css/admonitions.css
new file mode 100644
index 0000000000..a98d3510bd
--- /dev/null
+++ b/docs/_static/css/admonitions.css
@@ -0,0 +1,135 @@
+/* ---- Shared structure (defaults to Note) ---------------------------- */
+
+div.admonition {
+    position: relative;
+    margin: 10px 0;
+    padding: var(--adm-padding-y) 10px var(--adm-padding-y) 36px;
+    background-color: var(--adm-note-bg);
+    border: 1px solid var(--adm-note-border);
+    border-left: 4px solid var(--adm-note-accent-border);
+    border-radius: 4px;
+}
+
+div.admonition + div.admonition {
+    margin-top: 16px;
+}
+
+div.admonition p {
+    margin-bottom: var(--adm-padding-y);
+}
+
+/* ---- Per-type color overrides --------------------------------------- */
+
+div.warning {
+    background-color: var(--adm-warning-bg);
+    border-color: var(--adm-warning-border);
+    border-left-color: var(--adm-warning-border);
+}
+
+div.tip {
+    background-color: var(--adm-tip-bg);
+    border-color: var(--adm-tip-border);
+    border-left-color: var(--adm-tip-border);
+}
+
+div.important {
+    background-color: var(--adm-important-bg);
+    border-color: var(--adm-important-border);
+    border-left-color: var(--adm-important-border);
+}
+
+div.seealso {
+    background-color: var(--adm-seealso-bg);
+    border-color: var(--adm-seealso-border);
+    border-left-color: var(--adm-seealso-accent-border);
+}
+
+div.seealso a.reference {
+    color: var(--adm-seealso-link);
+    text-decoration: underline;
+    text-underline-offset: 2px;
+}
+
+div.seealso a.reference:has(code) {
+    text-decoration: none;
+}
+
+div.seealso a.reference:hover {
+    color: var(--adm-seealso-hover);
+}
+
+div.admonition a {
+    text-decoration: none;
+}
+
+/* ---- Title (inline with the first paragraph of content) ------------ */
+
+p.admonition-title,
+p.admonition-title + p {
+    display: inline;
+    margin: 0;
+    padding: 0;
+}
+
+p.admonition-title {
+    background: none;
+    color: var(--adm-title);
+    font-weight: 700;
+    margin-right: 0.4em;
+}
+
+p.admonition-title::after {
+    content: ":";
+}
+
+p.admonition-title::before {
+    content: "\f129";
+    position: absolute;
+    left: 10px;
+    top: calc(var(--adm-padding-y) + 3px);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 16px;
+    height: 16px;
+    border: 1.5px solid var(--adm-note-accent-border);
+    border-radius: 50%;
+    font-family: "Font Awesome 7 Free";
+    font-weight: 900;
+    font-size: 10px;
+    line-height: 1;
+    color: var(--adm-note-accent-border);
+}
+
+div.tip p.admonition-title::before,
+div.warning p.admonition-title::before,
+div.important p.admonition-title::before,
+div.seealso p.admonition-title::before {
+    top: var(--adm-padding-y);
+    width: auto;
+    height: auto;
+    border: 0;
+    border-radius: 0;
+    font-size: 15px;
+    line-height: inherit;
+}
+
+div.tip p.admonition-title::before {
+    content: "\f0eb";
+    color: var(--adm-tip-icon);
+}
+
+div.warning p.admonition-title::before {
+    content: "\f071";
+    color: var(--adm-warning-icon);
+}
+
+div.important p.admonition-title::before {
+    content: "\f06a";
+    color: var(--adm-important-icon);
+}
+
+div.seealso p.admonition-title::before {
+    content: "\f0c1";
+    color: var(--adm-seealso-accent-border);
+}
diff --git a/docs/_static/css/api-signatures.css b/docs/_static/css/api-signatures.css
new file mode 100644
index 0000000000..e411f3a129
--- /dev/null
+++ b/docs/_static/css/api-signatures.css
@@ -0,0 +1,128 @@
+/*
+ * psutil-sphinx-theme: API function / class signatures.
+ */
+
+/* ---- Signature container -------------------------------------------- */
+
+.article dl:not(.docutils):not(.simple) {
+    margin: 0 0 0 0;
+}
+
+.article dl.py + dl.py > dt {
+    margin-top: 10px;
+}
+
+/* Collapse constants without a description body. */
+.article dl.py:not(:has(> dd p)) + dl.py > dt {
+    margin-top: 0px;
+}
+
+.article dl.py > dd:not(:has(p)) {
+    margin: 0;
+    padding: 0;
+}
+
+.article dl:not(.docutils):not(.glossary) > dt {
+    background: var(--func-sig-bg);
+    color: var(--func-sig-text);
+    padding: 1px 9px;
+    border-left: 3px solid var(--func-sig-border);
+    border-radius: 0;
+    font-family: var(--font-body);
+    font-size: 17px;
+    margin-top: 0;
+    margin-bottom: 10px;
+    font-weight: 500;
+    display: block;
+    line-height: 1.5;
+    position: relative;
+}
+
+.article dl:not(.docutils):not(.glossary) > dt a.headerlink {
+    margin-left: 0.4rem;
+    padding: 0;
+}
+
+/* Function name + default values (e.g. "False" / "None"): bold. */
+.article dl:not(.docutils) > dt .descname,
+.article dl:not(.docutils) > dt .sig-name,
+.article dl:not(.docutils) > dt .default_value {
+    color: var(--func-sig-name);
+    font-weight: 700;
+}
+
+/* Reset to muted/normal: psutil. prefix, parens, param names,
+   operators, properties. Default values keep 700 from the dt. */
+.article dl:not(.docutils) > dt .sig-paren,
+.article dl:not(.docutils) > dt .sig-prename,
+.article dl:not(.docutils) > dt .descclassname,
+.article dl:not(.docutils) > dt .n,
+.article dl:not(.docutils) > dt .o,
+.article dl:not(.docutils) > dt .property {
+    color: var(--func-sig-param);
+    font-weight: 400;
+}
+
+.sig-paren {
+    padding-left: 2px;
+    padding-right: 2px;
+}
+
+/* "[source]" link to the right of the signature. */
+.viewcode-link {
+    color: var(--func-sig-border);
+    font-size: 0.8em;
+    font-style: italic;
+    font-weight: 600;
+    text-decoration: none;
+    margin-left: 1.5em;
+    vertical-align: middle;
+    position: relative;
+    top: 5px;
+}
+
+.viewcode-link:hover {
+    text-decoration: underline;
+}
+
+/* Nested <dd> body for the doc paragraph. */
+.article dl:not(.docutils):not(.glossary) > dd {
+    margin: 0.6em 0 1em 0;
+    padding: 0 0 0 1em;
+}
+
+/* ---- Glossary opt-out ---------------------------------------------- */
+
+.article dl.glossary > dt {
+    background: transparent;
+    border: none;
+    padding: 0;
+    font-size: 1.1em;
+    font-weight: 600;
+    color: var(--headings);
+    margin: 1.6em 0 0.3em 0;
+}
+
+.article dl.glossary > dd {
+    margin: 0 0 1em 1.5em;
+    padding: 0;
+    background: transparent;
+    border: none;
+}
+
+/* ---- Inline ntuple field code (e.g. `user`, `system`) -------------- */
+
+code.ntuple-field,
+.ntuple-field {
+    color: var(--ntuple-color);
+    font-weight: 700;
+}
+
+/* Compress constants */
+.article dl.py.data > dt {
+    margin-bottom: 2px;
+}
+
+.article dl.py.data + dl.py.data > dt {
+    margin-top: 0;
+}
diff --git a/docs/_static/css/banner.css b/docs/_static/css/banner.css
new file mode 100644
index 0000000000..c8f9467d83
--- /dev/null
+++ b/docs/_static/css/banner.css
@@ -0,0 +1,105 @@
+/* Full-width notice above the topbar (see _templates/banner.html).
+   Archived releases inject the same markup from build_versions.py. */
+
+.site-banner {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 10px;
+    padding: 9px 44px 9px 14px;
+    position: relative;
+    background: #fff8e1;
+    border-bottom: 1px solid #f0d98c;
+    color: #6b5618;
+    font-size: 0.88rem;
+    line-height: 1.45;
+    text-align: center;
+}
+
+html.site-banner-dismissed .site-banner {
+    display: none;
+}
+
+/* Archived releases are built from an old tag and have no
+   .header-stack; there the banner pins itself. */
+body > .site-banner {
+    position: sticky;
+    top: 0;
+    z-index: 1000;
+}
+
+/* Sensible offset before (or without) js/banner.js, which replaces it
+   with the measured height. */
+html:has(.site-banner) {
+    --header-height: calc(var(--topbar-height) + 40px);
+}
+
+html.site-banner-dismissed {
+    --header-height: var(--topbar-height);
+}
+
+.site-banner-close::before {
+    content: "\00d7";
+    font-size: 19px;
+    line-height: 1;
+}
+
+.site-banner-close {
+    position: absolute;
+    right: 10px;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 26px;
+    height: 26px;
+    padding: 0;
+    border: 0;
+    border-radius: 50%;
+    background: transparent;
+    color: inherit;
+    opacity: 0.7;
+    cursor: pointer;
+}
+
+.site-banner-close:hover {
+    background: rgba(0, 0, 0, 0.07);
+    opacity: 1;
+}
+
+.site-banner-close:focus-visible {
+    outline: 2px solid currentColor;
+    outline-offset: 1px;
+}
+
+[data-theme="dark"] .site-banner-close:hover {
+    background: rgba(255, 255, 255, 0.12);
+}
+
+/* Paired with :visited so the theme's visited-link rule can't leak
+   through and recolor it mid-sentence. */
+.site-banner a,
+.site-banner a:visited {
+    color: #8a6d1f;
+    font-weight: 600;
+    text-decoration: underline;
+    text-underline-offset: 2px;
+}
+
+.site-banner a:hover {
+    color: #5c470f;
+}
+
+[data-theme="dark"] .site-banner {
+    background: #2b2415;
+    border-bottom-color: #4a3c1d;
+    color: #ddcb98;
+}
+
+[data-theme="dark"] .site-banner a,
+[data-theme="dark"] .site-banner a:visited {
+    color: #f0d98c;
+}
+
+[data-theme="dark"] .site-banner a:hover {
+    color: #fbecc0;
+}
diff --git a/docs/_static/css/base.css b/docs/_static/css/base.css
new file mode 100644
index 0000000000..4bbc31131c
--- /dev/null
+++ b/docs/_static/css/base.css
@@ -0,0 +1,415 @@
+/*
+ * psutil-sphinx-theme: design tokens.
+ *
+ * All shared variables (colors, fonts, layout dimensions) live here
+ * so per-component CSS files (layout.css, topbar.css, *.css) consume
+ * vars instead of hardcoded values. Loaded first so the cascade has
+ * the tokens available before any rule references them.
+ */
+
+:root {
+    color-scheme: light;
+
+    /* ================================================================== */
+    /* Layout                                                             */
+    /* ================================================================== */
+
+    --topbar-height: 44px;
+    --header-height: var(--topbar-height);
+    --left-sidebar-width: 260px;
+    --right-sidebar-width: 230px;
+    --content-max-width: 1240px;
+    --layout-width: calc(var(--left-sidebar-width) + var(--content-max-width));
+
+    /* ================================================================== */
+    /* Colors                                                             */
+    /* ================================================================== */
+
+    /* Surfaces (backgrounds). */
+    --bg: #ffffff;
+    --bg-page: #efefef;
+    --bg-sidebar: #343131;
+    --bg-topbar: #2a2828;
+    --bg-input: #ffffff;
+    --bg-key: #f0f0f0;
+    --kbd-bg: #f3f3f3;
+    --kbd-text: #6a6a6a;
+    --kbd-border: #c8c8c8;
+    --bg-search-highlight: #e1edf5;
+    --bg-hover: rgba(0, 0, 0, 0.04);
+    --bg-hover-on-dark: rgba(255, 255, 255, 0.08);
+
+    /* Text. */
+    --text: #404040;
+    --text-muted: #555555;
+    --text-secondary: #555555;
+    --text-on-dark: #d1d1d1;
+    --headings: #404040;
+    --ntuple-color: #333333;
+
+    /* Sidebar: left nav is always on a dark surface; tokens here
+       are constant across light/dark mode (only --bg-sidebar shifts
+       between the two). */
+    --sidebar-fg: #d9d9d9;
+    --sidebar-caption: #8aa8c0;
+    --sidebar-active-bg: #f0f0f0;
+    --sidebar-active-fg: #1a1a1a;
+
+    /* Inline code (`literals`). */
+    --inline-code-bg: rgba(175, 184, 193, 0.17);
+    --inline-code-text: inherit;
+
+    /* Borders. */
+    --border: #dddddd;
+    --scrollbar-thumb: #c1c1c1;
+    --border-radius: 6px;
+    --border-radius-code: 3px;
+
+    --accent: #2371a8;
+    --accent-ring: rgba(40, 100, 180, 0.25);
+
+    /* Inline API links (cross-refs to symbols). */
+    --links-api: #336699;
+    --links-api-underline: #336699;
+
+    /* Function/method signature box ("psutil.cpu_times(percpu=False)"). */
+    --func-sig-bg: #f0f4f7;
+    --func-sig-border: #336699;
+    --func-sig-text: #404040;
+    --func-sig-name: #404040;
+    --func-sig-param: #555555;
+
+    /* Lifted-surface accent (cards, sponsor logos). */
+    --surface-raised: #f0f4f7;
+
+    /* Admonitions (Note / Tip / Warning / Important / See also). */
+    --adm-padding-y: 5px;
+    --adm-title: black;
+    --adm-note-bg: #f5f5f5;
+    --adm-note-border: #ccc;
+    --adm-note-accent-border: #2980b9;
+    --adm-tip-bg: #f0faf0;
+    --adm-tip-border: #8aba8a;
+    --adm-tip-icon: #4a8a4a;
+    --adm-warning-bg: #fff0f0;
+    --adm-warning-border: #e8a0a0;
+    --adm-warning-icon: #c0392b;
+    --adm-important-bg: #fdf3dc;
+    --adm-important-border: #d4a23e;
+    --adm-important-icon: #b07d17;
+    --adm-seealso-bg: #f3f9fe;
+    --adm-seealso-border: #b0cfe8;
+    --adm-seealso-accent-border: #336699;
+    --adm-seealso-link: #2a6099;
+    --adm-seealso-hover: #2980b9;
+
+    /* Version directives (versionadded / versionchanged / deprecated). */
+    --versionadded-border: #4fc464;
+    --versionadded-color: #296433;
+    --versionchanged-border: #f4e34c;
+    --versionchanged-color: #854826;
+    --deprecated-border: #f44c4e;
+    --deprecated-color: #9f3133;
+
+    /* Tables. */
+    --table-header-bg: #f0f4f7;
+    --table-header-text: var(--text);
+    --table-row-odd: #f8f9fa;
+    --table-row-even: #ffffff;
+    --table-border: var(--border);
+
+    /* Changelog labels. */
+    --label-critical-bg: #fdeaea;
+    --label-critical-text: #a3161a;
+    --label-critical-border: #f3c6c7;
+    --label-build-fail-bg: #fdf2ea;
+    --label-build-fail-text: #933e06;
+    --label-build-fail-border: #f4d3bd;
+    --label-memleak-bg: #fdf5d8;
+    --label-memleak-text: #7d5e00;
+    --label-memleak-border: #f2dc9c;
+    --label-breaking-bg: #f4eefe;
+    --label-breaking-text: #5c3fa3;
+    --label-breaking-border: #e0d4fa;
+
+    /* ================================================================== */
+    /* Fonts                                                              */
+    /* ================================================================== */
+
+    --font-body:
+        "Inter",
+        system-ui,
+        -apple-system,
+        "Segoe UI",
+        Roboto,
+        "Helvetica Neue",
+        Arial,
+        "Noto Sans",
+        sans-serif;
+    --font-mono:
+        "JetBrains Mono",
+        ui-monospace,
+        SFMono-Regular,
+        Menlo,
+        Monaco,
+        Consolas,
+        "Liberation Mono",
+        "Courier New",
+        monospace;
+    --code-line-height: 1.5;
+
+    /* ================================================================== */
+    /* Aliases (semantic names used by component files)                   */
+    /* ================================================================== */
+
+    --content-text: var(--text);
+    --code-font: var(--font-mono);
+    --links: var(--accent);
+    --surface-sunken: var(--bg-key);
+    --card-bg: var(--bg);
+    --card-border: var(--border);
+    --theme-transition: 0.2s ease;
+}
+
+/* ====================================================================== */
+/* Dark mode                                                              */
+/* ====================================================================== */
+
+/*
+ * Dark theme overrides only the color tokens. Layout / fonts are
+ * mode-agnostic. data-theme is set on <html> by extrahead's inline
+ * script + theme-toggle.js.
+ */
+
+[data-theme="dark"] {
+    color-scheme: dark;
+
+    /* Surfaces. */
+    --bg: #1a1a1a;
+    --bg-page: #0e0e0e;
+    --bg-sidebar: #212121;
+    --bg-topbar: #181818;
+    --bg-input: #2a2a2a;
+    --bg-key: #2a2a2a;
+    --kbd-bg: #3a3a3a;
+    --kbd-text: #d4d4d4;
+    --kbd-border: #5a5a5a;
+    --bg-search-highlight: rgba(225, 237, 245, 0.15);
+    --bg-hover: rgba(255, 255, 255, 0.06);
+    --sidebar-active-bg: #404040;
+    --sidebar-active-fg: #fff;
+
+    /* Text. */
+    --text: #c8c8c8;
+    --text-muted: #9b9b9b;
+    --text-secondary: #d1d1d1;
+    --headings: #e0e0e0;
+    --ntuple-color: #6db99a;
+
+    /* Borders. */
+    --border: #2e2e2e;
+    --scrollbar-thumb: #4a4a4a;
+
+    /* Accent: lighter blue for sufficient contrast on dark. */
+    --accent: #6ab0de;
+    --accent-ring: rgba(106, 176, 222, 0.35);
+
+    /* API links + signature box. */
+    --links-api: #7ecfff;
+    --links-api-underline: #7ecfff;
+    --func-sig-bg: #2c2c2c;
+    --func-sig-border: #7ecfff;
+    --func-sig-text: #e0e0e0;
+    --func-sig-name: #e0e0e0;
+    --func-sig-param: #d1d1d1;
+    --surface-raised: #2c2c2c;
+
+    /* Inline code. */
+    --inline-code-bg: rgba(255, 255, 255, 0.08);
+    --inline-code-text: #e6e6e6;
+
+    /* Admonitions: dark mode overrides. */
+    --adm-title: #ddd;
+    --adm-note-bg: #2a2a2a;
+    --adm-note-border: #4a4a4a;
+    --adm-note-accent-border: #6ab0de;
+    --adm-tip-bg: #1a2a1a;
+    --adm-tip-border: #3a6a3a;
+    --adm-tip-icon: #6aba6a;
+    --adm-warning-bg: #472424;
+    --adm-warning-border: #8a3030;
+    --adm-warning-icon: #e08a80;
+    --adm-important-bg: #2a200d;
+    --adm-important-border: #6e5328;
+    --adm-important-icon: #d4a23e;
+    --adm-seealso-bg: #1d2e40;
+    --adm-seealso-border: #2d5280;
+    --adm-seealso-accent-border: #5599cc;
+    --adm-seealso-link: #90c8ee;
+    --adm-seealso-hover: #8bbfe0;
+
+    /* Version directives: dark mode overrides. */
+    --versionadded-color: #5ec46e;
+    --versionchanged-color: #b0873a;
+    --deprecated-color: #d06060;
+
+    /* Tables: dark mode overrides. */
+    --table-header-bg: #2d2d2d;
+    --table-row-odd: #222222;
+    --table-row-even: #272727;
+    --table-border: #424242;
+
+    /* Changelog labels. */
+    --label-critical-bg: rgba(225, 29, 33, 0.16);
+    --label-critical-text: #ff8a8c;
+    --label-critical-border: rgba(225, 29, 33, 0.45);
+    --label-build-fail-bg: rgba(245, 104, 10, 0.14);
+    --label-build-fail-text: #f79f64;
+    --label-build-fail-border: rgba(245, 104, 10, 0.4);
+    --label-memleak-bg: rgba(251, 202, 4, 0.14);
+    --label-memleak-text: #e5b833;
+    --label-memleak-border: rgba(251, 202, 4, 0.4);
+    --label-breaking-bg: rgba(212, 197, 249, 0.14);
+    --label-breaking-text: #cbb9f7;
+    --label-breaking-border: rgba(212, 197, 249, 0.4);
+}
+
+/* ====================================================================== */
+/* Theme transition                                                       */
+/* ====================================================================== */
+
+body,
+.page,
+.article,
+.right-sidebar,
+.right-sidebar-title,
+.topbar,
+.footer,
+.search-page-form,
+ul.search > li,
+.shortcut-flyout-panel {
+    transition:
+        background-color var(--theme-transition),
+        color var(--theme-transition),
+        border-color var(--theme-transition);
+}
+
+.no-transition,
+.no-transition *,
+.no-transition *::before,
+.no-transition *::after {
+    transition: none !important;
+}
+
+/* Honor the OS "reduce motion" setting: drop transitions, animations
+   and smooth scrolling everywhere. */
+@media (prefers-reduced-motion: reduce) {
+    *,
+    *::before,
+    *::after {
+        animation-duration: 0.01ms !important;
+        animation-iteration-count: 1 !important;
+        transition-duration: 0.01ms !important;
+        scroll-behavior: auto !important;
+    }
+}
+
+/* ====================================================================== */
+/* Utilities                                                              */
+/* ====================================================================== */
+
+/* .no-visited: suppresses the browser-default purple ":visited" color */
+.no-visited:visited,
+.no-visited a:visited {
+    color: inherit;
+}
+
+/* Thin, theme-aware scrollbars for every scrollable region (code
+   blocks, the TOC, tables, ...). */
+* {
+    scrollbar-width: thin;
+    scrollbar-color: var(--scrollbar-thumb) transparent;
+}
+
+::-webkit-scrollbar {
+    width: 8px;
+    height: 8px;
+}
+
+::-webkit-scrollbar-thumb {
+    background: var(--scrollbar-thumb);
+    border-radius: 4px;
+}
+
+::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+/* about.html page */
+.about-shot {
+    display: block;
+    max-width: 100%;
+    max-height: 560px;
+    width: auto;
+    height: auto;
+    margin: 0.4em 0 1.4em;
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.08);
+}
+
+/* Two screenshots side by side (light vs dark); wrap on narrow columns. */
+.about-shot-pair {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 12px;
+    margin: 0.4em 0 1.4em;
+}
+
+.about-shot-pair .about-shot {
+    flex: 1 1 240px;
+    min-width: 0;
+    margin: 0;
+}
+
+/* Flash when clicking on a link / anchor */
+@keyframes anchor-flash {
+    from {
+        background-color: var(--accent-ring);
+    }
+}
+
+:target > h1,
+:target > h2,
+:target > h3,
+:target > h4,
+:target > h5,
+:target > h6,
+:target + h1,
+:target + h2,
+:target + h3,
+:target + h4,
+:target + h5,
+:target + h6,
+dt:target {
+    animation: anchor-flash 1.8s ease-out;
+}
+
+/* Keyboard focus ring on interactive controls (both themes). The
+   browser default is nearly invisible on the dark topbar/sidebar. */
+.topbar-link:focus-visible,
+.topbar-btn:focus-visible,
+.topbar-hamburger:focus-visible,
+.topbar-text:focus-visible,
+.topbar-logo:focus-visible,
+.left-sidebar a:focus-visible,
+.right-sidebar a:focus-visible,
+.home-feature-card:focus-visible,
+.home-platform-pill:focus-visible,
+.home-stat:focus-visible,
+.prev-next a:focus-visible,
+.blog-card-title a:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+    border-radius: var(--border-radius);
+}
diff --git a/docs/_static/css/blog.css b/docs/_static/css/blog.css
new file mode 100644
index 0000000000..537ce18d20
--- /dev/null
+++ b/docs/_static/css/blog.css
@@ -0,0 +1,414 @@
+/*
+ * psutil-sphinx-theme: blog sub-site.
+ *
+ * Loaded for every page; rules are scoped to blog pages via
+ * `body:has(.blog-section-banner)` (any page under the blog path
+ * renders the banner) or `.article:has(.post-meta-banner)` (only
+ * blog posts) so non-blog pages stay unaffected.
+ */
+
+/* ---- Tokens ---------------------------------------------------------- */
+
+:root {
+    --font-post-body: "Merriweather", Charter, Georgia, serif;
+    --blog-accent: #9a3412; /* warm rust, editorial */
+    --blog-accent-deep: #7c2d12;
+}
+
+[data-theme="dark"] {
+    --blog-accent: #fb923c;
+    --blog-accent-deep: #fdba74;
+}
+
+/* ---- Section banner (top of every blog page) ------------------------ */
+
+.blog-section-banner {
+    display: flex;
+    align-items: center;
+    gap: 0.7em;
+    flex-wrap: wrap;
+    padding: 0.3em 0;
+    margin: 1.5em 0 0.3em 0;
+    border-bottom: 1px solid var(--border);
+}
+
+@media (min-width: 1280px) {
+    .main:has(.article-with-toc:not(.no-toc)) .blog-section-banner {
+        max-width: calc(100% - var(--right-sidebar-width) - 32px);
+    }
+}
+
+.blog-section-banner .blog-rss {
+    margin-left: auto;
+}
+
+.blog-section-label {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.45em;
+}
+
+.blog-section-icon {
+    grid-area: icon;
+    width: 1.7em;
+    height: 1.7em;
+    color: var(--blog-accent);
+    flex-shrink: 0;
+}
+
+a.blog-section-title,
+a.blog-section-title:visited {
+    grid-area: title;
+    font-size: 1.9em;
+    font-weight: 700;
+    letter-spacing: 0.04em;
+    color: var(--text);
+    text-decoration: none;
+    line-height: 1.1;
+}
+
+a.blog-section-title:hover,
+.blog-card-title a:hover {
+    color: var(--blog-accent);
+    text-decoration: none;
+}
+
+.blog-section-subtitle {
+    grid-area: subtitle;
+    font-size: 0.85em;
+    color: var(--text-muted);
+    opacity: 0.8;
+    margin-top: 0.15em;
+}
+
+/* RSS subscribe button (orange outlined). */
+a.blog-rss,
+a.blog-rss:visited {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.4em;
+    padding: 0.35em 0.75em;
+    background: transparent;
+    color: var(--blog-accent);
+    border: 1px solid var(--blog-accent);
+    border-radius: 4px;
+    text-decoration: none;
+    font-weight: 600;
+    font-size: 0.9em;
+    line-height: 1;
+    flex: 0 0 auto;
+}
+
+a.blog-rss:hover {
+    background: color-mix(in srgb, var(--blog-accent) 12%, transparent);
+    color: var(--blog-accent);
+    text-decoration: none;
+}
+
+.blog-rss-icon {
+    width: 1.1em;
+    height: 1.1em;
+    flex: 0 0 auto;
+    transform: translateY(-0.05em);
+}
+
+/* ---- Blog listing (post cards) -------------------------------------- */
+
+.blog-listing-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 1em;
+    margin-bottom: 1.5em;
+}
+
+.blog-listing-title {
+    font-size: 2.2em;
+    margin: 0;
+}
+
+.blog-listing-title-value,
+.blog-listing-title-value:visited {
+    color: var(--text);
+    font-weight: 500;
+    border-bottom: none;
+    text-decoration: none;
+}
+
+ol.blog-cards {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+}
+
+ol.blog-cards > li.blog-card {
+    list-style: none;
+    margin: 0;
+}
+
+ol.blog-cards > li.blog-card + li.blog-card {
+    border-top: 1px solid var(--border);
+}
+
+.blog-card {
+    display: grid;
+    grid-template-columns: 1fr;
+    grid-template-areas:
+        "date"
+        "title"
+        "summary"
+        "tags";
+    padding: 1.6em 0;
+    margin: 0;
+    background: none;
+    border: none;
+}
+
+.blog-card:first-child {
+    padding-top: 0;
+}
+
+.blog-card-head {
+    display: contents;
+}
+
+.blog-card-meta {
+    grid-area: date;
+    color: color-mix(in srgb, var(--text-muted) 75%, transparent);
+    font-size: 0.78em;
+    font-weight: 400;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    font-variant-numeric: tabular-nums;
+    margin: 0 0 0.05em 0;
+}
+
+.blog-card-comments {
+    letter-spacing: normal;
+}
+
+.blog-card-comments::before {
+    content: "\00b7";
+    margin: 0 0.72em 0 0.6em;
+    letter-spacing: 0.08em;
+}
+
+.blog-card-draft {
+    font-style: italic;
+}
+
+.blog-card-titlerow {
+    grid-area: title;
+    display: flex;
+    align-items: flex-start;
+    justify-content: space-between;
+    gap: 0.75em;
+}
+
+.blog-card .blog-card-title {
+    min-width: 0;
+    font-family: var(--font-body);
+    font-size: 1.3em;
+    font-weight: 700;
+    line-height: 1.3;
+    margin: 0 0 0.4em 0;
+    padding: 0;
+}
+
+.blog-card-title a,
+.blog-card-title a:visited {
+    text-decoration: none;
+    color: var(--text);
+}
+
+/* Match the article banner's effective size (0.78em inside a 0.9em
+   banner = 0.702em) so the listing badge is identical to it. */
+.blog-card-titlerow .post-meta-featured {
+    font-size: 0.702em;
+}
+
+.blog-card-summary {
+    grid-area: summary;
+    color: var(--text-muted);
+    font-family: var(--font-body);
+    font-size: 1.05em;
+    line-height: 1.6;
+    margin: 0.3em 0 0 0;
+}
+
+.blog-card-summary a,
+.blog-card-summary a:visited {
+    color: inherit;
+    text-decoration: none;
+    border-bottom: 1px dotted var(--border);
+}
+
+.blog-card-summary a:hover {
+    color: var(--blog-accent);
+    border-bottom-color: var(--blog-accent);
+    text-decoration: none;
+}
+
+.blog-card-summary code {
+    background: none;
+    border: none;
+    padding: 0;
+    color: inherit;
+    font-size: 0.92em;
+}
+
+.blog-card-summary p:empty {
+    display: none;
+}
+
+.blog-card-summary p {
+    margin: 0;
+}
+
+.blog-card .blog-card-tags {
+    grid-area: tags;
+    justify-self: start;
+    list-style: none;
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.3em;
+    margin: 0.9em 0 0 0;
+    padding-left: 0;
+}
+
+.blog-card-tags li {
+    list-style: none;
+    margin: 0;
+}
+
+/* ---- Post meta banner (date + tags below the H1 of a post) --------- */
+
+.post-meta-banner {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5em;
+    align-items: center;
+    margin: 0 0 2em 0;
+    padding: 0.4em 0 0 0;
+    font-size: 0.9em;
+    color: var(--text-muted);
+}
+
+.post-meta-banner > *:not(:first-child)::before {
+    content: "·";
+    color: var(--text-muted);
+    opacity: 0.6;
+    margin: 0 0.5em 0 0.15em;
+}
+
+.post-meta-featured,
+a.post-meta-featured,
+a.post-meta-featured:visited {
+    padding: 0.15em 0.65em;
+    border-radius: 999px;
+    font-size: 0.78em;
+    font-weight: 600;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+    line-height: 1.6;
+    color: var(--blog-accent);
+    background: color-mix(in srgb, var(--blog-accent) 12%, transparent);
+    border: 1px solid color-mix(in srgb, var(--blog-accent) 28%, transparent);
+    text-decoration: none;
+}
+
+a.post-meta-featured:hover {
+    background: color-mix(in srgb, var(--blog-accent) 22%, transparent);
+    border-color: color-mix(in srgb, var(--blog-accent) 50%, transparent);
+}
+
+.post-meta-author {
+    font-style: italic;
+}
+
+.post-meta-date,
+.post-meta-readtime {
+    font-variant-numeric: tabular-nums;
+}
+
+.post-meta-tags {
+    display: inline-flex;
+    flex-wrap: wrap;
+    gap: 0.3em;
+    align-items: center;
+}
+
+/* Shared tag-pill style: card listing + post banner. */
+.post-meta-tags a,
+.post-meta-tags a:visited,
+.blog-card-tags a,
+.blog-card-tags a:visited {
+    display: inline-block;
+    padding: 0.05em 0.55em;
+    border-radius: 999px;
+    font-size: 0.82em;
+    line-height: 1.6;
+    color: var(--text-muted);
+    background: color-mix(in srgb, var(--text-muted) 7%, transparent);
+    text-decoration: none;
+}
+
+.post-meta-tags a:hover,
+.blog-card-tags a:hover {
+    color: var(--blog-accent);
+    background: color-mix(in srgb, var(--blog-accent) 10%, transparent);
+    text-decoration: none;
+}
+
+/* ---- Blog post body: switch to serif typography -------------------- */
+
+.article:has(.post-meta-banner) p,
+.article:has(.post-meta-banner) li,
+.article:has(.post-meta-banner) blockquote,
+.article:has(.post-meta-banner) dd {
+    font-family: var(--font-post-body);
+    line-height: 1.75;
+}
+
+.article:has(.post-meta-banner) h1 {
+    font-size: 2.1em;
+    line-height: 1.25;
+    margin-bottom: 0.4em;
+}
+
+.article:has(.post-meta-banner) h2 {
+    font-size: 1.5em;
+    line-height: 1.3;
+    margin-top: 1.8em;
+    padding-top: 0.5em;
+}
+
+.article:has(.post-meta-banner) h3 {
+    font-size: 1.2em;
+    line-height: 1.35;
+    margin-top: 1.5em;
+}
+
+/* GitHub-style blockquotes inside posts. */
+.article:has(.post-meta-banner) blockquote {
+    margin: 1em 0;
+    padding: 0 1em;
+    border-left: 0.25em solid var(--border);
+    color: var(--text-muted);
+    background: transparent;
+    font-style: normal;
+}
+
+.article:has(.post-meta-banner) blockquote p {
+    margin: 0.5em 0;
+}
+
+/* ---- Blog-scoped accent: redefine the link tokens inside the blog
+   sub-site so every link picks up the rust hue without needing
+   per-element overrides. */
+
+body:has(.blog-section-banner) {
+    --accent: var(--blog-accent);
+    --links-api: var(--blog-accent-deep);
+    --links-api-underline: var(--blog-accent-deep);
+}
diff --git a/docs/_static/css/changelog.css b/docs/_static/css/changelog.css
new file mode 100644
index 0000000000..d874ee5134
--- /dev/null
+++ b/docs/_static/css/changelog.css
@@ -0,0 +1,52 @@
+/*
+ * psutil-sphinx-theme: changelog labels (:label:`critical` & co).
+ */
+
+.cl-label {
+    display: inline-block;
+    padding: 0 7px;
+    border: 1px solid transparent;
+    border-radius: 999px;
+    font-family: var(--font-body);
+    font-size: 0.72em;
+    font-weight: 700;
+    letter-spacing: 0.04em;
+    text-transform: uppercase;
+    line-height: 1.7;
+    white-space: nowrap;
+    vertical-align: 1px;
+}
+
+.cl-label-critical {
+    background: var(--label-critical-bg);
+    color: var(--label-critical-text);
+    border-color: var(--label-critical-border);
+}
+
+.cl-label-breaking {
+    background: var(--label-breaking-bg);
+    color: var(--label-breaking-text);
+    border-color: var(--label-breaking-border);
+}
+
+.cl-label-build-fail {
+    background: var(--label-build-fail-bg);
+    color: var(--label-build-fail-text);
+    border-color: var(--label-build-fail-border);
+}
+
+.cl-label-memleak {
+    background: var(--label-memleak-bg);
+    color: var(--label-memleak-text);
+    border-color: var(--label-memleak-border);
+}
+
+/* Printers drop backgrounds, which would leave the white text of
+   .cl-label-critical invisible. */
+@media print {
+    .cl-label {
+        background: none !important;
+        color: #000 !important;
+        border-color: #666 !important;
+    }
+}
diff --git a/docs/_static/css/code.css b/docs/_static/css/code.css
new file mode 100644
index 0000000000..28113a1b16
--- /dev/null
+++ b/docs/_static/css/code.css
@@ -0,0 +1,234 @@
+/*
+   Styles for code blocks: Pygments syntax highlighting (Monokai for
+   dark mode, custom palette for light).
+*/
+
+/* ================================================================== */
+/* Imported Monokai rules                                             */
+/* ================================================================== */
+
+[data-theme="dark"] .highlight          { color: #F8F8F2; }
+[data-theme="dark"] .highlight .hll     { background-color: #49483e; }
+[data-theme="dark"] .highlight .c       { color: #959077; }  /* Comment */
+[data-theme="dark"] .highlight .err     { color: #ED007E; background-color: #1E0010; }  /* Error */
+[data-theme="dark"] .highlight .esc     { color: #F8F8F2; }  /* Escape */
+[data-theme="dark"] .highlight .g       { color: #F8F8F2; }  /* Generic */
+[data-theme="dark"] .highlight .k       { color: #66D9EF; }  /* Keyword */
+[data-theme="dark"] .highlight .l       { color: #AE81FF; }  /* Literal */
+[data-theme="dark"] .highlight .n       { color: #F8F8F2; }  /* Name */
+[data-theme="dark"] .highlight .o       { color: #F8F8F2; }  /* Operator */
+[data-theme="dark"] .highlight .x       { color: #F8F8F2; }  /* Other */
+[data-theme="dark"] .highlight .p       { color: #F8F8F2; }  /* Punctuation */
+[data-theme="dark"] .highlight .ch      { color: #959077; }  /* Comment.Hashbang */
+[data-theme="dark"] .highlight .cm      { color: #959077; }  /* Comment.Multiline */
+[data-theme="dark"] .highlight .cp      { color: #959077; }  /* Comment.Preproc */
+[data-theme="dark"] .highlight .cpf     { color: #959077; }  /* Comment.PreprocFile */
+[data-theme="dark"] .highlight .c1      { color: #959077; }  /* Comment.Single */
+[data-theme="dark"] .highlight .cs      { color: #959077; }  /* Comment.Special */
+[data-theme="dark"] .highlight .gd      { color: #FF4689; }  /* Generic.Deleted */
+[data-theme="dark"] .highlight .ge      { color: #F8F8F2; font-style: italic; }  /* Generic.Emph */
+[data-theme="dark"] .highlight .ges     { color: #F8F8F2; font-weight: bold; font-style: italic; }  /* Generic.EmphStrong */
+[data-theme="dark"] .highlight .gr      { color: #F8F8F2; }  /* Generic.Error */
+[data-theme="dark"] .highlight .gh      { color: #F8F8F2; }  /* Generic.Heading */
+[data-theme="dark"] .highlight .gi      { color: #9ccfa5; }  /* Generic.Inserted */
+/* .go, .gp: overridden in the REPL theme sections below */
+[data-theme="dark"] .highlight .gs      { color: #F8F8F2; font-weight: bold; }  /* Generic.Strong */
+[data-theme="dark"] .highlight .gu      { color: #959077; }  /* Generic.Subheading */
+[data-theme="dark"] .highlight .gt      { color: #F8F8F2; }  /* Generic.Traceback */
+[data-theme="dark"] .highlight .kc      { color: #66D9EF; }  /* Keyword.Constant */
+[data-theme="dark"] .highlight .kd      { color: #66D9EF; }  /* Keyword.Declaration */
+[data-theme="dark"] .highlight .kn      { color: #FF4689; }  /* Keyword.Namespace */
+[data-theme="dark"] .highlight .kp      { color: #66D9EF; }  /* Keyword.Pseudo */
+[data-theme="dark"] .highlight .kr      { color: #66D9EF; }  /* Keyword.Reserved */
+[data-theme="dark"] .highlight .kt      { color: #66D9EF; }  /* Keyword.Type */
+[data-theme="dark"] .highlight .ld      { color: #d8c88a; }  /* Literal.Date */
+[data-theme="dark"] .highlight .m       { color: #b9a5e0; }  /* Literal.Number */
+[data-theme="dark"] .highlight .s       { color: #d8c88a; }  /* Literal.String */
+[data-theme="dark"] .highlight .na      { color: #9ccfa5; }  /* Name.Attribute */
+[data-theme="dark"] .highlight .nb      { color: #F8F8F2; }  /* Name.Builtin */
+[data-theme="dark"] .highlight .nc      { color: #9ccfa5; }  /* Name.Class */
+[data-theme="dark"] .highlight .no      { color: #66D9EF; }  /* Name.Constant */
+[data-theme="dark"] .highlight .nd      { color: #9ccfa5; }  /* Name.Decorator */
+[data-theme="dark"] .highlight .ni      { color: #F8F8F2; }  /* Name.Entity */
+[data-theme="dark"] .highlight .ne      { color: #9ccfa5; }  /* Name.Exception */
+[data-theme="dark"] .highlight .nf      { color: #9ccfa5; }  /* Name.Function */
+[data-theme="dark"] .highlight .nl      { color: #F8F8F2; }  /* Name.Label */
+[data-theme="dark"] .highlight .nn      { color: #F8F8F2; }  /* Name.Namespace */
+[data-theme="dark"] .highlight .nx      { color: #9ccfa5; }  /* Name.Other */
+[data-theme="dark"] .highlight .py      { color: #F8F8F2; }  /* Name.Property */
+[data-theme="dark"] .highlight .nt      { color: #FF4689; }  /* Name.Tag */
+[data-theme="dark"] .highlight .nv      { color: #F8F8F2; }  /* Name.Variable */
+[data-theme="dark"] .highlight .ow      { color: #66D9EF; }  /* Operator.Word */
+[data-theme="dark"] .highlight .pm      { color: #F8F8F2; }  /* Punctuation.Marker */
+[data-theme="dark"] .highlight .w       { color: #F8F8F2; }  /* Text.Whitespace */
+[data-theme="dark"] .highlight .mb      { color: #b9a5e0; }  /* Literal.Number.Bin */
+[data-theme="dark"] .highlight .mf      { color: #b9a5e0; }  /* Literal.Number.Float */
+[data-theme="dark"] .highlight .mh      { color: #b9a5e0; }  /* Literal.Number.Hex */
+[data-theme="dark"] .highlight .mi      { color: #b9a5e0; }  /* Literal.Number.Integer */
+[data-theme="dark"] .highlight .mo      { color: #b9a5e0; }  /* Literal.Number.Oct */
+[data-theme="dark"] .highlight .sa      { color: #d8c88a; }  /* Literal.String.Affix */
+[data-theme="dark"] .highlight .sb      { color: #d8c88a; }  /* Literal.String.Backtick */
+[data-theme="dark"] .highlight .sc      { color: #d8c88a; }  /* Literal.String.Char */
+[data-theme="dark"] .highlight .dl      { color: #d8c88a; }  /* Literal.String.Delimiter */
+[data-theme="dark"] .highlight .sd      { color: #d8c88a; }  /* Literal.String.Doc */
+[data-theme="dark"] .highlight .s2      { color: #d8c88a; }  /* Literal.String.Double */
+[data-theme="dark"] .highlight .se      { color: #AE81FF; }  /* Literal.String.Escape */
+[data-theme="dark"] .highlight .sh      { color: #d8c88a; }  /* Literal.String.Heredoc */
+[data-theme="dark"] .highlight .si      { color: #d8c88a; }  /* Literal.String.Interpol */
+[data-theme="dark"] .highlight .sx      { color: #d8c88a; }  /* Literal.String.Other */
+[data-theme="dark"] .highlight .sr      { color: #d8c88a; }  /* Literal.String.Regex */
+[data-theme="dark"] .highlight .s1      { color: #d8c88a; }  /* Literal.String.Single */
+[data-theme="dark"] .highlight .ss      { color: #d8c88a; }  /* Literal.String.Symbol */
+[data-theme="dark"] .highlight .bp      { color: #F8F8F2; }  /* Name.Builtin.Pseudo */
+[data-theme="dark"] .highlight .fm      { color: #9ccfa5; }  /* Name.Function.Magic */
+[data-theme="dark"] .highlight .vc      { color: #F8F8F2; }  /* Name.Variable.Class */
+[data-theme="dark"] .highlight .vg      { color: #F8F8F2; }  /* Name.Variable.Global */
+[data-theme="dark"] .highlight .vi      { color: #F8F8F2; }  /* Name.Variable.Instance */
+[data-theme="dark"] .highlight .vm      { color: #F8F8F2; }  /* Name.Variable.Magic */
+[data-theme="dark"] .highlight .il      { color: #b9a5e0; }  /* Literal.Number.Integer.Long */
+
+/* layout */
+div[class^="highlight-"] {
+    border-radius: var(--border-radius-code);
+    background: transparent;
+}
+
+/* Padding: applied to the wrapper, none on the inner pre so we don't
+   double up margins or shrink the scrollbar area. */
+.highlight {
+    padding: 12px 14px;
+    overflow-x: auto;
+}
+
+.highlight pre {
+    padding: 0;
+    margin: 0;
+}
+
+/* font */
+.highlight,
+.highlight pre {
+    font-size: 13px !important;
+    font-family: var(--code-font) !important;
+}
+
+/* REPL >>> prompt */
+.highlight .gp {
+    font-weight: normal;
+    font-style: normal;
+}
+
+  /* REPL output */
+.highlight .go {
+    font-weight: normal;
+    font-style: normal;
+}
+
+.highlight pre {
+    line-height: var(--code-line-height) !important;
+}
+
+/* background */
+[data-theme="light"] .highlight {
+    background: #eef1f4 !important;
+    border: 1px solid #c7ccd1;
+    border-radius: var(--border-radius-code);
+}
+
+[data-theme="dark"]  .highlight {
+    background: #262626 !important;
+    border: 1px solid #3a3a3a;
+    border-radius: var(--border-radius-code);
+}
+
+.highlight .k      { font-weight:normal; font-style: normal !important;}  /* keyword */
+.highlight .p      { font-weight:normal; }  /* (, [, ], )*/
+.highlight .mi     { font-weight:normal; }  /* numbers */
+.highlight .mf     { font-weight:normal; }  /* floats */
+
+/* Avoiod != → ≠, <= → ≤, etc.. */
+.highlight,
+.highlight pre,
+code,
+pre,
+kbd,
+samp,
+tt {
+    font-variant-ligatures: none;
+}
+
+/* ----------------- REPL light theme ---------------- */
+
+[data-theme="light"] .highlight-pycon .pycon-number { color:  #204A87; }
+[data-theme="light"] .highlight-pycon .pycon-string { color: #8a5a2d; }
+[data-theme="light"] .highlight .s,
+[data-theme="light"] .highlight .s1,
+[data-theme="light"] .highlight .s2,
+[data-theme="light"] .highlight .sa,
+[data-theme="light"] .highlight .sb,
+[data-theme="light"] .highlight .sc,
+[data-theme="light"] .highlight .dl,
+[data-theme="light"] .highlight .sd,
+[data-theme="light"] .highlight .sh,
+[data-theme="light"] .highlight .si,
+[data-theme="light"] .highlight .sx,
+[data-theme="light"] .highlight .sr,
+[data-theme="light"] .highlight .ss,
+[data-theme="light"] .highlight .se   { color: #4f6b39; }  /* strings: muted olive */
+[data-theme="light"] .highlight-pycon .pycon-field  { color: #4d4d4d; background: #eff1f3}
+[data-theme="light"] .highlight .gp                 { color: #6a6a6a; }  /* >>> prompt: muted */
+[data-theme="light"] .highlight .c,
+[data-theme="light"] .highlight .ch,
+[data-theme="light"] .highlight .cm,
+[data-theme="light"] .highlight .cp,
+[data-theme="light"] .highlight .cpf,
+[data-theme="light"] .highlight .c1,
+[data-theme="light"] .highlight .cs  { color: #5b636d; font-style: normal; }  /* comments: muted gray */
+[data-theme="light"] .highlight .go                 { color: #6a6a6a; }  /* output dimmer than code */
+
+/* ----------------- REPL dark theme ---------------- */
+
+[data-theme="dark"]  .highlight-pycon .pycon-number { color: #b9a5e0; }
+[data-theme="dark"]  .highlight-pycon .pycon-string { color: #d8c88a; }
+[data-theme="dark"]  .highlight-pycon .pycon-field  { color: #9ccfa5; }
+[data-theme="dark"]  .highlight .gp                 { color: #888888; }  /* >>> prompt */
+[data-theme="dark"]  .highlight .go                 { color: #6c7a88; }  /* output dimmer than code */
+
+/* ----------------- syntax highlight ---------------- */
+
+[data-theme="dark"] .highlight .k                 { color: #f56b8b}  /* keyword */
+[data-theme="dark"] .highlight .kn                 { color: #f56b8b}  /* keyword.namespace */
+
+/* --------------------------------------------------- */
+
+[data-theme="light"] .highlight .mi                 { color: #204A87}  /* numbers */
+[data-theme="light"] .highlight .nf                 { color: #A31515}  /* functions */
+[data-theme="light"] .highlight .o                  { color: inherit; font-weight: normal; }  /* operators  */
+
+/* ================================================================== */
+/* sphinx-codeautolink (makes APIs in code blocks clickable)          */
+/* ================================================================== */
+
+a.sphinx-codeautolink-a,
+a.sphinx-codeautolink-a:visited {
+    color: inherit;
+    text-decoration: none;
+    border-bottom: none;
+    border-radius: 3px;
+    transition: background var(--theme-transition),
+                color var(--theme-transition),
+                box-shadow var(--theme-transition);
+}
+
+a.sphinx-codeautolink-a:hover {
+    color: var(--links);
+    background: color-mix(in srgb, var(--links) 18%, transparent);
+    box-shadow: 0 0 0 2px color-mix(in srgb, var(--links) 18%, transparent);
+    text-decoration: none;
+    border-bottom: none;
+}
+
+[data-theme="dark"] a.sphinx-codeautolink-a:hover {
+    background: color-mix(in srgb, var(--links) 45%, transparent);
+    box-shadow: 0 0 0 2px color-mix(in srgb, var(--links) 45%, transparent);
+}
diff --git a/docs/_static/css/comments.css b/docs/_static/css/comments.css
new file mode 100644
index 0000000000..ef8d0762be
--- /dev/null
+++ b/docs/_static/css/comments.css
@@ -0,0 +1,23 @@
+/* Blog comments (giscus), below the prev/next nav. */
+
+.comments {
+    margin-top: 2em;
+    padding-top: 1em;
+    border-top: 1px solid var(--border);
+}
+
+.comments h2 {
+    margin-top: 0;
+    margin-bottom: 0.8em;
+    font-size: 1.3em;
+    color: var(--headings);
+    font-weight: 600;
+}
+
+/* giscus sizes its own iframe; just keep it inside the column. */
+.comments .giscus,
+.comments iframe.giscus-frame {
+    width: 100%;
+    max-width: 100%;
+    border: none;
+}
diff --git a/docs/_static/css/copy-page.css b/docs/_static/css/copy-page.css
new file mode 100644
index 0000000000..9aebeacd09
--- /dev/null
+++ b/docs/_static/css/copy-page.css
@@ -0,0 +1,107 @@
+/* "Copy page" button appended to the h1 by js/copy-page.js. */
+
+.article h1:has(button.copy-page) {
+    display: flex;
+    align-items: center;
+    flex-wrap: wrap;
+}
+
+.article h1 button.copy-page {
+    margin-left: auto;
+    display: inline-flex;
+    align-items: center;
+    gap: 5px;
+    padding: 3px 8px;
+    border: 1px solid var(--border);
+    border-radius: 5px;
+    background: transparent;
+    color: var(--text-muted);
+    font-family: inherit;
+    font-size: 0.34em;
+    font-weight: 400;
+    line-height: 1.5;
+    letter-spacing: 0.01em;
+    white-space: nowrap;
+    cursor: pointer;
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.06);
+    transition:
+        background 0.15s,
+        color 0.15s,
+        border-color 0.15s,
+        box-shadow 0.15s;
+}
+
+.article h1 button.copy-page:focus {
+    outline: none;
+}
+
+.article h1 button.copy-page:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+}
+
+.article h1 button.copy-page:hover {
+    background: var(--bg-hover);
+    border-color: var(--text-muted);
+    color: var(--text);
+    box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
+}
+
+.copy-page-icons {
+    display: inline-grid;
+    place-items: center;
+}
+
+.copy-page-icon-copy,
+.copy-page-icon-check {
+    grid-area: 1 / 1;
+}
+
+.copy-page-icon-check {
+    visibility: hidden;
+    color: #2e9e4f;
+}
+
+.copy-page.copied .copy-page-icon-copy {
+    visibility: hidden;
+}
+
+.copy-page.copied .copy-page-icon-check {
+    visibility: visible;
+}
+
+.copy-page.failed .copy-page-icon-copy {
+    color: #c0392b;
+}
+
+.copy-page-labels {
+    display: inline-grid;
+    place-items: center start;
+}
+
+.copy-page-label-copy,
+.copy-page-label-done {
+    grid-area: 1 / 1;
+}
+
+.copy-page-label-done {
+    visibility: hidden;
+}
+
+.copy-page.copied .copy-page-label-copy {
+    visibility: hidden;
+}
+
+.copy-page.copied .copy-page-label-done {
+    visibility: visible;
+}
+
+@media (max-width: 600px) {
+    .article h1 button.copy-page .copy-page-labels {
+        display: none;
+    }
+
+    .article h1 button.copy-page {
+        padding: 3px 6px;
+    }
+}
diff --git a/docs/_static/css/doc-icons.css b/docs/_static/css/doc-icons.css
new file mode 100644
index 0000000000..57b2812a5b
--- /dev/null
+++ b/docs/_static/css/doc-icons.css
@@ -0,0 +1,130 @@
+/* Left sidebar menu icons. Also shared with search results. */
+
+/* Documentation */
+a[href*="install/"],
+ul.search > li:has(> a[href*="install/"]),
+body[data-page="install"] .left-sidebar a.current {
+    --doc-icon: "\f019";
+}
+
+a[href*="api-overview/"],
+ul.search > li:has(> a[href*="api-overview/"]),
+body[data-page="api-overview"] .left-sidebar a.current {
+    --doc-icon: "\f14e";
+}
+
+a[href*="api/"],
+ul.search > li:has(> a[href*="api/"]),
+body[data-page="api"] .left-sidebar a.current {
+    --doc-icon: "\f121";
+}
+
+a[href*="faq/"],
+ul.search > li:has(> a[href*="faq/"]),
+body[data-page="faq"] .left-sidebar a.current {
+    --doc-icon: "\3f";
+}
+
+a[href*="performance/"],
+ul.search > li:has(> a[href*="performance/"]),
+body[data-page="performance"] .left-sidebar a.current {
+    --doc-icon: "\f0e7";
+}
+
+a[href*="recipes/"],
+ul.search > li:has(> a[href*="recipes/"]),
+body[data-page="recipes"] .left-sidebar a.current {
+    --doc-icon: "\f2e7";
+}
+
+/* Reference */
+a[href*="shell-equivalents/"],
+ul.search > li:has(> a[href*="shell-equivalents/"]),
+body[data-page="shell-equivalents"] .left-sidebar a.current {
+    --doc-icon: "\f120";
+}
+
+a[href*="stdlib-equivalents/"],
+ul.search > li:has(> a[href*="stdlib-equivalents/"]),
+body[data-page="stdlib-equivalents"] .left-sidebar a.current {
+    --doc-icon: "\f3e2";
+    --doc-icon-font: var(--fa-family-brands);
+    --doc-icon-weight: 400;
+}
+
+a[href*="glossary/"],
+ul.search > li:has(> a[href*="glossary/"]),
+body[data-page="glossary"] .left-sidebar a.current {
+    --doc-icon: "\f031";
+}
+
+a[href*="platform/"],
+ul.search > li:has(> a[href*="platform/"]),
+body[data-page="platform"] .left-sidebar a.current {
+    --doc-icon: "\f5fd";
+}
+
+a[href*="migration/"],
+ul.search > li:has(> a[href*="migration/"]),
+body[data-page="migration"] .left-sidebar a.current {
+    --doc-icon: "\f362";
+}
+
+/* About */
+a[href*="adoption/"],
+ul.search > li:has(> a[href*="adoption/"]),
+body[data-page="adoption"] .left-sidebar a.current {
+    --doc-icon: "\f0c0";
+}
+
+a[href*="alternatives/"],
+ul.search > li:has(> a[href*="alternatives/"]),
+body[data-page="alternatives"] .left-sidebar a.current {
+    --doc-icon: "\e13a";
+}
+
+a[href*="funding/"],
+ul.search > li:has(> a[href*="funding/"]),
+body[data-page="funding"] .left-sidebar a.current {
+    --doc-icon: "\f4be";
+}
+
+a[href*="credits/"],
+ul.search > li:has(> a[href*="credits/"]),
+body[data-page="credits"] .left-sidebar a.current {
+    --doc-icon: "\f559";
+}
+
+/* Project */
+a[href*="blog/"],
+ul.search > li:has(> a[href*="blog/"]),
+ul.search > li:has(> a[href^="blog/"]),
+ul.search > li:has(> a[href*="/blog/"]),
+body[data-page="blog"] .left-sidebar a.current,
+body[data-page^="blog/"] .left-sidebar li.toctree-l1 > a[href$="../"] {
+    --doc-icon: "\f09e";
+}
+
+a[href*="changelog/"],
+ul.search > li:has(> a[href*="changelog/"]),
+body[data-page="changelog"] .left-sidebar a.current {
+    --doc-icon: "\f1da";
+}
+
+a[href*="timeline/"],
+ul.search > li:has(> a[href*="timeline/"]),
+body[data-page="timeline"] .left-sidebar a.current {
+    --doc-icon: "\e29c";
+}
+
+a[href*="devguide/"],
+ul.search > li:has(> a[href*="devguide/"]),
+body[data-page="devguide"] .left-sidebar a.current {
+    --doc-icon: "\f7d9";
+}
+
+a[href*="genindex/"],
+ul.search > li:has(> a[href*="genindex/"]),
+body[data-page="genindex"] .left-sidebar a.current {
+    --doc-icon: "\f15d";
+}
diff --git a/docs/_static/css/fontawesome.css b/docs/_static/css/fontawesome.css
new file mode 100644
index 0000000000..48ca3d60fe
--- /dev/null
+++ b/docs/_static/css/fontawesome.css
@@ -0,0 +1,101 @@
+/*
+ * FontAwesome 7.2.0, subset to the glyphs this theme actually uses
+ * (see _static/fonts/fa-*-subset.woff2). Don't depend on a third-party
+ * CDN. FontAwesome Free is CC BY 4.0 / SIL OFL 1.1.
+ */
+
+@font-face {
+    font-family: "Font Awesome 7 Free";
+    font-style: normal;
+    font-weight: 900;
+    font-display: block;
+    src: url(../fonts/fa-solid-subset.woff2) format("woff2");
+}
+
+@font-face {
+    font-family: "Font Awesome 7 Free";
+    font-style: normal;
+    font-weight: 400;
+    font-display: block;
+    src: url(../fonts/fa-regular-subset.woff2) format("woff2");
+}
+
+@font-face {
+    font-family: "Font Awesome 7 Brands";
+    font-style: normal;
+    font-weight: 400;
+    font-display: block;
+    src: url(../fonts/fa-brands-subset.woff2) format("woff2");
+}
+
+/* Family-name vars consumed by doc-icons.css / left-sidebar.css. */
+:root {
+    --fa-family-classic: "Font Awesome 7 Free";
+    --fa-family-brands: "Font Awesome 7 Brands";
+}
+
+/* Base icon rendering (replaces FontAwesome's core rules). */
+.fa-solid,
+.fa-regular,
+.fa-brands {
+    display: inline-block;
+    font-style: normal;
+    font-variant: normal;
+    line-height: 1;
+    text-rendering: auto;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+}
+
+.fa-solid {
+    font-family: "Font Awesome 7 Free";
+    font-weight: 900;
+}
+
+.fa-regular {
+    font-family: "Font Awesome 7 Free";
+    font-weight: 400;
+}
+
+.fa-brands {
+    font-family: "Font Awesome 7 Brands";
+    font-weight: 400;
+}
+
+/* Glyphs referenced by class (the doc-icons set their codepoint via
+   --doc-icon and don't need entries here). */
+.fa-bars::before {
+    content: "\f0c9";
+}
+
+.fa-chevron-up::before {
+    content: "\f077";
+}
+
+.fa-tag::before {
+    content: "\f02b";
+}
+
+.fa-list-ul::before {
+    content: "\f0ca";
+}
+
+.fa-magnifying-glass::before {
+    content: "\f002";
+}
+
+.fa-sun::before {
+    content: "\f185";
+}
+
+.fa-moon::before {
+    content: "\f186";
+}
+
+.fa-github::before {
+    content: "\f09b";
+}
+
+.fa-python::before {
+    content: "\f3e2";
+}
diff --git a/docs/_static/css/fonts.css b/docs/_static/css/fonts.css
new file mode 100644
index 0000000000..3e3f49a921
--- /dev/null
+++ b/docs/_static/css/fonts.css
@@ -0,0 +1,87 @@
+/*
+ * Self-hosted web fonts (latin subset). Replaces the Google Fonts
+ * CDN so the docs render correctly without reaching Google (blocked
+ * in mainland China) and without leaking visitor IPs. OFL-1.1; see
+ * _static/fonts/LICENSE.txt.
+ */
+
+@font-face {
+    font-family: 'Inter';
+    font-style: normal;
+    font-weight: 400;
+    font-display: swap;
+    src: url(../fonts/inter-400.woff2) format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+    font-family: 'Inter';
+    font-style: normal;
+    font-weight: 500;
+    font-display: swap;
+    src: url(../fonts/inter-500.woff2) format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+    font-family: 'Inter';
+    font-style: normal;
+    font-weight: 600;
+    font-display: swap;
+    src: url(../fonts/inter-600.woff2) format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+    font-family: 'Inter';
+    font-style: normal;
+    font-weight: 700;
+    font-display: swap;
+    src: url(../fonts/inter-700.woff2) format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+    font-family: 'JetBrains Mono';
+    font-style: normal;
+    font-weight: 400;
+    font-display: swap;
+    src: url(../fonts/jetbrains-mono-400.woff2) format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+    font-family: 'JetBrains Mono';
+    font-style: normal;
+    font-weight: 600;
+    font-display: swap;
+    src: url(../fonts/jetbrains-mono-600.woff2) format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+    font-family: 'Merriweather';
+    font-style: italic;
+    font-weight: 400;
+    font-display: swap;
+    src: url(../fonts/merriweather-400-italic.woff2) format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+    font-family: 'Merriweather';
+    font-style: normal;
+    font-weight: 400;
+    font-display: swap;
+    src: url(../fonts/merriweather-400.woff2) format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+
+@font-face {
+    font-family: 'Merriweather';
+    font-style: normal;
+    font-weight: 700;
+    font-display: swap;
+    src: url(../fonts/merriweather-700.woff2) format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
diff --git a/docs/_static/css/footer.css b/docs/_static/css/footer.css
new file mode 100644
index 0000000000..42992bd092
--- /dev/null
+++ b/docs/_static/css/footer.css
@@ -0,0 +1,121 @@
+/* Footer sits in the content column (grid col 2) of .page, below the
+   main row. Padding matches .main so it lines up with the article. */
+.footer {
+    grid-column: 2;
+    margin-top: 0.5em;
+    padding: 1em 24px 16px;
+    border-top: 1px solid var(--border);
+}
+
+/* Mobile: single-column grid, so the footer is in column 1. */
+@media (max-width: 1024px) {
+    .footer {
+        grid-column: 1;
+        padding: 1em 16px 16px;
+    }
+}
+
+.footer-content {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+}
+
+.footer-text {
+    color: var(--text-muted);
+    line-height: 1.4;
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.3em 0.7em;
+}
+
+/* Middot between items, attached to each item except the last so a
+   wrapped row never starts with an orphan separator. */
+.footer-text > span:not(:last-child)::after {
+    content: "·";
+    margin-left: 0.7em;
+    color: var(--text-muted);
+    opacity: 0.7;
+}
+
+.footer-text a,
+.footer-text a:visited {
+    color: var(--text-muted);
+    text-decoration: underline;
+    text-decoration-color: var(--border);
+    text-underline-offset: 3px;
+}
+
+.footer-text a:hover {
+    color: var(--accent);
+    text-decoration-color: currentColor;
+}
+
+/* Easter egg: the © symbol links to the 404 page. No underline. */
+.footer-text a.footer-egg,
+.footer-text a.footer-egg:visited {
+    color: inherit;
+    text-decoration: none;
+}
+
+/* PyPI + RSS icon links, grouped at the right of the footer row. */
+.footer-icons {
+    margin-left: auto;
+    display: inline-flex;
+    align-items: center;
+    gap: 14px;
+    flex-shrink: 0;
+}
+
+.footer-pypi,
+.footer-pypi:visited,
+.footer-github,
+.footer-github:visited,
+.footer-rss,
+.footer-rss:visited {
+    display: inline-flex;
+    align-items: center;
+    color: var(--text-muted);
+    text-decoration: none;
+    opacity: 0.75;
+    transition: opacity 0.15s ease, color 0.15s ease;
+}
+
+/* FontAwesome glyphs, sized to roughly match the RSS icon. The python
+   logo's ink is shorter than the others, so nudge it up to match. */
+.footer-github {
+    font-size: 1.3em;
+}
+
+.footer-pypi {
+    font-size: 1.4em;
+}
+
+.footer-rss {
+    font-size: 0.9em;
+}
+
+.footer-pypi:hover,
+.footer-github:hover,
+.footer-rss:hover {
+    color: var(--accent);
+    opacity: 1;
+}
+
+.footer-text a.footer-egg:hover {
+    color: var(--accent);
+}
+
+/* RSS glyph from a single svg file, colored via mask so it follows
+   currentColor (muted, accent on hover). Shared with the blog banner. */
+.rss-icon {
+    display: inline-block;
+    background-color: currentColor;
+    -webkit-mask: url(../images/rss.svg) center / contain no-repeat;
+    mask: url(../images/rss.svg) center / contain no-repeat;
+}
+
+.footer-rss .rss-icon {
+    width: 1.4em;
+    height: 1.4em;
+}
diff --git a/docs/_static/css/giscus.css b/docs/_static/css/giscus.css
new file mode 100644
index 0000000000..7b0286fc0c
--- /dev/null
+++ b/docs/_static/css/giscus.css
@@ -0,0 +1,131 @@
+/*
+ * Giscus widget theme.
+ */
+
+@import url("https://giscus.app/themes/light.css")
+    screen and (prefers-color-scheme: light);
+@import url("https://giscus.app/themes/dark.css")
+    screen and (prefers-color-scheme: dark);
+
+main {
+    --color-canvas-default: #ffffff;
+    --color-canvas-overlay: #ffffff;
+    --color-canvas-subtle: #f0f4f7;
+    --color-canvas-inset: #f0f4f7;
+
+    --color-fg-default: #404040;
+    --color-fg-muted: #555555;
+    --color-fg-subtle: #555555;
+
+    --color-border-default: #dddddd;
+    --color-border-muted: #dddddd;
+
+    --color-accent-fg: #2371a8;
+    --color-accent-emphasis: #2371a8;
+
+    --color-btn-text: #404040;
+    --color-btn-bg: #f0f4f7;
+    --color-btn-border: #dddddd;
+    --color-btn-hover-bg: #e5ebf0;
+
+    /* The "Comment" button, green by default. */
+    --color-btn-primary-bg: #2371a8;
+    --color-btn-primary-hover-bg: #1d5f8e;
+    --color-btn-primary-disabled-bg: #a9c8dd;
+    --color-btn-primary-border: #2371a8;
+    --color-btn-primary-text: #ffffff;
+}
+
+@media (prefers-color-scheme: dark) {
+    main {
+        --color-canvas-default: #1a1a1a;
+        --color-canvas-overlay: #1a1a1a;
+        --color-canvas-subtle: #2c2c2c;
+        --color-canvas-inset: #2c2c2c;
+
+        --color-fg-default: #c8c8c8;
+        --color-fg-muted: #9b9b9b;
+        --color-fg-subtle: #9b9b9b;
+
+        --color-border-default: #2e2e2e;
+        --color-border-muted: #2e2e2e;
+
+        --color-accent-fg: #6ab0de;
+        --color-accent-emphasis: #6ab0de;
+
+        --color-btn-text: #c8c8c8;
+        --color-btn-bg: #2c2c2c;
+        --color-btn-border: #2e2e2e;
+        --color-btn-hover-bg: #383838;
+
+        --color-btn-primary-hover-bg: #2a83c2;
+        --color-btn-primary-disabled-bg: #2c4a5e;
+    }
+}
+
+main .gsc-reactions {
+    flex-direction: row;
+    align-items: center;
+    justify-content: flex-start;
+    gap: 0.5rem;
+}
+
+main .gsc-reactions-count,
+main .gsc-comments-count {
+    margin: 0;
+    font-size: 0.85rem;
+    font-weight: 400;
+    text-align: left;
+    color: var(--color-fg-muted);
+}
+
+main .gsc-reactions > * {
+    flex: 0 0 auto !important;
+    justify-content: flex-start !important;
+    margin-top: 0 !important;
+}
+
+main .gsc-main {
+    gap: 1rem;
+}
+
+@media (min-width: 601px) {
+    main .gsc-main {
+        position: relative;
+    }
+
+    main .gsc-reactions {
+        position: absolute;
+        top: 0;
+        right: 0;
+        width: auto;
+        margin: 0;
+    }
+
+    main .gsc-main:has(.gsc-right-header) .gsc-reactions {
+        right: 9.5rem;
+    }
+}
+
+main .gsc-comment-box-main {
+    margin-left: 0;
+    margin-right: 0;
+}
+
+main .gsc-comment-box-textarea {
+    box-sizing: border-box;
+    width: 100%;
+    border-left: 0;
+    border-right: 0;
+    border-top: 0;
+    border-radius: 0;
+    border-bottom-style: solid;
+}
+
+main .gsc-comment-box-textarea-extras {
+    display: none;
+}
+
+main .gsc-comment-box-md-toolbar {
+    display: none;
+}
diff --git a/docs/_static/css/home.css b/docs/_static/css/home.css
new file mode 100644
index 0000000000..5dd71e8e05
--- /dev/null
+++ b/docs/_static/css/home.css
@@ -0,0 +1,650 @@
+/* ================================================================== */
+/* Layout                                                             */
+/* ================================================================== */
+
+.home-page .right-sidebar {
+    display: none;
+}
+
+/* Hide next/prev buttons */
+.home-page .prev-next {
+    display: none;
+}
+
+/* ================================================================== */
+/* Hero                                                               */
+/* ================================================================== */
+
+.home-page .hero {
+    text-align: center;
+    padding: 1.5em 0 1em;
+}
+
+.home-page .hero-title {
+    font-family: var(--font-body);
+    font-size: 3.5rem;
+    font-weight: 700;
+    color: var(--headings);
+    line-height: 1.1;
+    margin: 0 0 0.3em;
+    font-variant-ligatures: none;
+    letter-spacing: 0.02em;
+    display: flex;
+    align-items: flex-end;
+    justify-content: center;
+}
+
+[data-theme="dark"] .home-page .hero-title {
+    color: #fff;
+}
+
+.home-page .hero-logo {
+    height: 55px;
+    width: auto;
+    padding-right: 5px;
+}
+
+.home-page .hero-title span {
+    position: relative;
+    bottom: -2px;
+}
+
+.home-page .hero-subtitle {
+    font-family: var(--font-body);
+    font-size: 1.15rem;
+    color: var(--text-muted);
+    margin-bottom: 0.9em;
+}
+
+.home-page .home-intro {
+    max-width: 720px;
+    margin: 0.4em auto 0;
+}
+
+.home-page .home-intro p {
+    margin-bottom: 0;
+}
+
+/* ================================================================== */
+/* Install one-liner                                                  */
+/* ================================================================== */
+
+.home-page .home-install {
+    position: relative;
+    display: flex;
+    align-items: center;
+    gap: 0.6em;
+    width: max-content;
+    max-width: 100%;
+    margin: 2.5em auto 0;
+    padding: 0.45em 0.55em 0.45em 0.85em;
+    background: transparent;
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    font-family: var(--code-font);
+    font-size: 0.95rem;
+    line-height: 1.4;
+    color: var(--content-text);
+    transition: border-color 0.2s ease;
+}
+
+.home-page .home-install:hover {
+    border-color: var(--text-muted);
+}
+
+.home-page .home-install.copied {
+    border-color: var(--links);
+}
+
+.home-page .home-install-prompt {
+    color: var(--text-muted);
+    font-weight: 600;
+    user-select: none;
+}
+
+.home-page .home-install-cmd {
+    background: transparent;
+    border: none;
+    padding: 0;
+    color: var(--content-text);
+    font-family: var(--code-font);
+    font-size: inherit;
+    white-space: nowrap;
+}
+
+.home-page button.home-install-copy {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 1.9em;
+    height: 1.9em;
+    padding: 0;
+    border: none;
+    border-radius: 999px;
+    background: transparent;
+    color: var(--text-muted);
+    cursor: pointer;
+    transition: background 0.15s ease, color 0.15s ease;
+}
+
+.home-page button.home-install-copy:hover {
+    background: var(--surface-sunken);
+    color: var(--content-text);
+}
+
+/* Icon swap: show copy by default, check when .copied is set on the
+   wrapper. Both SVGs are stacked at the same spot via grid trick on
+   the button so the layout doesn't shift. */
+.home-page .home-install-icon-copy,
+.home-page .home-install-icon-check {
+    grid-area: 1 / 1;
+}
+
+.home-page button.home-install-copy {
+    display: inline-grid;
+    place-items: center;
+}
+
+.home-page .home-install-icon-check {
+    visibility: hidden;
+    color: var(--links);
+}
+
+.home-page .home-install.copied .home-install-icon-copy {
+    visibility: hidden;
+}
+
+.home-page .home-install.copied .home-install-icon-check {
+    visibility: visible;
+}
+
+/* "Copied" toast: floats above the button, fades + lifts in. */
+.home-page .home-install-toast {
+    position: absolute;
+    bottom: calc(100% + 6px);
+    right: 0.4em;
+    padding: 0.18em 0.55em;
+    background: var(--links);
+    color: #fff;
+    font-family: var(--font-body);
+    font-size: 0.72rem;
+    font-weight: 600;
+    letter-spacing: 0.04em;
+    border-radius: 4px;
+    opacity: 0;
+    transform: translateY(4px);
+    pointer-events: none;
+    transition: opacity 0.18s ease, transform 0.18s ease;
+}
+
+.home-page .home-install.copied .home-install-toast {
+    opacity: 1;
+    transform: translateY(0);
+}
+
+/* ================================================================== */
+/* Platform pills                                                     */
+/* ================================================================== */
+
+.home-page hr:has(+ .home-platforms) {
+    margin-top: 32px;
+    margin-bottom: 16px;
+}
+
+/* Soften the Sponsors H2 */
+.home-page h2 {
+    font-size: 1.4rem;
+    font-weight: 600;
+    color: var(--text-muted);
+    text-align: center;
+    border-bottom: none;
+    margin-top: 2.5em;
+    margin-bottom: 0.8em;
+    text-transform: uppercase;
+    letter-spacing: 0.12em;
+}
+
+.home-page .home-platforms {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 0.4em;
+    margin: 2.5em 0 0;
+}
+
+.home-page a.home-platforms-label,
+.home-page a.home-platforms-label:visited {
+    font-size: 0.72rem;
+    color: var(--text-muted);
+    font-weight: 700;
+    letter-spacing: 0.12em;
+    text-transform: uppercase;
+    text-decoration: none;
+    transition: color var(--theme-transition);
+}
+
+.home-page a.home-platforms-label:hover {
+    color: var(--content-text);
+    text-decoration: none;
+}
+
+.home-page .home-platforms-pills {
+    display: flex;
+    justify-content: center;
+    flex-wrap: wrap;
+    gap: 8px;
+}
+
+.home-page a.home-platform-pill,
+.home-page a.home-platform-pill:visited {
+    display: inline-block;
+    padding: 3px 12px;
+    border: 1px solid var(--border);
+    border-radius: 999px;
+    font-size: 0.82rem;
+    color: var(--text-muted);
+    background: var(--surface-sunken);
+    text-decoration: none;
+    transition:
+        border-color var(--theme-transition),
+        color var(--theme-transition),
+        background var(--theme-transition);
+}
+
+.home-page a.home-platform-pill:hover {
+    border-color: var(--text-muted);
+    color: var(--content-text);
+    background: var(--surface-raised);
+    text-decoration: none;
+}
+
+/* ================================================================== */
+/* Adoption stats banner                                              */
+/* ================================================================== */
+
+.home-page .home-stats {
+    display: flex;
+    justify-content: center;
+    flex-wrap: wrap;
+    gap: 56px;
+    margin: 1em 0em 1.5em;
+}
+
+.home-page .home-section-label:has(+ .home-stats) {
+    margin-top: 4em;
+}
+
+/* Quiet stats: just numbers + labels, no boxes. The figures speak;
+   the chrome was reading as Series-B-SaaS marketing strip. */
+.home-page a.home-stat,
+.home-page a.home-stat:visited {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    color: var(--content-text);
+    text-decoration: none;
+    transition: color var(--theme-transition);
+}
+
+.home-page a.home-stat:hover .home-stat-num {
+    color: var(--links);
+}
+
+.home-page .home-stat-num {
+    font-size: 1.4rem;
+    font-weight: 700;
+    color: var(--content-text);
+    line-height: 1.2;
+    transition: color var(--theme-transition);
+}
+
+.home-page .home-stat-label {
+    font-size: 0.8rem;
+    color: var(--text-muted);
+    margin-top: 4px;
+    text-align: center;
+    text-transform: uppercase;
+    letter-spacing: 0.06em;
+}
+
+/* ================================================================== */
+/* Feature cards                                                 */
+/* ================================================================== */
+
+.home-page .home-feature-cards {
+    display: grid;
+    grid-template-columns: repeat(6, 1fr);
+    gap: 14px;
+    margin: 0;
+}
+
+@media (max-width: 900px) {
+    .home-page .home-feature-cards {
+        grid-template-columns: repeat(3, 1fr);
+    }
+}
+
+.home-page .home-feature-card {
+    position: relative;
+    border: 1px solid var(--card-border);
+    border-radius: 8px;
+    padding: 20px 14px;
+    text-align: center;
+    background: var(--card-bg);
+    text-decoration: none;
+    transition: box-shadow 0.15s, border-color 0.15s;
+    display: block;
+}
+
+.home-page .home-feature-card:hover {
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
+    border-color: var(--links);
+}
+
+/* Hover-revealed arrow signals "this is a nav link, click to jump." */
+.home-page .home-feature-card::after {
+    position: absolute;
+    top: 8px;
+    right: 10px;
+    font-size: 0.9rem;
+    color: var(--text-muted);
+    opacity: 0;
+    transition: opacity 0.15s;
+}
+
+.home-page .home-feature-card:hover::after {
+    opacity: 1;
+    color: var(--links);
+}
+
+/* Small caps section labels (Runs on, Explore the API, Try it).
+ * Margins drive the page rhythm: 2.5em above each section, 0.9em
+ * caption-to-content. Sections themselves use margin: 0 so gaps
+ * don't stack. */
+.home-page .home-section-label {
+    font-size: 0.72rem;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.12em;
+    color: var(--text-muted);
+    text-align: center;
+    margin: 2.5em 0 0.9em;
+}
+
+/* Section-label owns the caption-to-content gap; zero out the
+ * next sibling's top margin so they don't stack. */
+.home-page .home-section-label + .home-stats,
+.home-page .home-section-label + .home-quickstart,
+.home-page .home-section-label + .sponsor-table {
+    margin-top: 0;
+}
+
+/* Extra breathing room above "Try it" so it anchors as the page's
+ * interactive moment rather than blending with neighboring labels. */
+.home-page .home-section-label:has(+ .home-quickstart) {
+    margin-top: 4em;
+}
+
+.home-page .home-icon-svg {
+    width: 2.2rem;
+    height: 2.2rem;
+    display: block;
+    margin: 0 auto 10px;
+}
+
+[data-theme="dark"] .home-page .home-icon-svg {
+    filter: brightness(1.45) saturate(0.7);
+}
+
+.home-page .home-feature-title {
+    font-weight: 700;
+    font-size: 0.95rem;
+    margin-bottom: 10px;
+    color: var(--headings);
+}
+
+@media (max-width: 480px) {
+    .home-page .home-feature-cards {
+        grid-template-columns: repeat(3, 1fr);
+        gap: 8px;
+    }
+    .home-page .home-feature-card {
+        padding: 12px 8px;
+    }
+    .home-page .home-icon-svg {
+        width: 1.6rem;
+        height: 1.6rem;
+    }
+    .home-page .home-feature-title {
+        font-size: 0.8rem;
+    }
+}
+
+/* ================================================================== */
+/* Sponsors (shared with funding.rst)                                 */
+/* ================================================================== */
+
+.home-page #sponsors {
+    margin: 1.5rem -56px 20px;
+    padding: 1.5rem 56px 2rem;
+    background: #f8f9fa;
+    border-top: 1px solid var(--border);
+    text-align: center;
+}
+
+/* Full-bleed band: on mobile .main's side padding shrinks, so match
+   the pull-out to it or the band overflows and the page drags
+   sideways. */
+@media (max-width: 1024px) {
+    .home-page #sponsors {
+        margin-left: -16px;
+        margin-right: -16px;
+        padding-left: 16px;
+        padding-right: 16px;
+    }
+}
+
+@media (max-width: 600px) {
+    .home-page #sponsors {
+        margin-left: -12px;
+        margin-right: -12px;
+        padding-left: 12px;
+        padding-right: 12px;
+    }
+}
+
+.home-page #sponsors > .home-section-label {
+    margin-top: 1.2em;
+}
+
+[data-theme="dark"] .home-page #sponsors {
+    background: #1e1e1e;
+}
+
+.home-page #sponsors h1 {
+    text-align: center;
+}
+
+.sponsor-table {
+    margin-left: auto;
+    margin-right: auto;
+    max-width: 100%;
+}
+
+.sponsor-table svg {
+    max-width: 100%;
+    height: auto;
+}
+
+/* Give the logo row a subtle surface so it reads as an intentional
+   block rather than free-floating SVGs. */
+table.sponsor-table {
+    background: var(--surface-sunken);
+    border: 1px solid var(--border);
+    border-radius: var(--border-radius);
+    margin: 1em auto 0.5em auto;
+    padding: 0.8em 1.2em;
+    display: table;
+}
+
+table.sponsor-table,
+table.sponsor-table tr,
+table.sponsor-table td {
+    background: transparent;
+    border: none;
+}
+
+.sponsor-cta-wrap {
+    text-align: center;
+    margin-top: 1em;
+}
+
+a.sponsor-cta,
+a.sponsor-cta:visited {
+    font-size: 0.85rem;
+    color: var(--text-muted);
+    text-decoration: underline dashed;
+    text-decoration-color: var(--border);
+    text-underline-offset: 3px;
+    transition:
+        color var(--theme-transition),
+        opacity var(--theme-transition),
+        text-decoration-color var(--theme-transition);
+}
+
+a.sponsor-cta:hover {
+    color: var(--links);
+    opacity: 1;
+    text-decoration: underline;
+    text-decoration-color: var(--links);
+}
+
+/* ================================================================== */
+/* Misc                                                           */
+/* ================================================================== */
+
+/* TOC (hidden) */
+.home-page .toctree-wrapper {
+    display: none;
+}
+
+/* ================================================================== */
+/* Quickstart tabs (sphinx-design)                                    */
+/* ================================================================== */
+
+.home-page .home-quickstart .sd-tab-set {
+    margin: 0;
+}
+
+.home-page .home-quickstart .sd-tab-content {
+    padding: 0.5rem 0 0;
+    box-shadow: 0 -0.0625rem var(--border);
+}
+
+/* "See more →" link below each tab's code block. */
+.home-quickstart .home-tab-more {
+    margin-top: 0.8em;
+    text-align: right;
+    font-size: 0.9rem;
+    font-weight: 600;
+}
+
+.home-quickstart .home-tab-more p {
+    margin-bottom: 0;
+}
+
+.home-quickstart .home-tab-more a,
+.home-quickstart .home-tab-more a:visited {
+    color: var(--text-muted);
+    text-decoration: none;
+    transition: color 0.15s;
+}
+
+.home-quickstart .home-tab-more a:hover {
+    color: var(--links);
+    text-decoration: underline;
+}
+
+/* Inactive tabs: lighter than default so the current tab pops. */
+.home-quickstart .sd-tab-label {
+    color: var(--text-muted);
+    font-weight: 500;
+    transition: opacity 0.15s, color 0.15s;
+}
+
+.home-quickstart .sd-tab-label:hover {
+    opacity: 1;
+    color: var(--content-text);
+}
+
+/* Active tab: bolder weight + full opacity so it carries the page. */
+.home-quickstart input:checked + .sd-tab-label {
+    color: var(--links);
+    opacity: 1;
+    font-weight: 700;
+}
+
+/* ================================================================== */
+/* Quickstart code-block window chrome                                */
+/* ================================================================== */
+
+/* macOS-style traffic-light dots. */
+
+.home-quickstart .highlight {
+    position: relative;
+    padding: 42px 18px 10px;
+}
+
+.home-quickstart .highlight pre {
+    margin-top: 0;
+    padding-top: 0;
+}
+
+.home-quickstart .highlight,
+.home-quickstart .highlight pre {
+    font-size: 14px !important;
+    line-height: 1.65 !important;
+}
+
+.home-quickstart .highlight button.copybtn {
+    top: 36px;
+    right: 8px;
+}
+
+.home-quickstart .highlight::before {
+    content: "";
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    height: 28px;
+    border-top-left-radius: var(--border-radius);
+    border-top-right-radius: var(--border-radius);
+    background-color: #dde2e8;
+    background-image:
+        radial-gradient(circle at 14px 14px, #d49995 4px, transparent 4.5px),
+        radial-gradient(circle at 30px 14px, #d4b685 4px, transparent 4.5px),
+        radial-gradient(circle at 46px 14px, #9bc7a0 4px, transparent 4.5px);
+    border-bottom: 1px solid var(--border);
+    pointer-events: none;
+}
+
+[data-theme="dark"] .home-quickstart .highlight::before {
+    background-color: #1d1d1d;
+    border-bottom-color: #3a3a3a;
+}
+
+.home-quickstart .highlight::after {
+    content: "python";
+    position: absolute;
+    top: 0;
+    right: 12px;
+    height: 28px;
+    line-height: 28px;
+    font-family: var(--font-mono);
+    font-size: 0.72rem;
+    letter-spacing: 0.04em;
+    color: var(--text-muted);
+    opacity: 0.7;
+    pointer-events: none;
+}
diff --git a/docs/_static/css/layout.css b/docs/_static/css/layout.css
new file mode 100644
index 0000000000..e6b86f1e8c
--- /dev/null
+++ b/docs/_static/css/layout.css
@@ -0,0 +1,294 @@
+body {
+    margin: 0;
+}
+
+html {
+    /* Extra room below the topbar height so anchored headings clear
+       the topbar's drop shadow instead of landing inside it. */
+    scroll-padding-top: calc(var(--header-height) + 0.5rem);
+}
+
+/* ---- Header (banner + topbar), fixed at the top of the viewport ----- */
+
+/* Height varies with the banner, so js/dev-banner.js keeps
+   --header-height in sync; everything that sits below the header
+   offsets by it. */
+.header-stack {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    z-index: 100;
+}
+
+.topbar {
+    height: var(--topbar-height);
+}
+
+/* ---- Page grid (sidebar + main column), centered -------------------- */
+
+.page {
+    display: grid;
+    grid-template-columns:
+        var(--left-sidebar-width)
+        minmax(0, var(--content-max-width));
+    max-width: var(--layout-width);
+    margin: 0 auto;
+    padding-top: var(--header-height);
+    background: var(--bg);
+}
+
+.main {
+    min-width: 0;
+    padding: 0 24px;
+}
+
+/* ---- Article + right sidebar grid (inside .main) -------------------- */
+
+.article-with-toc {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr);
+    gap: 32px;
+    padding: 24px 0 24px 16px;
+    min-height: calc(100vh - var(--header-height));
+}
+
+/* No-TOC pages don't get the extra left indent; index.html etc.
+   handle their own horizontal padding via .article-column below. */
+.article-with-toc.no-toc {
+    padding-left: 0;
+}
+
+@media (min-width: 1280px) {
+    .article-with-toc {
+        grid-template-columns:
+            minmax(0, 1fr)
+            var(--right-sidebar-width);
+    }
+
+    .article-with-toc.no-toc {
+        grid-template-columns: minmax(0, 1fr);
+    }
+
+    /* No-TOC pages get extra horizontal padding so prose isn't
+       hugging the wide column edge. */
+    .article-with-toc.no-toc > .article-column {
+        padding-left: 32px;
+        padding-right: 32px;
+    }
+}
+
+.article-column {
+    min-width: 0;
+}
+
+.article {
+    min-width: 0;
+}
+
+/* ---- Mobile: collapse to single column, sidebar slides in --------- */
+
+@media (max-width: 1024px) {
+    .page {
+        grid-template-columns: minmax(0, 1fr);
+    }
+
+    .sidebar-backdrop {
+        position: fixed;
+        inset: var(--header-height) 0 0 0;
+        background: rgba(0, 0, 0, 0.4);
+        z-index: 80;
+        opacity: 0;
+        pointer-events: none;
+        transition: opacity 0.2s ease;
+    }
+
+    body.sidebar-open .sidebar-backdrop {
+        opacity: 1;
+        pointer-events: auto;
+    }
+
+    /* Don't let the page scroll behind an open sidebar. */
+    body.sidebar-open {
+        overflow: hidden;
+    }
+
+    .main {
+        padding: 0 16px;
+    }
+
+    .article-with-toc {
+        padding: 16px 0;
+    }
+}
+
+@media (max-width: 600px) {
+    :root {
+        --topbar-height: 48px;
+    }
+
+    .main {
+        padding: 0 12px;
+    }
+}
+
+/* ---- Keyboard shortcut flyout (triggered by "?") ----------------- */
+
+.shortcut-flyout {
+    position: fixed;
+    inset: 0;
+    z-index: 200;
+    display: none;
+}
+
+.shortcut-flyout.is-open {
+    display: block;
+}
+
+.shortcut-flyout-backdrop {
+    position: absolute;
+    inset: 0;
+    background: rgba(0, 0, 0, 0.45);
+}
+
+.shortcut-flyout-panel {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    box-sizing: border-box;
+    min-width: min(320px, 90vw);
+    max-width: 90vw;
+    background: var(--bg);
+    color: var(--text);
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    box-shadow: 0 12px 36px rgba(0, 0, 0, 0.35);
+    padding: 1.2em 1.4em 1.4em;
+}
+
+.shortcut-flyout-title {
+    font-size: 0.78rem;
+    font-weight: 700;
+    letter-spacing: 0.1em;
+    text-transform: uppercase;
+    color: var(--text-muted);
+    margin-bottom: 0.8em;
+}
+
+.shortcut-flyout-list {
+    display: grid;
+    grid-template-columns: auto 1fr;
+    gap: 0.55em 1.2em;
+    margin: 0;
+}
+
+.shortcut-flyout-list dt {
+    margin: 0;
+    padding: 0;
+    background: transparent;
+    border: 0;
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    white-space: nowrap;
+    font-weight: 400;
+}
+
+.shortcut-flyout-list dd {
+    margin: 0;
+    padding: 0;
+    color: var(--text);
+    align-self: center;
+}
+
+/* Pill style is shared with the search-input hint
+   (.search-kbd kbd in search.css). */
+
+/* ---- "Back to top" floating button ------------------------------- */
+
+.back-to-top {
+    position: fixed;
+    right: max(20px, calc((100vw - var(--layout-width)) / 2 + 20px));
+    bottom: 24px;
+    z-index: 90;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 34px;
+    height: 34px;
+    padding: 0;
+    border: 0;
+    border-radius: 999px;
+    background: var(--bg-topbar);
+    color: var(--text-on-dark);
+    font-size: 13px;
+    cursor: pointer;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.12);
+    /* Visible state below uses opacity 0.55, muted at rest so it
+       doesn't grab attention; pops on hover. */
+    opacity: 0;
+    pointer-events: none;
+    transition:
+        opacity 0.2s ease,
+        background 0.15s ease,
+        box-shadow 0.15s ease;
+}
+
+.back-to-top.is-visible {
+    opacity: 0.55;
+    pointer-events: auto;
+}
+
+/* Dark mode: --bg-topbar (#181818) blends into the page bg. Use a
+   lighter gray + full opacity so the button stands out. */
+[data-theme="dark"] .back-to-top {
+    background: #525252;
+    color: #f5f5f5;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.5);
+}
+
+[data-theme="dark"] .back-to-top.is-visible {
+    opacity: 1;
+}
+
+/* Mobile: bump size + opacity. The 28px gap-tucked button is way
+   too small/subtle for touch + small screens. */
+@media (max-width: 1024px) {
+    .back-to-top {
+        right: 14px;
+        bottom: 14px;
+        width: 36px;
+        height: 36px;
+        font-size: 13px;
+        box-shadow: 0 2px 6px rgba(0, 0, 0, 0.22);
+    }
+
+    .back-to-top.is-visible,
+    [data-theme="dark"] .back-to-top.is-visible {
+        opacity: 1;
+    }
+}
+
+/* Wide viewports: tuck the button into the 32px gap between the
+   article column and the right TOC. Button is 28px, so 2px clear
+   on each side. */
+@media (min-width: 1280px) {
+    .back-to-top {
+        right: calc(
+            max(0px, (100vw - var(--layout-width)) / 2) +
+                var(--right-sidebar-width) +
+                44px
+        );
+    }
+}
+
+.back-to-top.is-visible:hover {
+    opacity: 1;
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.2);
+}
+
+.back-to-top:focus-visible {
+    outline: 2px solid var(--accent-ring);
+    outline-offset: 3px;
+}
diff --git a/docs/_static/css/left-sidebar.css b/docs/_static/css/left-sidebar.css
new file mode 100644
index 0000000000..ef571ae514
--- /dev/null
+++ b/docs/_static/css/left-sidebar.css
@@ -0,0 +1,115 @@
+.left-sidebar {
+    position: sticky;
+    top: var(--header-height);
+    align-self: start;
+    height: calc(100vh - var(--header-height));
+    overflow-y: auto;
+    background: var(--bg-sidebar);
+    color: var(--sidebar-fg);
+}
+
+/* ---- Captions ("Documentation", "Reference", ...) ------------------- */
+
+.left-sidebar p.caption {
+    margin: 16px 0 4px;
+    padding: 0 1.618em;
+    font-size: 12px;
+    font-weight: 500;
+    letter-spacing: 0.18em;
+    text-transform: uppercase;
+    color: var(--sidebar-caption);
+}
+
+.left-sidebar p.caption:first-of-type {
+    margin-top: 0;
+}
+
+/* ---- List structure ------------------------------------------------- */
+
+.left-sidebar ul,
+.left-sidebar li {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+}
+
+/* ---- Items ---------------------------------------------------------- */
+
+.left-sidebar a,
+.left-sidebar a:visited {
+    display: block;
+    padding: 0.32em 1.2em;
+    line-height: 1.4;
+    color: var(--sidebar-fg);
+    text-decoration: none;
+}
+
+.left-sidebar li.toctree-l1 > a {
+    text-transform: capitalize;
+}
+
+.left-sidebar a:hover {
+    background: rgba(255, 255, 255, 0.04);
+}
+
+/* ---- Active item ---------------------------------------------------- */
+
+.left-sidebar li.current > a,
+.left-sidebar li.current > a:visited {
+    background: var(--sidebar-active-bg);
+    color: var(--sidebar-active-fg);
+    box-shadow:
+        inset 3px 0 0 var(--bg-sidebar),
+        inset -3px 0 0 var(--bg-sidebar);
+}
+
+/* ---- Mobile: off-canvas drawer ------------------------------------- */
+
+@media (max-width: 1024px) {
+    .left-sidebar {
+        position: fixed;
+        top: var(--header-height);
+        left: 0;
+        z-index: 90;
+        width: var(--left-sidebar-width);
+        max-width: 85vw;
+        height: calc(100vh - var(--header-height));
+        transform: translateX(-100%);
+        transition: transform 0.2s ease;
+    }
+
+    body.sidebar-open .left-sidebar {
+        transform: translateX(0);
+        box-shadow: 4px 0 16px rgba(0, 0, 0, 0.35);
+    }
+}
+
+/* Touch devices: taller nav rows for comfortable tapping. 36px keeps
+   them well above the WCAG 2.5.8 (AA) 24px floor without the airy gaps
+   the AAA 44px target leaves around single-line items. */
+@media (pointer: coarse) {
+    .left-sidebar a {
+        display: flex;
+        align-items: center;
+        min-height: 36px;
+    }
+}
+
+/* ---- Per-item icons (Font Awesome) ---------------------------------- */
+
+.left-sidebar li.toctree-l1 > a::before {
+    font-family: var(--doc-icon-font, var(--fa-family-classic));
+    font-weight: var(--doc-icon-weight, 900);
+    display: inline-block;
+    width: 1.3em;
+    margin-right: 0.7em;
+    font-size: 0.85em;
+    text-align: center;
+    color: var(--sidebar-caption);
+    opacity: 0.85;
+    content: var(--doc-icon, "");
+}
+
+.left-sidebar li.current > a::before {
+    color: var(--sidebar-active-fg);
+}
diff --git a/docs/_static/css/prev-next.css b/docs/_static/css/prev-next.css
new file mode 100644
index 0000000000..62e509d863
--- /dev/null
+++ b/docs/_static/css/prev-next.css
@@ -0,0 +1,86 @@
+/*
+ * psutil-sphinx-theme: prev / next page navigation at the bottom.
+ */
+
+.prev-next {
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    gap: 16px;
+    margin-top: 1.5em;
+    padding: 12px 0 4px;
+    border-top: 1px solid var(--border);
+}
+
+.prev-next-prev,
+.prev-next-next {
+    display: inline-flex;
+    align-items: center;
+    gap: 12px;
+    flex: 1 1 0;
+    min-width: 0;
+    color: inherit;
+    text-decoration: none;
+    padding: 4px 8px;
+    border-radius: 4px;
+    transition: background 0.15s;
+}
+
+.prev-next-next {
+    justify-content: flex-end;
+}
+
+.prev-next-prev:hover,
+.prev-next-next:hover {
+    background: var(--bg-hover);
+    text-decoration: none;
+}
+
+/* Push next-only (no prev) to the right edge. */
+.prev-next-next:only-child {
+    margin-left: auto;
+}
+
+.prev-next-block {
+    display: inline-flex;
+    flex-direction: column;
+    justify-content: center;
+    gap: 8px;
+    line-height: 1.2;
+    min-width: 0;
+}
+
+.prev-next-prev .prev-next-block {
+    align-items: flex-start;
+    text-align: left;
+}
+
+.prev-next-next .prev-next-block {
+    align-items: flex-end;
+    text-align: right;
+}
+
+.prev-next-label {
+    font-size: 0.7rem;
+    font-weight: 500;
+    text-transform: uppercase;
+    letter-spacing: 0.08em;
+    color: var(--text-muted);
+    opacity: 0.85;
+}
+
+.prev-next-title {
+    font-size: 1rem;
+    font-weight: 400;
+    color: var(--headings);
+    overflow-wrap: anywhere;
+}
+
+.prev-next-arrow {
+    display: inline-flex;
+    align-items: center;
+    align-self: stretch;
+    color: var(--text-muted);
+    font-size: 1.6rem;
+    line-height: 1;
+}
diff --git a/docs/_static/css/print.css b/docs/_static/css/print.css
new file mode 100644
index 0000000000..fde7015697
--- /dev/null
+++ b/docs/_static/css/print.css
@@ -0,0 +1,54 @@
+/* Print / PDF: strip top bar and other useless parts. */
+
+@media print {
+    .topbar,
+    .left-sidebar,
+    .right-sidebar,
+    .sidebar-backdrop,
+    .back-to-top,
+    .prev-next,
+    .shortcut-flyout,
+    .comments {
+        display: none !important;
+    }
+
+    .page {
+        display: block;
+        max-width: none;
+        margin: 0;
+        padding-top: 0;
+    }
+
+    .main {
+        padding: 0;
+    }
+
+    .article-with-toc {
+        display: block;
+        padding: 0;
+        min-height: 0;
+    }
+
+    body,
+    .article {
+        color: #000;
+        background: #fff;
+    }
+
+    .article a[href^="http"]::after {
+        content: " (" attr(href) ")";
+        font-size: 0.85em;
+        word-break: break-all;
+    }
+
+    .highlight {
+        border: 1px solid #ccc !important;
+        background: #fff !important;
+    }
+
+    pre,
+    .highlight {
+        white-space: pre-wrap;
+        overflow: visible;
+    }
+}
diff --git a/docs/_static/css/right-sidebar.css b/docs/_static/css/right-sidebar.css
new file mode 100644
index 0000000000..2e257e8c17
--- /dev/null
+++ b/docs/_static/css/right-sidebar.css
@@ -0,0 +1,225 @@
+/*
+ * psutil-sphinx-theme: right sidebar (per-page TOC).
+ *
+ * Hidden below 1280px. Sticky inside its grid cell at wider widths.
+ * Sizes / spacing kept faithful to the previous psutil site.
+ */
+
+.right-sidebar {
+    display: none;
+}
+
+@media (max-width: 1279px) {
+    .topbar-toc-toggle {
+        display: none;
+    }
+
+    body:has(.right-sidebar) .topbar-toc-toggle {
+        display: inline-flex;
+    }
+
+    .right-sidebar {
+        display: block;
+        position: fixed;
+        top: var(--header-height);
+        right: 0;
+        z-index: 90;
+        width: var(--left-sidebar-width);
+        max-width: 85vw;
+        height: calc(100vh - var(--header-height));
+        overflow-y: auto;
+        box-sizing: border-box;
+        padding: 16px;
+        background: var(--bg);
+        border-left: 1px solid var(--border);
+        transform: translateX(100%);
+        transition: transform 0.2s ease;
+    }
+
+    body.toc-open .right-sidebar {
+        transform: translateX(0);
+        box-shadow: -4px 0 16px rgba(0, 0, 0, 0.35);
+    }
+}
+
+@media (min-width: 1280px) {
+    .right-sidebar {
+        display: block;
+        position: sticky;
+        top: calc(var(--header-height) + 20px);
+        align-self: start;
+        max-height: calc(100vh - var(--header-height) - 36px);
+        overflow-y: auto;
+        padding: 0 16px;
+        margin-right: -24px;
+        border-left: 1px solid #ccc;
+        box-sizing: border-box;
+        font-size: 0.85rem;
+        line-height: 1.4;
+    }
+
+    [data-theme="dark"] .right-sidebar {
+        border-left-color: #3a3a3a;
+    }
+}
+
+/* ---- Title ("On this page") ---------------------------------------- */
+
+.right-sidebar-title {
+    position: sticky;
+    top: 0;
+    z-index: 1;
+    background: var(--bg);
+    color: var(--text-muted);
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.1em;
+    padding: 0 0 0.6rem 8px;
+}
+
+/* {{ toc }} renders the H1 as the root <li> wrapping all sections.
+   Sphinx has no config to skip it; alternatives are a custom doctree
+   walker (Furo's approach) or this 2-rule CSS hide. */
+.right-sidebar > ul > li:first-child > a {
+    display: none;
+}
+.right-sidebar > ul > li:first-child > ul {
+    padding-left: 0;
+}
+
+/* ---- List structure ------------------------------------------------ */
+
+.right-sidebar ul,
+.right-sidebar li {
+    list-style: none;
+    margin: 0;
+    padding: 0;
+}
+
+.right-sidebar li {
+    margin: 4px 0;
+    font-size: 0.85rem;
+    line-height: 1.4;
+}
+
+/* Nested uls don't add indent; indent is applied per-anchor instead,
+   so the active bar stays at column-edge regardless of depth. */
+.right-sidebar ul ul {
+    padding-left: 0;
+}
+
+/* ---- Anchors ------------------------------------------------------- */
+
+.right-sidebar a,
+.right-sidebar a:visited {
+    display: block;
+    font-variant-numeric: tabular-nums;
+    padding: 0.2rem 8px;
+    margin: 0 6px 0 0;
+    color: var(--text-muted);
+    text-decoration: none;
+    overflow-wrap: anywhere;
+}
+
+.right-sidebar a:hover {
+    color: var(--accent);
+    text-decoration: none;
+}
+
+.right-sidebar a code {
+    font-weight: inherit;
+    background: none;
+    padding: 0;
+    color: inherit;
+}
+
+/* H2 entries are emphasized; H3 styled as quiet group captions; H4 as items. */
+.right-sidebar > ul > li:first-child > ul > li > a {
+    font-size: 0.92rem;
+    font-weight: 600;
+}
+
+/* Flat TOC: if only H2s, no H3+ anywhere) drop the bold. */
+.right-sidebar > ul > li:first-child > ul:not(:has(li > ul)) > li > a {
+    font-size: 0.85rem;
+    font-weight: 400;
+}
+
+.right-sidebar > ul > li:first-child > ul > li + li {
+    margin-top: 0.5rem;
+}
+
+.right-sidebar > ul > li:first-child > ul > li > ul > li:has(> ul) > a,
+.right-sidebar
+    > ul > li:first-child
+    > ul > li > ul > li:has(> ul)
+    > a:visited {
+    font-weight: 600;
+    color: var(--text);
+}
+
+/* Suppress the accent-blue hover flash on group rows (labels, not
+   primary navigation targets). */
+.right-sidebar > ul > li:first-child > ul > li > ul > li:has(> ul) > a:hover {
+    color: var(--text);
+}
+
+.right-sidebar > ul > li:first-child > ul > li > ul > li:has(> ul) {
+    margin-top: 0.5rem;
+}
+
+.right-sidebar > ul > li:first-child > ul > li > ul > li > ul > li > a {
+    font-size: 0.85rem;
+    font-weight: 400;
+}
+
+.right-sidebar
+    > ul > li:first-child
+    > ul > li > ul > li > ul > li > ul > li > a {
+    font-size: 0.8rem;
+    font-weight: 400;
+}
+
+/* Glossary TOC: populated by _ext/glossary_toc.py. */
+.right-sidebar ul.glossary-toc li {
+    margin: 2px 0;
+}
+.right-sidebar ul.glossary-toc a {
+    font-size: 0.85rem;
+    padding: 0.15rem 0 0.15rem 8px;
+}
+
+.right-sidebar ul.blog-tags li {
+    margin: 2px 0;
+}
+
+.right-sidebar ul.blog-tags a {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.6em;
+    font-size: 0.9rem;
+    padding: 0.15rem 0 0.15rem 8px;
+}
+
+.right-sidebar .blog-tag-count {
+    flex: none;
+    min-width: 1.6em;
+    padding: 0.05em 0.5em;
+    border-radius: 999px;
+    background: var(--surface-raised);
+    color: var(--text-muted);
+    font-size: 0.75rem;
+    font-variant-numeric: tabular-nums;
+    text-align: center;
+}
+
+/* ---- Active state (driven by js/right-toc.js) ---------------------- */
+
+.right-sidebar li.scroll-current-leaf > a,
+.right-sidebar li.scroll-current-leaf > a:visited {
+    color: var(--text);
+    background: var(--surface-raised);
+    border-radius: var(--border-radius);
+}
diff --git a/docs/_static/css/search.css b/docs/_static/css/search.css
new file mode 100644
index 0000000000..bfae6620eb
--- /dev/null
+++ b/docs/_static/css/search.css
@@ -0,0 +1,309 @@
+/* ====================================================================== */
+/* Sidebar search box                                                     */
+/* ====================================================================== */
+
+.search-box {
+    position: sticky;
+    top: 0;
+    z-index: 5;
+    background: inherit;
+    padding: 12px;
+}
+
+/* Dim the rest of the page while the search input is focused. */
+.search-overlay {
+    position: fixed;
+    inset: var(--header-height) 0 0 0;
+    background: rgba(0, 0, 0, 0.5);
+    opacity: 0;
+    pointer-events: none;
+    z-index: 95;
+    transition: opacity 0.15s ease;
+}
+
+body.search-focused .search-overlay {
+    opacity: 1;
+}
+
+body.search-focused .left-sidebar {
+    z-index: 96;
+}
+
+body.search-focused .left-sidebar > :not(.search-box) {
+    opacity: 0.35;
+    transition: opacity 0.15s ease;
+}
+
+.search-box form {
+    position: relative;
+    display: flex;
+    align-items: center;
+}
+
+.search-box input[type="text"] {
+    flex: 1;
+    width: 100%;
+    box-sizing: border-box;
+    padding: 4px 60px 4px 12px;
+    font: inherit;
+    font-size: 13px;
+    border: 1px solid #555;
+    border-radius: 8px;
+    background: var(--bg-input);
+    color: var(--text);
+    transition: border-color 0.2s ease, box-shadow 0.2s ease;
+}
+
+.search-box input[type="text"]:focus {
+    outline: none;
+    border-color: #7ab3d4;
+    box-shadow: 0 0 0 2px rgba(122, 179, 212, 0.3);
+}
+
+.search-kbd {
+    position: absolute;
+    right: 10px;
+    top: 0;
+    bottom: 0;
+    display: flex;
+    align-items: center;
+    gap: 3px;
+    pointer-events: none;
+    color: #999;
+    font-size: 10px;
+    transition: opacity 0.15s ease;
+}
+
+/* Hide the hint while the input is focused (redundant cue). */
+body.search-focused .search-kbd {
+    opacity: 0;
+}
+
+.search-kbd kbd,
+.shortcut-flyout-list kbd,
+.article kbd {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 3px 5px 1px;
+    font-family: var(--font-body);
+    font-size: 10px;
+    font-weight: 500;
+    line-height: 1;
+    color: var(--kbd-text);
+    background: var(--kbd-bg);
+    border: 1px solid var(--kbd-border);
+    border-bottom-width: 1.5px;
+    border-radius: 3px;
+}
+
+/* Bigger pills: the '?' help flyout and the keyboard keys in prose /
+   tables on the "About this site" page (body content, not a hint). */
+.shortcut-flyout-list kbd,
+.article kbd {
+    padding: 4px 7px;
+    font-size: 12px;
+    vertical-align: baseline;
+}
+
+/* ====================================================================== */
+/* Search results page                                                    */
+/* ====================================================================== */
+
+/* ---- Big search input (top of page) -------------------------------- */
+
+.search-page-form {
+    position: relative;
+    display: flex;
+    align-items: stretch;
+    margin: 0 0 1.5em;
+    border: 1px solid var(--border);
+    border-radius: 4px;
+    background: var(--bg);
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.04);
+    transition: border-color 0.15s, box-shadow 0.15s;
+}
+
+.search-page-form:focus-within {
+    border-color: var(--accent);
+    box-shadow: 0 0 0 3px var(--accent-ring);
+}
+
+.search-page-icon {
+    align-self: center;
+    padding: 0 0.4em 0 0.9em;
+    color: var(--text-muted);
+    font-size: 0.95rem;
+}
+
+.search-page-input {
+    flex: 1;
+    min-width: 0;
+    padding: 0.7em 0.4em;
+    font-size: 1.15rem;
+    font-family: var(--font-body);
+    color: var(--text);
+    background: transparent;
+    border: none;
+    outline: none;
+    box-sizing: border-box;
+}
+
+.search-page-btn {
+    flex-shrink: 0;
+    padding: 0 1.4em;
+    font-size: 0.95rem;
+    font-weight: 500;
+    color: var(--text-muted);
+    background: transparent;
+    border: none;
+    border-left: 1px solid var(--border);
+    cursor: pointer;
+    transition: color 0.15s, background 0.15s;
+}
+
+.search-page-btn:hover {
+    color: var(--accent);
+    background: var(--bg-key);
+}
+
+/* ---- Result cards -------------------------------------------------- */
+
+/* "Search finished, found N pages..." strapline. */
+p.search-summary {
+    font-size: 0.9em;
+    font-weight: 500;
+    margin: 0 0 1em 0;
+    color: var(--text-muted);
+}
+
+ul.search {
+    list-style: none;
+    margin: 0;
+    padding: 8px 0;
+    display: flex;
+    flex-direction: column;
+    gap: 8px;
+}
+
+ul.search > li {
+    list-style: none;
+    margin: 0;
+    padding: 12px 16px;
+    display: flex;
+    flex-wrap: wrap;
+    align-items: flex-start;
+    column-gap: 6px;
+    line-height: normal;
+    border: 1px solid var(--border);
+    border-radius: 6px;
+    background: var(--bg);
+    box-shadow: 0 1px 2px rgba(0, 0, 0, 0.04);
+}
+
+[data-theme="dark"] ul.search > li {
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.35);
+}
+
+/* Compact card: link-only result with no description. */
+ul.search > li:not(:has(> span)):not(:has(> p.context)) {
+    padding: 8px 16px;
+}
+
+ul.search > li > a,
+ul.search > li > a:visited,
+ul.search > li > a *,
+ul.search > li > a:visited * {
+    flex: 1;
+    font-weight: bold;
+    color: var(--accent);
+    text-decoration: none;
+}
+
+ul.search > li > a:hover {
+    text-decoration: underline;
+}
+
+/* Description chip e.g. "(Python class, in API reference)" */
+ul.search > li > span:not(.highlighted) {
+    font-size: 0.75em;
+    font-weight: 500;
+    color: var(--text-muted);
+    background: var(--bg-key);
+    border: 1px solid var(--border);
+    border-radius: 10px;
+    padding: 0.1em 0.55em;
+    align-self: center;
+    opacity: 0.85;
+    white-space: nowrap;
+}
+
+/* Context paragraph (snippet under the title), aligned with the
+   icon column. */
+ul.search > li > p.context {
+    flex-basis: 100%;
+    margin: 0 0 0 28px;
+    font-size: 0.9em;
+    color: var(--text-muted);
+    line-height: 1.5;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+}
+
+ul.search .highlighted,
+ul.search > li > p.context .highlighted {
+    background: var(--bg-search-highlight);
+    padding: 0 2px;
+    border-radius: 2px;
+}
+
+/* Active row when navigating with ArrowUp / ArrowDown. */
+ul.search > li.search-result-active {
+    background: var(--bg-key);
+    outline: none;
+}
+
+/* ---- Result icons via FontAwesome ::before ------------------------- */
+
+/* Icon column. Page-specific glyph comes from --doc-icon (set per page
+   in doc-icons.css, shared with the sidebar); the kind fallback below
+   covers results whose target page has no icon. */
+ul.search > li::before {
+    content: var(--doc-icon, "\f0f6"); /* generic doc */
+    font-family: var(--doc-icon-font, "Font Awesome 7 Free");
+    font-weight: var(--doc-icon-weight, 900);
+    font-size: 16px;
+    flex-shrink: 0;
+    margin-top: 4px;
+    margin-right: 2px;
+    width: 1.2em;
+    text-align: center;
+    color: var(--text-muted);
+}
+
+/* Fallbacks by Sphinx SearchResultKind, used only when the target page
+   has no --doc-icon. */
+ul.search > li.kind-title::before {
+    content: var(--doc-icon, "\f0c1");
+} /* link */
+
+ul.search > li.kind-object::before {
+    content: var(--doc-icon, "\f085");
+} /* cogs */
+
+ul.search > li.kind-text::before {
+    content: var(--doc-icon, "\f0f6");
+} /* doc text */
+
+ul.search > li.kind-index::before {
+    content: var(--doc-icon, "\f097");
+} /* bookmark */
+
+/* Blog results get a "Blog >" breadcrumb prefix on the link itself. */
+ul.search > li:has(> a[href^="blog/"]) > a::before,
+ul.search > li:has(> a[href*="/blog/"]) > a::before {
+    content: "Blog > ";
+}
diff --git a/docs/_static/css/tables.css b/docs/_static/css/tables.css
new file mode 100644
index 0000000000..3dca2817dd
--- /dev/null
+++ b/docs/_static/css/tables.css
@@ -0,0 +1,98 @@
+/*
+ * psutil-sphinx-theme: HTML tables + version directives.
+ */
+
+/* ---- Tables -------------------------------------------------------- */
+
+.article table.docutils {
+    border-collapse: collapse;
+    width: 100%;
+    margin: 1em 0;
+    table-layout: fixed;
+}
+
+.article table.docutils th,
+.article table.docutils td {
+    padding: 6px 10px;
+    border: 1px solid var(--table-border);
+    vertical-align: top;
+    text-align: left;
+    white-space: normal;
+    word-wrap: break-word;
+    overflow-wrap: break-word;
+}
+
+.article table.docutils th {
+    background: var(--table-header-bg);
+    color: var(--table-header-text);
+    font-weight: 600;
+    text-align: left;
+}
+
+.article table.docutils tbody tr:nth-child(odd) td {
+    background: var(--table-row-odd);
+}
+
+.article table.docutils tbody tr:nth-child(even) td {
+    background: var(--table-row-even);
+}
+
+/* Cell paragraphs shouldn't add bottom margin. */
+.article table.docutils th p,
+.article table.docutils td p {
+    margin: 0;
+}
+
+/* "wide-table" opt-out: size columns to content. */
+.article table.wide-table {
+    table-layout: auto;
+}
+
+/* Narrow screens: let tables scroll horizontally. */
+@media (max-width: 1024px) {
+    .article table.docutils {
+        display: block;
+        overflow-x: auto;
+        table-layout: auto;
+        max-width: 100%;
+    }
+}
+
+/* ---- Version directives -------------------------------------------- */
+
+div.versionadded,
+div.versionchanged,
+div.deprecated {
+    border-left: 3px solid;
+    padding: 0 1rem;
+    margin: 1em 0;
+}
+
+div.versionadded p,
+div.versionchanged p,
+div.deprecated p {
+    margin: 0;
+}
+
+div.versionadded {
+    border-left-color: var(--versionadded-border);
+}
+div.versionchanged {
+    border-left-color: var(--versionchanged-border);
+}
+div.deprecated {
+    border-left-color: var(--deprecated-border);
+}
+
+div.versionadded .versionmodified {
+    color: var(--versionadded-color);
+    font-weight: 600;
+}
+div.versionchanged .versionmodified {
+    color: var(--versionchanged-color);
+    font-weight: 600;
+}
+div.deprecated .versionmodified {
+    color: var(--deprecated-color);
+    font-weight: 600;
+}
diff --git a/docs/_static/css/topbar.css b/docs/_static/css/topbar.css
new file mode 100644
index 0000000000..cf35fea0bb
--- /dev/null
+++ b/docs/_static/css/topbar.css
@@ -0,0 +1,251 @@
+/* ---- Hamburger (mobile only) ---------------------------------------- */
+
+.topbar-hamburger {
+    display: none;
+    align-items: center;
+    justify-content: center;
+    width: 38px;
+    height: 38px;
+    margin-right: 4px;
+    border: none;
+    border-radius: 6px;
+    background: transparent;
+    color: var(--sidebar-fg);
+    font-size: 1.25rem;
+    cursor: pointer;
+}
+
+@media (max-width: 1024px) {
+    .topbar-hamburger {
+        display: inline-flex;
+    }
+}
+
+/* ---- Container ------------------------------------------------------- */
+
+.topbar {
+    background:
+        linear-gradient(
+            to bottom,
+            rgba(255, 255, 255, 0.1) 0%,
+            rgba(255, 255, 255, 0) 100%
+        ),
+        var(--bg-topbar);
+    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.35);
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+    color: var(--sidebar-fg);
+}
+
+.topbar-inner {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    height: 100%;
+    max-width: var(--layout-width);
+    margin: 0 auto;
+    padding: 0 2.5rem 0 0;
+}
+
+/* ---- Left: logo block (same width as the left sidebar) -------------- */
+
+.topbar .topbar-logo,
+.topbar .topbar-logo:visited {
+    display: flex;
+    align-items: center;
+    height: 100%;
+    width: var(--left-sidebar-width);
+    /* Match the left sidebar's item indentation (1.618em) so the
+       wordmark sits directly above where the toctree items start. */
+    padding-left: 1.618em;
+    gap: 10px;
+    text-decoration: none;
+    color: #ffffff;
+    font-weight: 500;
+    font-size: 1.1rem;
+    letter-spacing: 0.01em;
+}
+
+.topbar-logo span {
+    padding-top: 6px;
+    line-height: 1;
+}
+
+.topbar-logo img {
+    height: 30px;
+    width: auto;
+    display: block;
+}
+
+/* ---- Right: actions cluster ----------------------------------------- */
+
+.topbar-actions {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+}
+
+/* Visual gap between the "preferences/nav" group (Blog, theme) and the
+   "repo facts" group (GitHub, version). */
+.topbar-btn + .topbar-link {
+    margin-left: 6px;
+}
+
+/* Square icon button base (theme-toggle button + GitHub link). FA
+   icons inside scale via font-size. */
+.topbar-link,
+.topbar-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 32px;
+    height: 32px;
+    border-radius: 6px;
+    border: none;
+    background: transparent;
+    cursor: pointer;
+    color: var(--sidebar-fg);
+    font-size: 1.3rem;
+    text-decoration: none;
+    transition: background 0.15s, color 0.15s;
+}
+
+/* Blog link reads as a text label, not an icon button. */
+.topbar-text {
+    display: inline-flex;
+    align-items: center;
+    height: 32px;
+    padding: 0 10px;
+    font-size: 1.05rem;
+    font-weight: 600;
+    color: var(--sidebar-fg);
+    text-decoration: none;
+    border-radius: 6px;
+    transition: background 0.15s, color 0.15s;
+}
+
+/* Shared hover for every actionable element in the topbar. */
+.topbar-hamburger:hover,
+.topbar-link:hover,
+.topbar-btn:hover,
+.topbar-text:hover {
+    background: var(--bg-hover-on-dark);
+    color: #ffffff;
+}
+
+.topbar a:hover {
+    text-decoration: none;
+}
+
+/* GitHub: icon + star count, expands beyond the 32px square. */
+.topbar-github {
+    width: auto;
+    padding: 0 8px 0 6px;
+    gap: 6px;
+}
+
+.topbar-stars {
+    display: inline-flex;
+    align-items: center;
+    gap: 3px;
+    font-size: 0.9rem;
+    font-weight: 600;
+    line-height: 1;
+    font-variant-numeric: tabular-nums;
+    color: var(--sidebar-fg);
+}
+
+/* FontAwesome star, matching the old site exactly. */
+.topbar-stars::before {
+    content: "\f005";
+    font-family: "Font Awesome 7 Free";
+    font-weight: 900;
+    font-size: 0.85em;
+    opacity: 0.85;
+}
+
+.topbar-stars:empty {
+    display: none;
+}
+
+/* ---- Mobile responsive ---------------------------------------------- */
+
+@media (max-width: 1024px) {
+    .topbar-logo,
+    .topbar-logo:visited {
+        width: auto;
+        padding-left: 0;
+    }
+
+    .topbar-inner {
+        padding: 0 8px;
+        justify-content: flex-start;
+    }
+
+    .topbar-hamburger {
+        margin-right: 0;
+    }
+
+    .topbar-actions {
+        gap: 0;
+        margin-left: auto;
+    }
+
+    .topbar-btn + .topbar-link {
+        margin-left: 0;
+    }
+
+    .topbar-text {
+        padding: 0 8px;
+    }
+
+    /* Drop the stars count once the hamburger is in play; the
+       icon-only GitHub link stays. */
+    .topbar-stars {
+        display: none;
+    }
+
+    .topbar-github {
+        padding: 0 6px;
+    }
+
+    .topbar-link,
+    .topbar-btn,
+    .topbar-hamburger {
+        width: 38px;
+    }
+}
+
+@media (max-width: 600px) {
+    .topbar-text {
+        font-size: 0.95rem;
+    }
+}
+
+@media (max-width: 620px) {
+    .topbar-actions .topbar-text {
+        display: none;
+    }
+}
+
+@media (max-width: 360px) {
+    .topbar-logo span {
+        display: none;
+    }
+}
+
+@media (pointer: coarse) {
+    .topbar-link,
+    .topbar-btn,
+    .topbar-hamburger {
+        width: 44px;
+        height: 44px;
+    }
+
+    .topbar-text {
+        height: 44px;
+    }
+}
+
+.topbar-toc-toggle {
+    display: none;
+}
diff --git a/docs/_static/css/typography.css b/docs/_static/css/typography.css
new file mode 100644
index 0000000000..e20e18e771
--- /dev/null
+++ b/docs/_static/css/typography.css
@@ -0,0 +1,240 @@
+/* ---- Body ---------------------------------------------------------- */
+
+body {
+    font-family: var(--font-body);
+    /* fix flashing */
+    background: var(--bg);
+    color: var(--text);
+    font-size: 16px;
+    line-height: 1.65;
+}
+
+/* ---- Headings (article only) -------------------------------------- */
+
+.article h1,
+.article h2,
+.article h3,
+.article h4 {
+    color: var(--headings);
+    font-family: var(--font-body);
+    margin-top: 14px;
+    margin-bottom: 8px;
+}
+
+.article h1 {
+    font-size: 230%;
+    font-weight: 700;
+    line-height: 1.2;
+    letter-spacing: -0.015em;
+    padding: 4px 0 2px;
+    margin-bottom: 0.8rem;
+}
+
+.article h1 a,
+.article h2 a,
+.article h3 a,
+.article h4 a,
+.article h1 a:visited,
+.article h2 a:visited,
+.article h3 a:visited,
+.article h4 a:visited {
+    color: inherit;
+    text-decoration: none;
+}
+
+/* Anchor link (¶) replaced with a FontAwesome chain-link icon, shown
+   only on heading hover. Same pattern as the old RTD theme. */
+.article a.headerlink,
+.article a.headerlink:visited,
+.article a.headerlink:hover {
+    visibility: visible; /* override basic.css default */
+    margin-left: 0.6rem;
+    padding-left: 0;
+    color: var(--text-muted);
+    font-weight: normal;
+    font-size: 0;
+    text-decoration: none;
+    opacity: 0;
+    transition: opacity 0.15s ease;
+}
+
+.article a.headerlink::after,
+.article a.headerlink:hover::after {
+    font-family: "Font Awesome 7 Free";
+    font-weight: 900;
+    content: "\f0c1";
+    font-size: 0.85rem;
+    color: var(--text-muted);
+}
+
+.article h1:hover a.headerlink,
+.article h2:hover a.headerlink,
+.article h3:hover a.headerlink,
+.article h4:hover a.headerlink,
+.article h5:hover a.headerlink,
+.article h6:hover a.headerlink,
+.article dt:hover a.headerlink {
+    opacity: 0.7;
+}
+
+.article a.headerlink:hover,
+.article a.headerlink:focus-visible {
+    opacity: 1;
+}
+
+.article a.headerlink:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+}
+
+.article h2 {
+    font-size: 150%;
+    font-weight: 600;
+    line-height: 1.3;
+    padding: 2px 0;
+    margin-top: 1.4rem;
+    margin-bottom: 0.5rem;
+}
+
+.article h3 {
+    font-size: 125%;
+    font-weight: 600;
+    line-height: 1.35;
+    padding: 2px 0;
+    margin-top: 1rem;
+}
+
+.article h4 {
+    font-size: 115%;
+    font-weight: 500;
+    padding: 2px 0;
+}
+
+/* ---- Paragraphs and lists ----------------------------------------- */
+
+.article p {
+    margin-bottom: 16px;
+}
+
+.article ul,
+.article ol {
+    margin: 0 0 1em;
+    padding-left: 1.5em;
+}
+
+.article li {
+    margin-bottom: 0.3em;
+}
+
+/* ---- Links (prose only) ------------------------------------------- */
+
+.article a {
+    color: var(--accent);
+    text-decoration: none;
+}
+
+.article a:hover {
+    text-decoration: underline;
+}
+
+.article a.reference:has(code.xref) {
+    color: var(--links-api);
+}
+
+.article a.reference:has(code.xref):hover {
+    text-decoration: none;
+}
+
+/* External links get a small "↗" FontAwesome icon after the text. */
+.article a.reference.external:not(:has(img)):not([href^="#"])::after {
+    content: "\f08e";
+    font-family: "Font Awesome 7 Free";
+    font-weight: 900;
+    font-size: 0.4em;
+    margin-left: 0.3em;
+    vertical-align: super;
+    opacity: 0.6;
+    display: inline-block;
+}
+
+/* Pull the icon flush against trailing inline code to avoid a gap. */
+.article a.reference.external:has(> code):not(:has(img))::after,
+.article a.reference.external:has(> span > code):not(:has(img))::after {
+    margin-left: 0;
+}
+
+.article a.reference code,
+.article a.reference tt {
+    color: inherit;
+    background: none;
+    font-size: 90%;
+    font-weight: normal;
+    text-decoration: underline;
+    text-decoration-color: var(--links-api-underline);
+    text-decoration-thickness: 1px;
+    text-underline-offset: 4px;
+}
+
+/* ---- Inline code (`literals`) ------------------------------------- */
+
+code {
+    font-family: var(--font-mono);
+    font-size: 92%;
+    font-weight: normal;
+    color: var(--inline-code-text);
+    background: var(--inline-code-bg);
+    padding: 0.1em 0.35em;
+    border-radius: 4px;
+    border: none;
+    overflow-wrap: break-word;
+}
+
+pre code {
+    background: transparent;
+    padding: 0;
+    border-radius: 0;
+    font-size: inherit;
+    color: inherit;
+}
+
+.article a.reference.external {
+    overflow-wrap: break-word;
+}
+
+.article code.docutils.literal span.pre,
+.article dl:not(.docutils) > dt span.pre {
+    white-space: normal;
+}
+
+.article dl:not(.docutils) > dt {
+    overflow-wrap: break-word;
+}
+
+/* ---- Blockquotes --------------------------------------------------- */
+
+blockquote {
+    margin: 1em 0;
+    padding: 0 1em;
+    border-left: 3px solid var(--border);
+    color: var(--text-secondary);
+}
+
+/* ---- Horizontal rule ----------------------------------------------- */
+
+hr {
+    border: 0;
+    border-top: 1px solid var(--border);
+    margin: 2em 0;
+}
+
+/* ---- In-content TOC (`.. contents::`) ----------------------------- */
+
+/* basic.css wraps these in a 1px #ccc border with padding; drop the
+   border so the list reads as native prose. */
+.article aside.topic,
+.article div.topic,
+.article nav.contents {
+    border: 0;
+    padding: 0;
+    background: transparent;
+}
diff --git a/docs/_static/css/versions.css b/docs/_static/css/versions.css
new file mode 100644
index 0000000000..922994a19f
--- /dev/null
+++ b/docs/_static/css/versions.css
@@ -0,0 +1,141 @@
+/* Version selector in the topbar. */
+
+.topbar-versions {
+    position: relative;
+    user-select: none;
+}
+
+.topbar-versions > summary {
+    display: inline-flex;
+    align-items: center;
+    gap: 5px;
+    height: 32px;
+    padding: 0 8px;
+    border-radius: 6px;
+    color: var(--sidebar-fg);
+    font-size: 0.95rem;
+    font-weight: 600;
+    line-height: 1;
+    cursor: pointer;
+    list-style: none;
+    transition: background 0.15s, color 0.15s;
+}
+
+.topbar-versions > summary::-webkit-details-marker {
+    display: none;
+}
+
+.topbar-versions > summary::before {
+    content: "\f02b";
+    font-family: "Font Awesome 7 Free";
+    font-weight: 900;
+    font-size: 0.9em;
+    opacity: 0.85;
+}
+
+.topbar-versions > summary:hover,
+.topbar-versions[open] > summary {
+    background: var(--bg-hover-on-dark);
+    color: #ffffff;
+}
+
+.topbar-versions > summary::after {
+    content: "\f077";
+    font-family: "Font Awesome 7 Free";
+    font-weight: 900;
+    font-size: 0.7em;
+    opacity: 0.9;
+    transform: rotate(180deg);
+    transition: transform 0.15s;
+}
+
+.topbar-versions[open] > summary::after {
+    transform: rotate(0deg);
+}
+
+.topbar-versions-menu {
+    position: absolute;
+    top: calc(100% + 6px);
+    right: 0;
+    z-index: 200;
+    min-width: 168px;
+    padding: 6px 0;
+    border: 1px solid var(--border);
+    border-radius: 8px;
+    background: var(--bg);
+    box-shadow:
+        0 0 6px rgba(0, 0, 0, 0.06),
+        0 2px 8px rgba(0, 0, 0, 0.1),
+        0 8px 24px rgba(0, 0, 0, 0.16);
+}
+
+[data-theme="dark"] .topbar-versions-menu {
+    border-color: rgba(255, 255, 255, 0.14);
+    background: var(--surface-raised);
+    box-shadow: 0 2px 10px rgba(0, 0, 0, 0.5), 0 10px 28px rgba(0, 0, 0, 0.6);
+}
+
+[data-theme="dark"] .topbar-versions-sep {
+    border-top-color: rgba(255, 255, 255, 0.1);
+}
+
+.topbar-versions-sep {
+    height: 0;
+    margin: 5px 0;
+    border: 0;
+    border-top: 1px solid var(--border);
+}
+
+.topbar-versions-menu .topbar-versions-item,
+.topbar-versions-menu .topbar-versions-item:visited {
+    display: flex;
+    align-items: baseline;
+    gap: 7px;
+    padding: 5px 14px;
+    color: var(--text);
+    font-size: 0.88rem;
+    text-decoration: none;
+}
+
+.topbar-versions-name {
+    font-weight: 600;
+}
+
+.topbar-versions-item:hover {
+    background: var(--bg-hover);
+    text-decoration: none;
+}
+
+.topbar-versions-note {
+    margin-left: auto;
+    padding-left: 18px;
+    color: var(--text-muted);
+    font-size: 0.76rem;
+}
+
+.topbar-versions-menu {
+    max-width: calc(100vw - 24px);
+}
+
+@media (max-width: 1024px) {
+    .topbar-versions > summary {
+        padding: 0 8px;
+    }
+}
+
+@media (max-width: 600px) {
+    .topbar-versions > summary::before {
+        display: none;
+    }
+}
+
+@media (pointer: coarse) {
+    .topbar-versions > summary {
+        height: 44px;
+    }
+
+    .topbar-versions-menu .topbar-versions-item {
+        padding-top: 9px;
+        padding-bottom: 9px;
+    }
+}
diff --git a/docs/_static/favicon.ico b/docs/_static/favicon.ico
deleted file mode 100644
index c9efc5844a..0000000000
Binary files a/docs/_static/favicon.ico and /dev/null differ
diff --git a/docs/_static/fonts/README.txt b/docs/_static/fonts/README.txt
new file mode 100644
index 0000000000..748ac393e2
--- /dev/null
+++ b/docs/_static/fonts/README.txt
@@ -0,0 +1,23 @@
+Self-hosted web fonts (latin subset), wired up in ../css/fonts.css.
+
+All three families are licensed under the SIL Open Font License 1.1.
+The full license text ships with each upstream project (linked below);
+see also https://openfontlicense.org.
+
+- Inter
+  Copyright (c) The Inter Project Authors.
+  https://github.com/rsms/inter
+
+- JetBrains Mono
+  Copyright (c) The JetBrains Mono Project Authors.
+  https://github.com/JetBrains/JetBrainsMono
+
+- Merriweather
+  Copyright (c) The Merriweather Project Authors.
+  https://github.com/SorkinType/Merriweather
+
+Files were generated from the Google Fonts css2 API (latin unicode-range
+only), then trimmed of unused OpenType features with pyftsubset:
+
+  pyftsubset FONT.woff2 --unicodes='*' --layout-features='kern,liga,tnum' \
+    --no-hinting --flavor=woff2 --output-file=FONT.woff2
diff --git a/docs/_static/fonts/fa-brands-subset.woff2 b/docs/_static/fonts/fa-brands-subset.woff2
new file mode 100644
index 0000000000..de928e846f
Binary files /dev/null and b/docs/_static/fonts/fa-brands-subset.woff2 differ
diff --git a/docs/_static/fonts/fa-regular-subset.woff2 b/docs/_static/fonts/fa-regular-subset.woff2
new file mode 100644
index 0000000000..e5fa8b9b4d
Binary files /dev/null and b/docs/_static/fonts/fa-regular-subset.woff2 differ
diff --git a/docs/_static/fonts/fa-solid-subset.woff2 b/docs/_static/fonts/fa-solid-subset.woff2
new file mode 100644
index 0000000000..73e4b7d2fc
Binary files /dev/null and b/docs/_static/fonts/fa-solid-subset.woff2 differ
diff --git a/docs/_static/fonts/inter-400.woff2 b/docs/_static/fonts/inter-400.woff2
new file mode 100644
index 0000000000..03cc794e7b
Binary files /dev/null and b/docs/_static/fonts/inter-400.woff2 differ
diff --git a/docs/_static/fonts/inter-500.woff2 b/docs/_static/fonts/inter-500.woff2
new file mode 100644
index 0000000000..03cc794e7b
Binary files /dev/null and b/docs/_static/fonts/inter-500.woff2 differ
diff --git a/docs/_static/fonts/inter-600.woff2 b/docs/_static/fonts/inter-600.woff2
new file mode 100644
index 0000000000..03cc794e7b
Binary files /dev/null and b/docs/_static/fonts/inter-600.woff2 differ
diff --git a/docs/_static/fonts/inter-700.woff2 b/docs/_static/fonts/inter-700.woff2
new file mode 100644
index 0000000000..03cc794e7b
Binary files /dev/null and b/docs/_static/fonts/inter-700.woff2 differ
diff --git a/docs/_static/fonts/jetbrains-mono-400.woff2 b/docs/_static/fonts/jetbrains-mono-400.woff2
new file mode 100644
index 0000000000..28f3f7322a
Binary files /dev/null and b/docs/_static/fonts/jetbrains-mono-400.woff2 differ
diff --git a/docs/_static/fonts/jetbrains-mono-600.woff2 b/docs/_static/fonts/jetbrains-mono-600.woff2
new file mode 100644
index 0000000000..28f3f7322a
Binary files /dev/null and b/docs/_static/fonts/jetbrains-mono-600.woff2 differ
diff --git a/docs/_static/fonts/merriweather-400-italic.woff2 b/docs/_static/fonts/merriweather-400-italic.woff2
new file mode 100644
index 0000000000..b2d66cb8dc
Binary files /dev/null and b/docs/_static/fonts/merriweather-400-italic.woff2 differ
diff --git a/docs/_static/fonts/merriweather-400.woff2 b/docs/_static/fonts/merriweather-400.woff2
new file mode 100644
index 0000000000..a3298284c5
Binary files /dev/null and b/docs/_static/fonts/merriweather-400.woff2 differ
diff --git a/docs/_static/fonts/merriweather-700.woff2 b/docs/_static/fonts/merriweather-700.woff2
new file mode 100644
index 0000000000..a3298284c5
Binary files /dev/null and b/docs/_static/fonts/merriweather-700.woff2 differ
diff --git a/docs/_static/images/about/backtotop.png b/docs/_static/images/about/backtotop.png
new file mode 100644
index 0000000000..3d006afda6
Binary files /dev/null and b/docs/_static/images/about/backtotop.png differ
diff --git a/docs/_static/images/about/clickable.png b/docs/_static/images/about/clickable.png
new file mode 100644
index 0000000000..1edb323020
Binary files /dev/null and b/docs/_static/images/about/clickable.png differ
diff --git a/docs/_static/images/about/copy.png b/docs/_static/images/about/copy.png
new file mode 100644
index 0000000000..cdfa4fd5fd
Binary files /dev/null and b/docs/_static/images/about/copy.png differ
diff --git a/docs/_static/images/about/copypage.png b/docs/_static/images/about/copypage.png
new file mode 100644
index 0000000000..43e111a94c
Binary files /dev/null and b/docs/_static/images/about/copypage.png differ
diff --git a/docs/_static/images/about/darkmode-dark.png b/docs/_static/images/about/darkmode-dark.png
new file mode 100644
index 0000000000..0778c80da2
Binary files /dev/null and b/docs/_static/images/about/darkmode-dark.png differ
diff --git a/docs/_static/images/about/darkmode-light.png b/docs/_static/images/about/darkmode-light.png
new file mode 100644
index 0000000000..8074c42a1c
Binary files /dev/null and b/docs/_static/images/about/darkmode-light.png differ
diff --git a/docs/_static/images/about/mobile.png b/docs/_static/images/about/mobile.png
new file mode 100644
index 0000000000..dfd46485d3
Binary files /dev/null and b/docs/_static/images/about/mobile.png differ
diff --git a/docs/_static/images/about/search.png b/docs/_static/images/about/search.png
new file mode 100644
index 0000000000..60e05a4f0f
Binary files /dev/null and b/docs/_static/images/about/search.png differ
diff --git a/docs/_static/images/about/toc.png b/docs/_static/images/about/toc.png
new file mode 100644
index 0000000000..9c812a2d8a
Binary files /dev/null and b/docs/_static/images/about/toc.png differ
diff --git a/docs/_static/images/about/versions.png b/docs/_static/images/about/versions.png
new file mode 100644
index 0000000000..d4e8992ded
Binary files /dev/null and b/docs/_static/images/about/versions.png differ
diff --git a/docs/_static/images/favicon.svg b/docs/_static/images/favicon.svg
new file mode 100644
index 0000000000..65a8a36c53
--- /dev/null
+++ b/docs/_static/images/favicon.svg
@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">
+  <rect x="3"  y="20" width="17" height="38" rx="3.5" fill="#4a90b8"/>
+  <rect x="24" y="6"  width="17" height="52" rx="3.5" fill="#e8a830"/>
+  <rect x="45" y="28" width="17" height="30" rx="3.5" fill="#707070"/>
+</svg>
diff --git a/docs/_static/images/icon-cpu.svg b/docs/_static/images/icon-cpu.svg
new file mode 100644
index 0000000000..59a2c5e107
--- /dev/null
+++ b/docs/_static/images/icon-cpu.svg
@@ -0,0 +1,16 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+  <style>* { stroke: #2980b9; }</style>
+  <rect x="6" y="6" width="12" height="12" rx="2"/>
+  <line x1="9"  y1="6"  x2="9"  y2="3"/>
+  <line x1="12" y1="6"  x2="12" y2="3"/>
+  <line x1="15" y1="6"  x2="15" y2="3"/>
+  <line x1="9"  y1="18" x2="9"  y2="21"/>
+  <line x1="12" y1="18" x2="12" y2="21"/>
+  <line x1="15" y1="18" x2="15" y2="21"/>
+  <line x1="6"  y1="9"  x2="3"  y2="9"/>
+  <line x1="6"  y1="12" x2="3"  y2="12"/>
+  <line x1="6"  y1="15" x2="3"  y2="15"/>
+  <line x1="18" y1="9"  x2="21" y2="9"/>
+  <line x1="18" y1="12" x2="21" y2="12"/>
+  <line x1="18" y1="15" x2="21" y2="15"/>
+</svg>
diff --git a/docs/_static/images/icon-disks.svg b/docs/_static/images/icon-disks.svg
new file mode 100644
index 0000000000..9eacdf03cc
--- /dev/null
+++ b/docs/_static/images/icon-disks.svg
@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#2980b9">
+  <!-- FontAwesome 4.7.0 hdd-o (\f0a0), path scaled and centered
+       into a 24x24 box to match the other home icons. -->
+  <g transform="translate(1 2.83) scale(0.01432) translate(0 1280) scale(1 -1)">
+    <path d="M1040 320q0 -33 -23.5 -56.5t-56.5 -23.5t-56.5 23.5t-23.5 56.5t23.5 56.5t56.5 23.5t56.5 -23.5t23.5 -56.5zM1296 320q0 -33 -23.5 -56.5t-56.5 -23.5t-56.5 23.5t-23.5 56.5t23.5 56.5t56.5 23.5t56.5 -23.5t23.5 -56.5zM1408 160v320q0 13 -9.5 22.5t-22.5 9.5h-1216q-13 0 -22.5 -9.5t-9.5 -22.5v-320q0 -13 9.5 -22.5t22.5 -9.5h1216q13 0 22.5 9.5t9.5 22.5zM178 640h1180l-157 482q-4 13 -16 21.5t-26 8.5h-782q-14 0 -26 -8.5t-16 -21.5zM1536 480v-320q0 -66 -47 -113t-113 -47h-1216q-66 0 -113 47t-47 113v320q0 25 16 75l197 606q17 53 63 86t101 33h782q55 0 101 -33t63 -86l197 -606q16 -50 16 -75z"/>
+  </g>
+</svg>
diff --git a/docs/_static/images/icon-memory.svg b/docs/_static/images/icon-memory.svg
new file mode 100644
index 0000000000..e499ac5aa1
--- /dev/null
+++ b/docs/_static/images/icon-memory.svg
@@ -0,0 +1,19 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke-width="1.3" stroke-linecap="round" stroke-linejoin="round">
+  <style>* { stroke: #2980b9; }</style>
+  <rect x="1" y="4" width="22" height="13" rx="1.5"/>
+  <rect x="3"  y="7.5" width="3" height="6" rx="0.5"/>
+  <rect x="8"  y="7.5" width="3" height="6" rx="0.5"/>
+  <rect x="13" y="7.5" width="3" height="6" rx="0.5"/>
+  <rect x="18" y="7.5" width="3" height="6" rx="0.5"/>
+  <line x1="2"    y1="17" x2="2"    y2="19"/>
+  <line x1="4.2"  y1="17" x2="4.2"  y2="19"/>
+  <line x1="6.4"  y1="17" x2="6.4"  y2="19"/>
+  <line x1="8.6"  y1="17" x2="8.6"  y2="19"/>
+  <line x1="10.8" y1="17" x2="10.8" y2="19"/>
+  <line x1="13.2" y1="17" x2="13.2" y2="19"/>
+  <line x1="15.4" y1="17" x2="15.4" y2="19"/>
+  <line x1="17.6" y1="17" x2="17.6" y2="19"/>
+  <line x1="19.8" y1="17" x2="19.8" y2="19"/>
+  <line x1="22"   y1="17" x2="22"   y2="19"/>
+  <line x1="2"    y1="19.5" x2="22" y2="19.5"/>
+</svg>
diff --git a/docs/_static/images/icon-network.svg b/docs/_static/images/icon-network.svg
new file mode 100644
index 0000000000..4abfa54c31
--- /dev/null
+++ b/docs/_static/images/icon-network.svg
@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+  <style>* { stroke: #2980b9; }</style>
+  <circle cx="12" cy="12" r="10"/>
+  <line x1="2" y1="12" x2="22" y2="12"/>
+  <path d="M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z"/>
+</svg>
diff --git a/docs/_static/images/icon-processes.svg b/docs/_static/images/icon-processes.svg
new file mode 100644
index 0000000000..90b94bf577
--- /dev/null
+++ b/docs/_static/images/icon-processes.svg
@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+  <style>* { stroke: #2980b9; }</style>
+  <line x1="8"  y1="6"  x2="21" y2="6"/>
+  <line x1="8"  y1="12" x2="21" y2="12"/>
+  <line x1="8"  y1="18" x2="21" y2="18"/>
+  <circle cx="3.5" cy="6"  r="1"/>
+  <circle cx="3.5" cy="12" r="1"/>
+  <circle cx="3.5" cy="18" r="1"/>
+</svg>
diff --git a/docs/_static/images/icon-sensors.svg b/docs/_static/images/icon-sensors.svg
new file mode 100644
index 0000000000..2b1ccb0eb3
--- /dev/null
+++ b/docs/_static/images/icon-sensors.svg
@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="#2980b9">
+  <!-- FontAwesome 4.7.0 thermometer-half (\f2c9), path scaled and
+       centered into a 24x24 box to match the other home icons. -->
+  <g transform="translate(5.713 1) scale(0.01228) translate(0 1536) scale(1 -1)">
+    <path d="M640 192q0 -80 -56 -136t-136 -56t-136 56t-56 136q0 60 35 110t93 71v395h128v-395q58 -21 93 -71t35 -110zM768 192q0 77 -34 144t-94 112v768q0 80 -56 136t-136 56t-136 -56t-56 -136v-768q-60 -45 -94 -112t-34 -144q0 -133 93.5 -226.5t226.5 -93.5t226.5 93.5t93.5 226.5zM896 192q0 -185 -131.5 -316.5t-316.5 -131.5t-316.5 131.5t-131.5 316.5q0 182 128 313v711q0 133 93.5 226.5t226.5 93.5t226.5 -93.5t93.5 -226.5v-711q128 -131 128 -313zM1024 768v-128h-192v128h192zM1024 1024v-128h-192v128h192zM1024 1280v-128h-192v128h192z"/>
+  </g>
+</svg>
diff --git a/docs/_static/images/logo-apivoid.svg b/docs/_static/images/logo-apivoid.svg
new file mode 100644
index 0000000000..49ebb25cd8
--- /dev/null
+++ b/docs/_static/images/logo-apivoid.svg
@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0 0 400 120">
+  <defs>
+    <style>.a-dark{fill:#130f40;}:root[data-theme="dark"] .a-dark{fill:#c8cad0;}</style>
+    <linearGradient id="a">
+      <stop offset="0" stop-color="#ee5b24"/>
+      <stop offset=".5" stop-color="#f38321"/>
+      <stop offset="1" stop-color="#f79e1f"/>
+    </linearGradient>
+    <linearGradient xlink:href="#a" id="b" x1="416.183" x2="416.183" y1="409.143" y2="267.974" gradientTransform="matrix(.79919 0 0 .79919 -253.764 -207.28)" gradientUnits="userSpaceOnUse"/>
+  </defs>
+  <path fill="url(#b)" d="M149.65 6.916c-2.023 0-3.802.769-5.339 2.306-1.456 1.456-2.183 3.235-2.183 5.338s.727 3.884 2.183 5.34c1.537 1.456 3.316 2.184 5.339 2.184 2.103 0 3.883-.728 5.34-2.184 1.536-1.456 2.305-3.237 2.305-5.34 0-2.103-.769-3.882-2.306-5.338-1.456-1.537-3.236-2.306-5.34-2.306zm0 22.568c-2.023 0-3.802.769-5.339 2.306-1.456 1.456-2.183 3.196-2.183 5.218v45.864c0 2.022.727 3.802 2.183 5.338 1.537 1.456 3.316 2.186 5.339 2.186 2.103 0 3.883-.73 5.34-2.186 1.536-1.536 2.305-3.316 2.305-5.338V37.008c0-2.022-.769-3.762-2.306-5.218-1.456-1.537-3.236-2.306-5.34-2.306zm-70.234.122c-2.022 0-3.801.768-5.338 2.305-1.456 1.456-2.185 3.236-2.185 5.339v75.106c0 2.103.729 3.884 2.185 5.34 1.537 1.537 3.316 2.304 5.338 2.304 2.103 0 3.883-.767 5.339-2.304 1.536-1.456 2.305-3.237 2.305-5.34V86.148c4.692 2.75 9.748 4.126 15.167 4.126 8.413 0 15.572-2.953 21.477-8.858 5.905-5.905 8.857-13.064 8.857-21.477 0-8.332-2.952-15.45-8.857-21.355-5.905-5.986-13.064-8.978-21.477-8.978zm-49.081.122c-8.413 0-15.572 2.951-21.477 8.856C2.953 44.49 0 51.648 0 60.061c0 8.331 2.953 15.45 8.858 21.355 5.905 5.905 13.023 8.899 21.355 8.98h22.931c2.023 0 3.763-.73 5.219-2.186 1.537-1.537 2.305-3.316 2.305-5.338V60.061c0-8.413-2.953-15.572-8.858-21.477-5.905-5.905-13.063-8.856-21.475-8.856zm71.892 15.045c4.207 0 7.765 1.496 10.677 4.49 2.993 2.911 4.49 6.47 4.49 10.676s-1.497 7.807-4.49 10.8c-2.912 2.912-6.47 4.367-10.677 4.367-4.206 0-7.805-1.455-10.798-4.367-2.912-2.993-4.369-6.594-4.369-10.8s1.457-7.765 4.369-10.677c2.993-2.993 6.592-4.489 10.798-4.489zm-71.892.122c4.206 0 7.764 1.496 10.676 4.49 2.993 2.911 4.49 6.47 4.49 10.676s-1.497 7.805-4.49 10.798c-2.912 2.912-6.47 4.37-10.676 4.37s-7.807-1.458-10.8-4.37c-2.912-2.993-4.368-6.592-4.368-10.798 0-4.207 1.456-7.765 4.368-10.677 2.993-2.993 6.594-4.49 10.8-4.49z"/>
+  <path class="a-dark" d="M392.354 0c-2.022 0-3.801.769-5.338 2.306-1.456 1.456-2.184 3.235-2.184 5.338v26.21c-4.691-2.751-9.748-4.126-15.167-4.126-8.413 0-15.57 2.951-21.475 8.856-5.905 5.905-8.858 13.064-8.858 21.477 0 8.332 2.953 15.49 8.858 21.477 5.905 5.905 13.062 8.858 21.475 8.858h22.69c2.102 0 3.883-.73 5.34-2.186 1.536-1.536 2.305-3.357 2.305-5.46V7.644c0-2.103-.769-3.882-2.306-5.338C396.238.769 394.457 0 392.354 0Zm-72.462 6.916c-2.022 0-3.801.769-5.338 2.306-1.456 1.456-2.186 3.235-2.186 5.338s.73 3.884 2.186 5.34c1.537 1.456 3.316 2.184 5.338 2.184 2.103 0 3.882-.728 5.338-2.184 1.537-1.456 2.306-3.237 2.306-5.34 0-2.103-.769-3.882-2.306-5.338-1.456-1.537-3.235-2.306-5.338-2.306zm0 22.568c-2.022 0-3.801.769-5.338 2.306-1.456 1.456-2.186 3.196-2.186 5.218v45.864c0 2.022.73 3.802 2.186 5.338 1.537 1.456 3.316 2.186 5.338 2.186 2.103 0 3.882-.73 5.338-2.186 1.537-1.536 2.306-3.316 2.306-5.338V37.008c0-2.022-.769-3.762-2.306-5.218-1.456-1.537-3.235-2.306-5.338-2.306zm-142.418.244c-2.103 0-3.923.768-5.46 2.305-1.456 1.456-2.183 3.194-2.183 5.217 0 1.132.242 2.184.727 3.154l22.448 45.5c1.456 2.994 3.761 4.492 6.916 4.492 3.236 0 5.58-1.498 7.037-4.491l22.447-45.5c.485-.971.729-2.023.729-3.155 0-2.023-.769-3.76-2.306-5.217-1.456-1.537-3.236-2.305-5.34-2.305-3.154 0-5.458 1.496-6.914 4.489l-15.653 31.547-15.531-31.547c-1.456-2.993-3.762-4.49-6.917-4.49zm93.003 0c-8.413 0-15.572 2.951-21.477 8.856-5.905 5.905-8.856 13.064-8.856 21.477 0 8.412 2.951 15.571 8.856 21.476 5.905 5.905 13.064 8.859 21.477 8.859 8.412 0 15.571-2.954 21.476-8.859 5.905-5.905 8.857-13.064 8.857-21.476 0-8.413-2.952-15.572-8.857-21.477-5.905-5.905-13.064-8.856-21.476-8.856zm0 15.167c4.206 0 7.766 1.496 10.678 4.49 2.993 2.911 4.49 6.47 4.49 10.676s-1.497 7.805-4.49 10.798c-2.912 2.912-6.472 4.37-10.678 4.37-4.207 0-7.806-1.458-10.799-4.37-2.912-2.993-4.369-6.592-4.369-10.798s1.457-7.765 4.37-10.677c2.992-2.993 6.591-4.489 10.798-4.489zm99.188 0c4.206 0 7.766 1.496 10.678 4.49 2.993 2.911 4.49 6.47 4.49 10.676s-1.497 7.805-4.49 10.798c-2.912 2.912-6.472 4.37-10.678 4.37s-7.806-1.458-10.799-4.37c-2.912-2.993-4.367-6.592-4.367-10.798s1.455-7.765 4.367-10.677c2.993-2.993 6.593-4.489 10.799-4.489z"/>
+</svg>
diff --git a/docs/_static/images/logo-psutil-readme.svg b/docs/_static/images/logo-psutil-readme.svg
new file mode 100644
index 0000000000..45ac91842f
--- /dev/null
+++ b/docs/_static/images/logo-psutil-readme.svg
@@ -0,0 +1,20 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="6 0 220 74" width="212" height="72">
+  <!-- support for bright / dark background -->
+  <style>
+    .bg       { fill: white; }
+    .wordmark { fill: #111111; }
+    @media (prefers-color-scheme: dark) {
+      .bg       { fill: transparent; }
+      .wordmark { fill: white; }
+    }
+  </style>
+  <rect class="bg" width="100%" height="100%"/>
+  <rect x="7"  y="25" width="16" height="38" rx="3" fill="#4a90b8"/>
+  <rect x="28" y="9"  width="16" height="54" rx="3" fill="#e8a830"/>
+  <rect x="50" y="34" width="16" height="29" rx="3" fill="#8a8a8a"/>
+  <text class="wordmark" x="76" y="62"
+        font-family="system-ui,-apple-system,'Segoe UI',Helvetica,Arial,sans-serif"
+        font-size="56"
+        font-weight="700"
+        letter-spacing="-0.7">psutil</text>
+</svg>
diff --git a/docs/_static/images/logo-psutil.png b/docs/_static/images/logo-psutil.png
new file mode 100644
index 0000000000..d02ab0af4f
Binary files /dev/null and b/docs/_static/images/logo-psutil.png differ
diff --git a/docs/_static/images/logo-psutil.svg b/docs/_static/images/logo-psutil.svg
new file mode 100644
index 0000000000..245e606bca
--- /dev/null
+++ b/docs/_static/images/logo-psutil.svg
@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 64 64">
+  <rect x="6"  y="22" width="14" height="34" rx="3" fill="#4a90b8"/>
+  <rect x="25" y="8"  width="14" height="48" rx="3" fill="#e8a830"/>
+  <rect x="44" y="30" width="14" height="26" rx="3" fill="#8a8a8a"/>
+</svg>
diff --git a/docs/_static/images/logo-sansec.svg b/docs/_static/images/logo-sansec.svg
new file mode 100644
index 0000000000..9fa30a4e0e
--- /dev/null
+++ b/docs/_static/images/logo-sansec.svg
@@ -0,0 +1 @@
+<svg viewBox="0 0 186 34.854" xmlns="http://www.w3.org/2000/svg"><style>.s-dark{fill:#1d2227;}:root[data-theme="dark"] .s-dark{fill:#c8cad0;}</style><g class="s-dark"><path d="m0 26.351 6.117-2.823c.941 2.319 2.756 4.5 5.983 4.5 2.252 0 4.3-1.109 4.3-3.731 0-2.017-1.109-2.958-4.336-4.235l-2.117-.807c-4.537-1.815-8.705-4.3-8.705-9.814.002-5.841 4.909-9.441 10.791-9.441a11.935 11.935 0 0 1 11.192 7.226l-5.579 3.159c-1.479-2.588-3.193-3.664-5.31-3.664-2.05 0-3.63.941-3.63 2.857 0 1.479.874 2.622 4.4 4.067l2.286.907c6.117 2.386 8.84 5.176 8.84 9.848 0 7.058-6.319 10.453-12.033 10.453-5.981.001-10.922-3.528-12.199-8.502z"/><path d="m80.7 39.906c0-8.671 6.218-12.906 11.864-12.906 4.4 0 6.991 2.386 7.361 3.294h.134v-2.823h7.394v24.838h-7.393v-2.824h-.134c-.37.907-2.958 3.294-7.361 3.294-5.647 0-11.865-4.235-11.865-12.873zm19.528 0a6.1 6.1 0 1 0 -12.2 0 6.1 6.1 0 1 0 12.2 0z" transform="translate(-53.576 -17.925)"/><path d="m199.7 37.688v14.621h-7.4v-13.309c0-3.092-1.58-5.411-4.638-5.411-2.991 0-4.571 2.286-4.571 5.411v13.31h-7.391v-24.839h7.394v3.159a8.293 8.293 0 0 1 7.327-3.63c5.008 0 9.279 3.092 9.279 10.688z" transform="translate(-116.647 -17.925)"/><path d="m257.6 45.655 5.882-1.58a3.591 3.591 0 0 0 3.6 2.857c1.344 0 2.588-.672 2.588-2.05 0-.807-.471-1.58-2.117-2.117l-3.327-1.244c-4.1-1.479-5.882-4.168-5.882-7.26 0-4.638 4.168-7.361 9.041-7.361 4.672 0 8.066 2.622 8.94 6.655l-5.819 1.445a2.888 2.888 0 0 0 -2.857-2.353c-1.445 0-2.151.874-2.151 1.714 0 .807.471 1.58 2.151 2.117l3.092 1.143c2.689.907 6.218 2.756 6.218 7.26 0 5.008-4.235 7.831-9.781 7.831-5.041.001-8.805-2.318-9.578-7.057z" transform="translate(-171.02 -17.859)"/><path d="m347.171 42.763h-17.679c1.008 2.689 3.5 4 6.789 4a9.5 9.5 0 0 0 5.983-1.916l3.327 3.5a12.629 12.629 0 0 1 -10.117 4.437c-6.89 0-13.074-4.672-13.074-12.839 0-8.4 6.252-12.94 12.671-12.94 6.285-.005 13.68 4.395 12.1 15.758zm-17.814-5.31h11.327a5.345 5.345 0 0 0 -5.546-4.235 5.693 5.693 0 0 0 -5.781 4.235z" transform="translate(-214.04 -17.925)"/></g><path d="m505.48 31.2a12.836 12.836 0 0 0 -9.68-4.4v25.813a12.836 12.836 0 0 0 9.68-4.4 12.818 12.818 0 0 1 0-17.007z" fill="#00a19a" transform="translate(-329.16 -17.792)"/><path d="m524.6 31.2a12.818 12.818 0 0 1 0 17.007 12.836 12.836 0 0 0 9.68 4.4v-25.807a12.89 12.89 0 0 0 -9.68 4.4z" fill="#fc0" transform="translate(-348.28 -17.792)"/><path d="m518.227 39.9a12.819 12.819 0 0 0 0 17.007 12.818 12.818 0 0 0 0-17.007z" fill="#3f1f71" transform="translate(-341.906 -26.489)"/><path class="s-dark" d="m425.175 48.376a13.086 13.086 0 0 1 -2.722-4.974 6.412 6.412 0 0 1 -5.21 2.722 5.886 5.886 0 0 1 -5.915-6.252 5.857 5.857 0 0 1 5.915-6.151 6.458 6.458 0 0 1 5.176 2.689 12.879 12.879 0 0 1 2.756-5.075c.235-.269.5-.538.773-.807a11.972 11.972 0 0 0 -8.705-3.528c-6.655 0-13.243 4.437-13.243 12.839 0 8.5 6.588 12.94 13.242 12.94a12.11 12.11 0 0 0 8.739-3.6z" transform="translate(-268.214 -17.925)"/></svg>
\ No newline at end of file
diff --git a/docs/_static/images/logo-tidelift.svg b/docs/_static/images/logo-tidelift.svg
new file mode 100644
index 0000000000..448dd7a081
--- /dev/null
+++ b/docs/_static/images/logo-tidelift.svg
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 21.1.0, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
+<svg version="1.1" id="Artwork" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
+	 viewBox="2 2 187 29" xml:space="preserve">
+<style type="text/css">
+	.st0{fill:#4B5168;}
+	.st1{fill:#F6914D;}
+	:root[data-theme="dark"] .st0{fill:#c8cad0;}
+</style>
+<g>
+	<path class="st0" d="M33.4,27.7V5.3c0-2.3,0-2.3,2.4-2.3c2.4,0,2.4,0,2.4,2.3v22.4c0,2.3,0,2.3-2.4,2.3
+		C33.4,29.9,33.4,29.9,33.4,27.7z"/>
+	<path class="st0" d="M45,26.4V6.6c0-3.6,0-3.6,3.6-3.6h5.8c7.8,0,12.5,3.9,13,10.2c0.2,2.2,0.2,3.4,0,5.5
+		c-0.5,6.3-5.3,11.2-13,11.2h-5.8C45,29.9,45,29.9,45,26.4z M54.3,25.4c5.3,0,8-3,8.3-7.1c0.1-1.8,0.1-2.8,0-4.6
+		c-0.3-4.2-3-6.1-8.3-6.1h-4.5v17.8H54.3z"/>
+	<path class="st0" d="M73.8,26.4V6.6c0-3.6,0-3.6,3.6-3.6h13.5c2.3,0,2.3,0,2.3,2.2c0,2.2,0,2.2-2.3,2.2H78.6v6.9h11
+		c2.2,0,2.2,0,2.2,2.1c0,2.1,0,2.1-2.2,2.1h-11v6.9h12.3c2.3,0,2.3,0,2.3,2.2c0,2.3,0,2.3-2.3,2.3H77.4
+		C73.8,29.9,73.8,29.9,73.8,26.4z"/>
+	<path class="st0" d="M100,26.4v-21c0-2.3,0-2.3,2.4-2.3c2.4,0,2.4,0,2.4,2.3v20.2h11.9c2.4,0,2.4,0,2.4,2.2c0,2.2,0,2.2-2.4,2.2
+		h-13.1C100,29.9,100,29.9,100,26.4z"/>
+	<path class="st0" d="M125.8,27.7V5.3c0-2.3,0-2.3,2.4-2.3c2.4,0,2.4,0,2.4,2.3v22.4c0,2.3,0,2.3-2.4,2.3
+		C125.8,29.9,125.8,29.9,125.8,27.7z"/>
+	<path class="st0" d="M137.4,27.7V6.6c0-3.6,0-3.6,3.6-3.6h13.5c2.3,0,2.3,0,2.3,2.2c0,2.2,0,2.2-2.3,2.2h-12.2v7.2h11.3
+		c2.3,0,2.3,0,2.3,2.2c0,2.2,0,2.2-2.3,2.2h-11.3v8.6c0,2.3,0,2.3-2.4,2.3S137.4,29.9,137.4,27.7z"/>
+	<path class="st0" d="M24.2,3.1H5.5c-2.4,0-2.4,0-2.4,2.2c0,2.2,0,2.2,2.4,2.2h7v4.7v3.2l4.8-3.7v-1.1V7.5h7c2.4,0,2.4,0,2.4-2.2
+		C26.6,3.1,26.6,3.1,24.2,3.1z"/>
+	<path class="st1" d="M12.5,20v7.6c0,2.3,0,2.3,2.4,2.3c2.4,0,2.4,0,2.4-2.3V16.3L12.5,20z"/>
+	<g>
+		<path class="st0" d="M165.9,3.1h18.7c2.4,0,2.4,0,2.4,2.2c0,2.2,0,2.2-2.4,2.2h-7v4.7v3.2l-4.8-3.7v-1.1V7.5h-7
+			c-2.4,0-2.4,0-2.4-2.2C163.5,3.1,163.5,3.1,165.9,3.1z"/>
+		<path class="st1" d="M177.6,20v7.6c0,2.3,0,2.3-2.4,2.3c-2.4,0-2.4,0-2.4-2.3V16.3L177.6,20z"/>
+	</g>
+</g>
+</svg>
diff --git a/docs/_static/images/rss.svg b/docs/_static/images/rss.svg
new file mode 100644
index 0000000000..cdb14648b1
--- /dev/null
+++ b/docs/_static/images/rss.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><path d="M0 64C0 46.3 14.3 32 32 32c229.8 0 416 186.2 416 416 0 17.7-14.3 32-32 32s-32-14.3-32-32C384 253.6 226.4 96 32 96 14.3 96 0 81.7 0 64zM0 416a64 64 0 1 1 128 0 64 64 0 1 1-128 0zM32 160c159.1 0 288 128.9 288 288 0 17.7-14.3 32-32 32s-32-14.3-32-32c0-123.7-100.3-224-224-224-17.7 0-32-14.3-32-32s14.3-32 32-32z"/></svg>
diff --git a/docs/_static/js/back-to-top.js b/docs/_static/js/back-to-top.js
new file mode 100644
index 0000000000..5eaf3ea0a6
--- /dev/null
+++ b/docs/_static/js/back-to-top.js
@@ -0,0 +1,52 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Floating "back to top" button. Appears when the user has scrolled
+// down and is moving back up; hidden again at the top of the page.
+
+(function () {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "back-to-top";
+    btn.setAttribute("aria-label", "Back to top");
+    btn.title = "Back to top";
+    // Hidden at rest via opacity, which doesn't remove it from the tab
+    // order; keep it unfocusable until the scroll handler shows it.
+    btn.tabIndex = -1;
+    btn.innerHTML =
+        '<i class="fa-solid fa-chevron-up" aria-hidden="true"></i>';
+    // Faster than the browser's default smooth scroll (which can take
+    // ~1s on long pages). Custom 300ms ease-out animation.
+    btn.addEventListener("click", () => {
+        if (window.matchMedia("(prefers-reduced-motion: reduce)").matches) {
+            window.scrollTo(0, 0);
+            return;
+        }
+        const start = window.scrollY;
+        const t0 = performance.now();
+        function step(now) {
+            const t = Math.min((now - t0) / 300, 1);
+            const eased = 1 - Math.pow(1 - t, 3);
+            window.scrollTo(0, start * (1 - eased));
+            if (t < 1) {
+                requestAnimationFrame(step);
+            }
+        }
+        requestAnimationFrame(step);
+    });
+    document.body.appendChild(btn);
+
+    // Show only while scrolling UP (and past the threshold); hide
+    // again on any downward scroll.
+    const SHOW_AFTER_PX = 400;
+    let lastY = window.scrollY;
+    window.addEventListener("scroll", () => {
+        const y = window.scrollY;
+        const goingUp = y < lastY;
+        const visible = goingUp && y > SHOW_AFTER_PX;
+        btn.classList.toggle("is-visible", visible);
+        btn.tabIndex = visible ? 0 : -1;
+        lastY = y;
+    }, { passive: true });
+})();
diff --git a/docs/_static/js/banner.js b/docs/_static/js/banner.js
new file mode 100644
index 0000000000..f6062367b1
--- /dev/null
+++ b/docs/_static/js/banner.js
@@ -0,0 +1,47 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Notice above the topbar. Archived releases inject the same markup
+// from build_versions.py, and those pages have no .header-stack.
+
+(function () {
+    const KEY = "psutil-banner";
+    const root = document.documentElement;
+    const banner = document.querySelector(".site-banner");
+    if (!banner) {
+        return;
+    }
+
+    // The banner is part of the fixed header and its text wraps, so
+    // the offset below it has to be measured, not hardcoded.
+    const stack = banner.closest(".header-stack");
+
+    function syncHeight() {
+        if (stack) {
+            root.style.setProperty(
+                "--header-height",
+                stack.offsetHeight + "px",
+            );
+        }
+    }
+
+    const close = banner.querySelector(".site-banner-close");
+    if (close) {
+        close.addEventListener("click", () => {
+            root.classList.add("site-banner-dismissed");
+            try {
+                localStorage.setItem(KEY, banner.dataset.bannerId || "");
+            }
+            catch (err) {
+                console.warn("banner: " + err.message);
+            }
+            syncHeight();
+        });
+    }
+
+    if (stack) {
+        new ResizeObserver(syncHeight).observe(stack);
+        syncHeight();
+    }
+})();
diff --git a/docs/_static/js/blog-comment-counts.js b/docs/_static/js/blog-comment-counts.js
new file mode 100644
index 0000000000..4b3e903e99
--- /dev/null
+++ b/docs/_static/js/blog-comment-counts.js
@@ -0,0 +1,53 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Comment counts on the blog listing.
+
+(function () {
+    const list = document.querySelector(".blog-cards[data-comments-repo]");
+    if (!list) {
+        return;
+    }
+
+    const repo = list.dataset.commentsRepo;
+    const url = "https://api.github.com/repos/" + repo +
+        "/discussions?per_page=100";
+
+    function render(discussions) {
+        const counts = new Map();
+        for (const disc of discussions) {
+            counts.set(disc.title, disc.comments);
+        }
+        for (const card of list.querySelectorAll(".blog-card[data-docname]")) {
+            const num = counts.get(card.dataset.docname);
+            if (!num) {
+                continue;
+            }
+            const meta = card.querySelector(".blog-card-meta");
+            if (!meta) {
+                continue;
+            }
+            const span = document.createElement("span");
+            span.className = "blog-card-comments";
+            span.textContent = "\u{1F4AC} " + num;
+            span.setAttribute(
+                "aria-label",
+                num === 1 ? "1 comment" : num + " comments",
+            );
+            meta.appendChild(span);
+        }
+    }
+
+    fetch(url, { headers: { Accept: "application/vnd.github+json" } })
+        .then((resp) => {
+            if (!resp.ok) {
+                throw new Error("HTTP " + resp.status);
+            }
+            return resp.json();
+        })
+        .then(render)
+        .catch((err) => {
+            console.warn("could not load blog comment counts:", err);
+        });
+})();
diff --git a/docs/_static/js/copy-page.js b/docs/_static/js/copy-page.js
new file mode 100644
index 0000000000..16d3ac807e
--- /dev/null
+++ b/docs/_static/js/copy-page.js
@@ -0,0 +1,86 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// "Copy page" button next to the h1: copies the page's RsT source, which
+// Sphinx publishes under _sources/.
+
+(function () {
+    const RESET_DELAY_MS = 2000;
+
+    const ICONS = `
+<svg class="copy-page-icon-copy" viewBox="0 0 24 24" width="12" height="12"
+     fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"
+     stroke-linejoin="round" aria-hidden="true">
+  <rect x="9" y="9" width="13" height="13" rx="2"></rect>
+  <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path>
+</svg>
+<svg class="copy-page-icon-check" viewBox="0 0 24 24" width="12" height="12"
+     fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round"
+     stroke-linejoin="round" aria-hidden="true">
+  <path d="M4 12.5l5.5 5.5L20 6"></path>
+</svg>`;
+
+    const SKIP = ["index", "404", "blog"];
+
+    const page = document.body.dataset.page;
+    const root = document.documentElement.dataset.content_root;
+    if (!page || !root || SKIP.includes(page)) {
+        return;
+    }
+    const h1 = document.querySelector(".article h1");
+    if (!h1) {
+        return;
+    }
+
+    const url = root + "_sources/" + page + ".rst.txt";
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "copy-page";
+    btn.title = "Copy this page as reStructuredText";
+    btn.innerHTML = '<span class="copy-page-icons">' + ICONS + "</span>" +
+        '<span class="copy-page-labels">' +
+        '<span class="copy-page-label-copy">Copy page</span>' +
+        '<span class="copy-page-label-done">Copied</span>' +
+        "</span>";
+
+    let busy = false;
+
+    function flash(state) {
+        btn.classList.add(state);
+        setTimeout(() => {
+            btn.classList.remove(state);
+            busy = false;
+        }, RESET_DELAY_MS);
+    }
+
+    btn.addEventListener("click", function () {
+        if (busy) {
+            return;
+        }
+        busy = true;
+        fetch(url)
+            .then((resp) => {
+                if (!resp.ok) {
+                    throw new Error(url + " returned " + resp.status);
+                }
+                return resp.text();
+            })
+            .then((text) => navigator.clipboard.writeText(text))
+            .then(() => flash("copied"))
+            .catch((err) => {
+                console.warn("copy-page: " + err.message);
+                flash("failed");
+            });
+    });
+
+    // Only offer it when the source is actually published; generated
+    // pages (genindex, search, blog archives) have none.
+    fetch(url, { method: "HEAD" })
+        .then((resp) => {
+            if (resp.ok) {
+                h1.appendChild(btn);
+            }
+        })
+        .catch(() => {});
+})();
diff --git a/docs/_static/js/external-urls.js b/docs/_static/js/external-urls.js
new file mode 100644
index 0000000000..e65e496b8f
--- /dev/null
+++ b/docs/_static/js/external-urls.js
@@ -0,0 +1,12 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Open all external URLs in a new tab.
+
+document.querySelectorAll("a[href^='http']").forEach((a) => {
+    if (a.hostname !== location.hostname) {
+        a.target = "_blank";
+        a.rel = "noopener noreferrer";
+    }
+});
diff --git a/docs/_static/js/giscus.js b/docs/_static/js/giscus.js
new file mode 100644
index 0000000000..76edae3073
--- /dev/null
+++ b/docs/_static/js/giscus.js
@@ -0,0 +1,124 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Blog comments, backed by giscus + GitHub Discussions.
+
+(function () {
+    const container = document.querySelector(".giscus");
+    if (!container) {
+        return;
+    }
+
+    const ORIGIN = "https://giscus.app";
+    const section = container.closest(".comments");
+    const url = new URL(container.dataset.themeUrl, location.href).href;
+    let sheet = null;
+    let ready = false;
+    let pushed = null;
+
+    function isDark() {
+        return document.documentElement.getAttribute("data-theme") === "dark";
+    }
+
+    // css/giscus.css branches on prefers-color-scheme, which inside
+    // giscus' iframe follows the reader's OS rather than our toggle.
+    // Swap the conditions for ones that are always (or never) true so
+    // the branch we want is the one that applies.
+    function themeFor(dark) {
+        const yes = "(min-width: 0px)";
+        const no = "(min-width: 99999px)";
+        const css = sheet
+            .replace(/\(prefers-color-scheme:\s*dark\)/g, dark ? yes : no)
+            .replace(/\(prefers-color-scheme:\s*light\)/g, dark ? no : yes);
+        return "data:text/css;base64," + btoa(css);
+    }
+
+    function inject() {
+        const attrs = {
+            "data-repo": container.dataset.repo,
+            "data-repo-id": container.dataset.repoId,
+            "data-category": container.dataset.category,
+            "data-category-id": container.dataset.categoryId,
+            // Thread key is the source path, not the URL.
+            "data-mapping": "specific",
+            "data-term": container.dataset.term,
+            // Without this giscus matches by fuzzy title search,
+            // and our terms all share a "blog/<year>/" prefix.
+            "data-strict": "1",
+            "data-reactions-enabled": "1",
+            "data-emit-metadata": "0",
+            "data-input-position": "top",
+            "data-theme": sheet ? themeFor(isDark()) : url,
+            "data-lang": "en",
+            "data-loading": "lazy",
+        };
+        pushed = isDark();
+
+        const script = document.createElement("script");
+        script.src = ORIGIN + "/client.js";
+        script.crossOrigin = "anonymous";
+        script.async = true;
+        Object.keys(attrs).forEach((name) => {
+            script.setAttribute(name, attrs[name]);
+        });
+        // A blocked script fires "error", not "load", so the section
+        // stays hidden rather than showing an empty widget.
+        script.addEventListener("load", () => {
+            if (section) {
+                section.removeAttribute("hidden");
+            }
+        });
+        container.appendChild(script);
+    }
+
+    function push() {
+        if (!ready || !sheet || isDark() === pushed) {
+            return;
+        }
+        const frame = document.querySelector("iframe.giscus-frame");
+        if (!frame || !frame.contentWindow) {
+            return;
+        }
+        const dark = isDark();
+        frame.contentWindow.postMessage(
+            { giscus: { setConfig: { theme: themeFor(dark) } } },
+            ORIGIN,
+        );
+        pushed = dark;
+    }
+
+    new MutationObserver(push).observe(document.documentElement, {
+        attributes: true,
+        attributeFilter: ["data-theme"],
+    });
+
+    // contentWindow exists well before giscus can receive messages,
+    // so wait for it to talk to us first.
+    window.addEventListener("message", (event) => {
+        if (event.origin !== ORIGIN || !event.data || !event.data.giscus) {
+            return;
+        }
+        ready = true;
+        push();
+    });
+
+    // giscus fetches its theme with crossorigin="anonymous", which
+    // needs CORS headers and is blocked outright from localhost.
+    // Inlining it sidesteps both: this fetch is same-origin.
+    fetch(url)
+        .then((resp) => {
+            if (!resp.ok) {
+                throw new Error(resp.status);
+            }
+            return resp.text();
+        })
+        .then((css) => {
+            sheet = css;
+        })
+        .catch((err) => {
+            // Fall back to the URL, fine wherever CORS allows it.
+            console.warn("giscus: inlining theme failed:", err);
+        })
+        .finally(inject);
+})();
diff --git a/docs/_static/js/github-meta.js b/docs/_static/js/github-meta.js
new file mode 100644
index 0000000000..d782afff10
--- /dev/null
+++ b/docs/_static/js/github-meta.js
@@ -0,0 +1,66 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Fills in the star count from the GitHub API. Result is cached in
+// sessionStorage for an hour to avoid hitting the rate limit on every
+// page navigation.
+
+(function () {
+    const REPO = "giampaolo/psutil";
+    const CACHE_KEY = "psutil-gh-meta";
+    const CACHE_TTL_MS = 60 * 60 * 1000;
+
+    function applyValues(stars) {
+        const s = document.querySelector(".topbar-stars");
+        if (s && stars) {
+            s.textContent = stars;
+        }
+    }
+
+    function formatStars(n) {
+        if (typeof n !== "number") {
+            return "";
+        }
+        if (n >= 1000) {
+            return (n / 1000).toFixed(1) + "k";
+        }
+        return String(n);
+    }
+
+    let cached;
+    try {
+        cached = JSON.parse(sessionStorage.getItem(CACHE_KEY) || "null");
+    }
+    catch (e) {
+        cached = null;
+    }
+    if (cached && Date.now() - cached.t < CACHE_TTL_MS) {
+        applyValues(cached.stars);
+        return;
+    }
+
+    fetch("https://api.github.com/repos/" + REPO)
+        .then((r) => (r.ok ? r.json() : null))
+        .then((repo) => {
+            // Skip caching on a rate-limit / error response so the next
+            // page load retries instead of showing empty for an hour.
+            if (!repo) {
+                return;
+            }
+            const stars = formatStars(repo.stargazers_count);
+            try {
+                sessionStorage.setItem(
+                    CACHE_KEY,
+                    JSON.stringify({ t: Date.now(), stars: stars }),
+                );
+            }
+            catch (e) {
+                // private mode / storage disabled: skip caching
+            }
+            applyValues(stars);
+        })
+        .catch(() => {
+            // offline / network error: leave the topbar placeholders
+        });
+})();
diff --git a/docs/_static/js/highlight-repl.js b/docs/_static/js/highlight-repl.js
new file mode 100644
index 0000000000..31dcdc7155
--- /dev/null
+++ b/docs/_static/js/highlight-repl.js
@@ -0,0 +1,33 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Syntax-highlight REPL inside pycon output spans (class="go").
+// Pygments tokenizes >>> lines as Python, but leaves output as plain
+// Generic.Output.
+
+document.querySelectorAll(".highlight-pycon .go").forEach((span) => {
+    let html = span.innerHTML;
+    // Highlight quoted strings (must run first, before we inject spans).
+    html = html.replace(
+        /('[^']*'|"[^"]*")/g,
+        '<span class="pycon-string">$1</span>',
+    );
+    // Highlight namedtuple field names (word before '=').
+    // The (?!") lookahead avoids matching class= in the injected span tags.
+    html = html.replace(
+        /\b([a-z_]\w*)=(?!")/g,
+        '<span class="pycon-field">$1</span>=',
+    );
+    // Highlight numbers after '=' or at the start of a line.
+    html = html.replace(
+        /(?<==)\d+\.?\d*|^\d+\.?\d*/gm,
+        '<span class="pycon-number">$&</span>',
+    );
+    span.innerHTML = html;
+});
+
+// Disable title showing up on hover.
+document.querySelectorAll("a.sphinx-codeautolink-a[title]").forEach((a) => {
+    a.removeAttribute("title");
+});
diff --git a/docs/_static/js/home-install-copy.js b/docs/_static/js/home-install-copy.js
new file mode 100644
index 0000000000..e70bef8cf9
--- /dev/null
+++ b/docs/_static/js/home-install-copy.js
@@ -0,0 +1,69 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Wire the home-page install pill: copy `pip install psutil` to the
+// clipboard and flash a "Copied" hint on the button.
+
+(function () {
+    const wrapper = document.querySelector(".home-install");
+    if (!wrapper) {
+        return;
+    }
+    const btn = wrapper.querySelector(".home-install-copy");
+    const cmd = wrapper.querySelector(".home-install-cmd");
+    if (!btn || !cmd) {
+        return;
+    }
+
+    let resetTimer = null;
+
+    function flashCopied() {
+        wrapper.classList.add("copied");
+        const label = btn.getAttribute("aria-label") || "";
+        if (!btn.dataset.origLabel) {
+            btn.dataset.origLabel = label;
+        }
+        btn.setAttribute("aria-label", "Copied");
+        if (resetTimer) {
+            clearTimeout(resetTimer);
+        }
+        resetTimer = setTimeout(() => {
+            wrapper.classList.remove("copied");
+            btn.setAttribute("aria-label", btn.dataset.origLabel);
+        }, 1400);
+    }
+
+    function legacyCopy(text) {
+        const ta = document.createElement("textarea");
+        ta.value = text;
+        ta.style.position = "fixed";
+        ta.style.opacity = "0";
+        document.body.appendChild(ta);
+        ta.select();
+        let ok = false;
+        try {
+            ok = document.execCommand("copy");
+        }
+        finally {
+            document.body.removeChild(ta);
+        }
+        return ok;
+    }
+
+    btn.addEventListener("click", () => {
+        const text = cmd.textContent.trim();
+        if (navigator.clipboard && navigator.clipboard.writeText) {
+            navigator.clipboard.writeText(text)
+                .then(flashCopied)
+                .catch(() => {
+                    if (legacyCopy(text)) {
+                        flashCopied();
+                    }
+                });
+        }
+        else if (legacyCopy(text)) {
+            flashCopied();
+        }
+    });
+})();
diff --git a/docs/_static/js/right-toc-toggle.js b/docs/_static/js/right-toc-toggle.js
new file mode 100644
index 0000000000..2a793b89cd
--- /dev/null
+++ b/docs/_static/js/right-toc-toggle.js
@@ -0,0 +1,51 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Hide TOC bar below 1280px resolution.
+
+(function () {
+    const btn = document.getElementById("toc-toggle");
+    const toc = document.querySelector(".right-sidebar");
+    if (!btn || !toc) {
+        return;
+    }
+    const body = document.body;
+    const wide = window.matchMedia("(min-width: 1280px)");
+
+    function close() {
+        body.classList.remove("toc-open");
+        btn.setAttribute("aria-expanded", "false");
+    }
+
+    btn.addEventListener("click", (e) => {
+        e.stopPropagation();
+        const open = body.classList.toggle("toc-open");
+        btn.setAttribute("aria-expanded", open ? "true" : "false");
+    });
+
+    toc.addEventListener("click", (e) => {
+        if (e.target.closest("a")) {
+            close();
+        }
+    });
+
+    document.addEventListener("click", (e) => {
+        if (body.classList.contains("toc-open") && !toc.contains(e.target)) {
+            close();
+        }
+    });
+
+    document.addEventListener("keydown", (e) => {
+        if (e.key === "Escape" && body.classList.contains("toc-open")) {
+            close();
+            btn.focus();
+        }
+    });
+
+    wide.addEventListener("change", (e) => {
+        if (e.matches) {
+            close();
+        }
+    });
+})();
diff --git a/docs/_static/js/right-toc.js b/docs/_static/js/right-toc.js
new file mode 100644
index 0000000000..384fa232b9
--- /dev/null
+++ b/docs/_static/js/right-toc.js
@@ -0,0 +1,245 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Right-side per-page TOC. Scroll-spy + auto-positioning so the
+// current heading stays visible inside the (independently scrolling)
+// TOC. Modeled after pydata-sphinx-theme.
+
+(function () {
+    "use strict";
+
+    var pageToc = document.querySelector(".right-sidebar");
+    if (!pageToc) {
+        return;
+    }
+
+    // Strip trailing "()" from function-name entries (just visual noise).
+    pageToc.querySelectorAll("a code .pre").forEach(function (el) {
+        if (el.textContent.endsWith("()")) {
+            el.textContent = el.textContent.slice(0, -2);
+        }
+    });
+
+    var tocLinks = Array.prototype.slice.call(
+        pageToc.querySelectorAll('a[href^="#"]'),
+    );
+
+    if (tocLinks.length === 0) {
+        return;
+    }
+
+    function getHeading(tocLink) {
+        var href = tocLink.getAttribute("href");
+        if (!href || !href.startsWith("#")) {
+            return null;
+        }
+
+        var id = href.substring(1);
+        if (!id) {
+            return null;
+        }
+
+        var decodedId;
+        try {
+            decodedId = decodeURIComponent(id);
+        }
+        catch (e) {
+            // Malformed %-escape in the href; ignore this entry.
+            return null;
+        }
+
+        var target = document.getElementById(decodedId);
+        if (!target) {
+            return null;
+        }
+
+        // Prefer the heading inside; fall back to target itself for
+        // <dt> autodoc anchors with no inner heading.
+        var heading = target.querySelector("h1, h2, h3, h4, h5, h6");
+        if (heading) {
+            return heading;
+        }
+        return target;
+    }
+
+    var headingsToTocLinks = new Map();
+
+    tocLinks.forEach(function (tocLink) {
+        var heading = getHeading(tocLink);
+        if (heading) {
+            headingsToTocLinks.set(heading, tocLink);
+        }
+    });
+
+    var observedHeadings = Array.from(headingsToTocLinks.keys());
+    var titleHeight = 0;
+
+    function refreshTitleHeight() {
+        var title = pageToc.querySelector(".right-sidebar-title");
+        if (title) {
+            titleHeight = title.offsetHeight;
+        }
+        else {
+            titleHeight = 0;
+        }
+    }
+
+    refreshTitleHeight();
+
+    // offsetTop / clientHeight are precomputed; getBoundingClientRect
+    // would force a layout flush each call.
+    function ensureVisibleInToc(link) {
+        var linkTop = link.offsetTop;
+        var linkBottom = linkTop + link.offsetHeight;
+
+        var visibleTop = pageToc.scrollTop + titleHeight;
+        var visibleBottom = pageToc.scrollTop + pageToc.clientHeight;
+
+        if (linkTop < visibleTop) {
+            pageToc.scrollTop = Math.max(0, linkTop - titleHeight);
+        }
+        else if (linkBottom > visibleBottom) {
+            pageToc.scrollTop = linkBottom - pageToc.clientHeight;
+        }
+    }
+
+    var activeLink = null;
+    var activeLis = [];
+
+    function activate(tocLink) {
+        if (tocLink === activeLink) {
+            return;
+        }
+
+        if (activeLink) {
+            activeLink.removeAttribute("aria-current");
+        }
+
+        activeLis.forEach(function (li) {
+            li.classList.remove("scroll-current-leaf");
+        });
+
+        activeLis = [];
+        activeLink = tocLink;
+
+        if (!tocLink) {
+            return;
+        }
+
+        tocLink.setAttribute("aria-current", "true");
+
+        var leaf = tocLink.parentNode && tocLink.parentNode.closest("li");
+
+        if (leaf) {
+            leaf.classList.add("scroll-current-leaf");
+            activeLis.push(leaf);
+        }
+
+        ensureVisibleInToc(tocLink);
+    }
+
+    var observer;
+    var disableObserver = false;
+
+    function temporarilyDisableObserver(ms) {
+        disableObserver = true;
+        setTimeout(function () {
+            disableObserver = false;
+        }, ms);
+    }
+
+    function connectIntersectionObserver() {
+        if (observer) {
+            observer.disconnect();
+        }
+
+        refreshTitleHeight();
+
+        var topbar = document.querySelector(".topbar");
+        var headerHeight = topbar ? topbar.offsetHeight : 0;
+
+        // Active band: top 30% of viewport below the header.
+        var options = {
+            root: null,
+            rootMargin: "-" + headerHeight + "px 0px -70% 0px",
+            threshold: 0,
+        };
+
+        function callback(entries) {
+            if (disableObserver) {
+                return;
+            }
+            var entry = entries.filter(function (e) {
+                return e.isIntersecting;
+            }).pop();
+            if (!entry) {
+                return;
+            }
+            var tocLink = headingsToTocLinks.get(entry.target);
+            if (tocLink) {
+                activate(tocLink);
+            }
+        }
+
+        observer = new IntersectionObserver(callback, options);
+
+        observedHeadings.forEach(function (h) {
+            observer.observe(h);
+        });
+    }
+
+    function debounce(fun, wait) {
+        var t;
+
+        return function () {
+            clearTimeout(t);
+            t = setTimeout(fun, wait);
+        };
+    }
+
+    // Highlight the TOC entry whose href matches the URL hash. Used on
+    // page load and when navigating between headings on the same page.
+    function syncTocHash(hash) {
+        if (!hash || hash.length <= 1) {
+            return;
+        }
+        var link = tocLinks.find(function (l) {
+            return l.hash === hash;
+        });
+        if (link) {
+            temporarilyDisableObserver(1000);
+            activate(link);
+        }
+    }
+
+    window.addEventListener(
+        "resize",
+        debounce(connectIntersectionObserver, 300),
+    );
+
+    connectIntersectionObserver();
+
+    // Initial sync (in case the URL has a hash).
+    syncTocHash(location.hash);
+
+    // Hash changes via in-page anchor clicks.
+    window.addEventListener("hashchange", function () {
+        syncTocHash(location.hash);
+    });
+
+    // Edge case: clicking a same-hash link doesn't fire hashchange,
+    // but we still want the TOC to re-sync (the user may have scrolled
+    // away from that section in between).
+    window.addEventListener("click", function (e) {
+        var link = e.target.closest("a");
+        if (
+            link &&
+            link.hash &&
+            link.hash === location.hash &&
+            link.origin === location.origin
+        ) {
+            syncTocHash(link.hash);
+        }
+    });
+})();
diff --git a/docs/_static/js/search-dim.js b/docs/_static/js/search-dim.js
new file mode 100644
index 0000000000..ab5ac0d180
--- /dev/null
+++ b/docs/_static/js/search-dim.js
@@ -0,0 +1,25 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Dim the rest of the page while the sidebar search input is focused.
+// search.css handles the visual fade. Skipped on touch devices.
+
+(function () {
+    if (window.matchMedia("(pointer: coarse)").matches) {
+        return;
+    }
+    const input = document.getElementById("search-input");
+    if (!input) {
+        return;
+    }
+    const overlay = document.createElement("div");
+    overlay.className = "search-overlay";
+    document.body.appendChild(overlay);
+    input.addEventListener("focus", () => {
+        document.body.classList.add("search-focused");
+    });
+    input.addEventListener("blur", () => {
+        document.body.classList.remove("search-focused");
+    });
+})();
diff --git a/docs/_static/js/search-shortcuts.js b/docs/_static/js/search-shortcuts.js
new file mode 100644
index 0000000000..4c58a2ed4c
--- /dev/null
+++ b/docs/_static/js/search-shortcuts.js
@@ -0,0 +1,150 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Sidebar input:
+//   `CTRL+K` / `CMD+K`: focus / select the search input
+//   `ESC`: exit search
+//
+// Search results page:
+//   `Arrow Up` / `Arrow down`: navigate results
+//   `ENTER`: open result
+
+(function () {
+    // Disable Sphinx's built-in "/" shortcut so it doesn't compete.
+    // Done before the touch-device early return so it applies there too.
+    if (typeof DOCUMENTATION_OPTIONS !== "undefined") {
+        DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS = false;
+    }
+
+    if (window.matchMedia("(pointer: coarse)").matches) {
+        return;
+    }
+
+    function getInput() {
+        return document.getElementById("search-input");
+    }
+
+    // Re-submitting the same query on the search page is a browser
+    // no-op (URL doesn't change). Force a reload only in that case;
+    // for a real navigation, let the browser do its thing.
+    getInput()?.form?.addEventListener("submit", (e) => {
+        const form = e.currentTarget;
+        const action = new URL(form.action, location.href);
+        action.search = "?" + new URLSearchParams(new FormData(form));
+        if (
+            action.pathname === location.pathname &&
+            action.search === location.search
+        ) {
+            e.preventDefault();
+            location.reload();
+        }
+    });
+
+    // ---- Ctrl+K + Esc on the sidebar input -------------------------
+
+    document.addEventListener("keydown", (e) => {
+        if ((e.ctrlKey || e.metaKey) && e.key === "k") {
+            const input = getInput();
+            if (input) {
+                e.preventDefault();
+                if (document.activeElement === input) {
+                    input.blur();
+                }
+                else {
+                    input.focus();
+                    input.select();
+                }
+            }
+            return;
+        }
+        if (e.key === "Escape") {
+            const input = getInput();
+            if (input && document.activeElement === input) {
+                input.value = "";
+                input.blur();
+            }
+        }
+    });
+
+    // ---- Arrow-key navigation on the search results page -----------
+    (function () {
+        const container = document.getElementById("search-results");
+        if (!container) {
+            return;
+        }
+
+        const pageInput = document.querySelector(".search-page-input");
+        const sidebarInput = getInput();
+        let activeIndex = -1;
+
+        function getResults() {
+            return Array.from(container.querySelectorAll("ul.search > li"));
+        }
+
+        function setActive(index) {
+            const results = getResults();
+            if (!results.length) {
+                return;
+            }
+            index = Math.max(0, Math.min(index, results.length - 1));
+            results.forEach((li) => {
+                li.classList.remove("search-result-active");
+            });
+            activeIndex = index;
+            results[index].classList.add("search-result-active");
+            const link = results[index].querySelector("a");
+            if (link) {
+                link.focus({ preventScroll: true });
+            }
+            results[index].scrollIntoView({ block: "nearest" });
+        }
+
+        function clearActive() {
+            activeIndex = -1;
+            getResults().forEach((li) => {
+                li.classList.remove("search-result-active");
+            });
+        }
+
+        // When Sphinx adds new <li>s, drop any prior selection.
+        new MutationObserver((mutations) => {
+            const hasNewLi = mutations.some((m) => {
+                return Array.from(m.addedNodes).some((n) => {
+                    return n.tagName === "LI";
+                });
+            });
+            if (hasNewLi) {
+                clearActive();
+            }
+        }).observe(container, { childList: true, subtree: true });
+
+        function isSearchInput(el) {
+            return el && (el === sidebarInput || el === pageInput);
+        }
+
+        document.addEventListener("keydown", (e) => {
+            if (!getResults().length) {
+                return;
+            }
+            if (isSearchInput(document.activeElement)) {
+                if (e.key !== "ArrowDown") {
+                    return;
+                }
+                e.preventDefault();
+                setActive(0);
+                return;
+            }
+            if (e.key === "ArrowDown") {
+                e.preventDefault();
+                setActive(activeIndex === -1 ? 0 : activeIndex + 1);
+            }
+            else if (e.key === "ArrowUp") {
+                e.preventDefault();
+                if (activeIndex > 0) {
+                    setActive(activeIndex - 1);
+                }
+            }
+        });
+    })();
+})();
diff --git a/docs/_static/js/shortcuts-help.js b/docs/_static/js/shortcuts-help.js
new file mode 100644
index 0000000000..386e2d8f00
--- /dev/null
+++ b/docs/_static/js/shortcuts-help.js
@@ -0,0 +1,93 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Shows a helper when pressing "?" anywhere outside a form field, listing
+// the site's keyboard shortcuts. Esc / click on backdrop / second "?"
+// closes it.
+
+(function () {
+    const SHORTCUTS = [
+        { keys: ["Shift", "D"], desc: "Toggle dark / light mode" },
+        { keys: ["Ctrl", "K"], desc: "Focus search" },
+        { keys: ["↑", "↓"], desc: "Navigate search results" },
+        { keys: ["Enter"], desc: "Open highlighted search result" },
+        { keys: ["Esc"], desc: "Close search / dialog" },
+        { keys: ["?"], desc: "Show this help" },
+    ];
+
+    const flyout = document.createElement("div");
+    flyout.className = "shortcut-flyout";
+    flyout.setAttribute("aria-hidden", "true");
+    flyout.setAttribute("role", "dialog");
+    flyout.setAttribute("aria-modal", "true");
+    flyout.setAttribute("aria-label", "Keyboard shortcuts");
+    flyout.innerHTML = '<div class="shortcut-flyout-backdrop"></div>' +
+        '<div class="shortcut-flyout-panel" tabindex="-1">' +
+        '<div class="shortcut-flyout-title">Keyboard shortcuts</div>' +
+        '<dl class="shortcut-flyout-list">' +
+        SHORTCUTS.map((s) => {
+            return (
+                "<dt>" +
+                s.keys
+                    .map((k) => "<kbd>" + k + "</kbd>")
+                    .join(" + ") +
+                "</dt>" +
+                "<dd>" + s.desc + "</dd>"
+            );
+        }).join("") +
+        "</dl>" +
+        "</div>";
+    document.body.appendChild(flyout);
+
+    const backdrop = flyout.querySelector(".shortcut-flyout-backdrop");
+    const panel = flyout.querySelector(".shortcut-flyout-panel");
+    let lastFocused = null;
+
+    function open() {
+        lastFocused = document.activeElement;
+        flyout.classList.add("is-open");
+        flyout.setAttribute("aria-hidden", "false");
+        panel.focus();
+    }
+
+    function close() {
+        flyout.classList.remove("is-open");
+        flyout.setAttribute("aria-hidden", "true");
+        if (lastFocused && typeof lastFocused.focus === "function") {
+            lastFocused.focus();
+        }
+        lastFocused = null;
+    }
+
+    function toggle() {
+        if (flyout.classList.contains("is-open")) {
+            close();
+        }
+        else {
+            open();
+        }
+    }
+
+    backdrop.addEventListener("click", close);
+
+    document.addEventListener("keydown", (e) => {
+        const tag = document.activeElement && document.activeElement.tagName;
+        const isOpen = flyout.classList.contains("is-open");
+        if (!isOpen && (tag === "INPUT" || tag === "TEXTAREA")) {
+            return;
+        }
+        if (e.key === "?") {
+            e.preventDefault();
+            toggle();
+        }
+        else if (e.key === "Escape" && isOpen) {
+            close();
+        }
+        else if (e.key === "Tab" && isOpen) {
+            // Dialog has no focusable children: keep focus on the panel.
+            e.preventDefault();
+            panel.focus();
+        }
+    });
+})();
diff --git a/docs/_static/js/sidebar-mobile.js b/docs/_static/js/sidebar-mobile.js
new file mode 100644
index 0000000000..dc6693f383
--- /dev/null
+++ b/docs/_static/js/sidebar-mobile.js
@@ -0,0 +1,168 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Mobile sidebar: hamburger button toggles a `.sidebar-open` class on
+// <body>, CSS slides the sidebar in from the left. Tapping the
+// backdrop or swiping left closes it.
+
+(function () {
+    const btn = document.getElementById("sidebar-toggle");
+    const sidebar = document.querySelector(".left-sidebar");
+    const body = document.body;
+
+    if (!btn || !sidebar) {
+        return;
+    }
+
+    const backdrop = document.createElement("div");
+    backdrop.className = "sidebar-backdrop";
+    backdrop.setAttribute("aria-hidden", "true");
+    body.appendChild(backdrop);
+
+    function open() {
+        body.classList.add("sidebar-open");
+        btn.setAttribute("aria-expanded", "true");
+        const firstLink = sidebar.querySelector("a");
+        if (firstLink) {
+            firstLink.focus();
+        }
+    }
+
+    function close() {
+        body.classList.remove("sidebar-open");
+        btn.setAttribute("aria-expanded", "false");
+        // Restore focus to the hamburger only if it's still visible
+        // (offsetParent is null when display:none, e.g. >1024px).
+        if (btn.offsetParent !== null) {
+            btn.focus();
+        }
+    }
+
+    function toggle() {
+        if (body.classList.contains("sidebar-open")) {
+            close();
+        }
+        else {
+            open();
+        }
+    }
+
+    btn.addEventListener("click", (e) => {
+        e.stopPropagation();
+        toggle();
+    });
+
+    backdrop.addEventListener("click", close);
+
+    let dragStartX = null;
+    let dragStartY = null;
+    let dragging = false;
+    const SWIPE_CLOSE_PX = 40;
+
+    document.addEventListener(
+        "touchstart",
+        (e) => {
+            if (!body.classList.contains("sidebar-open")) {
+                return;
+            }
+            dragStartX = e.touches[0].clientX;
+            dragStartY = e.touches[0].clientY;
+            dragging = false;
+        },
+        { passive: true },
+    );
+
+    document.addEventListener(
+        "touchmove",
+        (e) => {
+            if (dragStartX === null) {
+                return;
+            }
+            const dx = e.touches[0].clientX - dragStartX;
+            const dy = e.touches[0].clientY - dragStartY;
+            if (!dragging) {
+                // Let vertical scrolls through; only engage on a clear
+                // leftward drag.
+                if (Math.abs(dx) <= Math.abs(dy)) {
+                    dragStartX = null;
+                    return;
+                }
+                if (dx > -8) {
+                    return;
+                }
+                dragging = true;
+            }
+            // Follow the finger 1:1, no transition so it tracks live.
+            sidebar.style.transition = "none";
+            sidebar.style.transform = "translateX(" + Math.min(0, dx) + "px)";
+        },
+        { passive: true },
+    );
+
+    document.addEventListener("touchend", (e) => {
+        if (dragStartX === null) {
+            return;
+        }
+        const dx = e.changedTouches[0].clientX - dragStartX;
+        dragStartX = null;
+        if (!dragging) {
+            // A quick flick with no visible drag still closes (CSS
+            // transition animates it).
+            if (dx < -SWIPE_CLOSE_PX) {
+                close();
+            }
+            return;
+        }
+        dragging = false;
+        const willClose = dx < -SWIPE_CLOSE_PX;
+        requestAnimationFrame(() => {
+            sidebar.style.transition = "";
+            sidebar.style.transform = "";
+            if (willClose) {
+                close();
+            }
+        });
+    });
+
+    sidebar.addEventListener("click", (e) => {
+        const link = e.target.closest("a");
+        if (link) {
+            close();
+        }
+    });
+
+    document.addEventListener("keydown", (e) => {
+        if (!body.classList.contains("sidebar-open")) {
+            return;
+        }
+        if (e.key === "Escape") {
+            close();
+            return;
+        }
+        if (e.key === "Tab") {
+            const items = sidebar.querySelectorAll("a, button, input");
+            if (!items.length) {
+                return;
+            }
+            const first = items[0];
+            const last = items[items.length - 1];
+            if (e.shiftKey && document.activeElement === first) {
+                e.preventDefault();
+                last.focus();
+            }
+            else if (!e.shiftKey && document.activeElement === last) {
+                e.preventDefault();
+                first.focus();
+            }
+        }
+    });
+
+    // Auto-close when transitioning to desktop width.
+    const desktop = window.matchMedia("(min-width: 1025px)");
+    desktop.addEventListener("change", (e) => {
+        if (e.matches && body.classList.contains("sidebar-open")) {
+            close();
+        }
+    });
+})();
diff --git a/docs/_static/js/theme-toggle.js b/docs/_static/js/theme-toggle.js
new file mode 100644
index 0000000000..a9a07a62c0
--- /dev/null
+++ b/docs/_static/js/theme-toggle.js
@@ -0,0 +1,68 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flips data-theme on <html> between "light" and "dark" and persists
+// the choice in localStorage. Initial application happens inline in
+// layout.html (extrahead) so there is no flash on page load. Keep the
+// "psutil-sphinx-theme" key in sync with the inline script.
+//
+// Shortcuts:
+//   click on #theme-toggle button (in the topbar)
+//   Shift+D anywhere outside an input/textarea
+(function () {
+    const html = document.documentElement;
+    const KEY = "psutil-sphinx-theme";
+
+    function applyTheme(dark) {
+        html.setAttribute("data-theme", dark ? "dark" : "light");
+        const btn = document.getElementById("theme-toggle");
+        if (btn) {
+            const icon = btn.querySelector("i");
+            if (icon) {
+                icon.className = dark
+                    ? "fa-solid fa-sun"
+                    : "fa-regular fa-moon";
+            }
+        }
+    }
+
+    function setTheme(dark) {
+        applyTheme(dark);
+        try {
+            localStorage.setItem(KEY, dark ? "dark" : "light");
+        }
+        catch (e) {
+            // private mode / storage disabled: skip persisting
+        }
+    }
+
+    // Sync the icon with whatever the inline script in <head> set.
+    applyTheme(html.getAttribute("data-theme") === "dark");
+
+    const btn = document.getElementById("theme-toggle");
+    if (btn) {
+        btn.addEventListener("click", () => {
+            setTheme(html.getAttribute("data-theme") !== "dark");
+        });
+    }
+
+    // Shift+D: toggle dark mode (skip when typing in a form field).
+    document.addEventListener("keydown", (e) => {
+        const tag = document.activeElement && document.activeElement.tagName;
+        if (tag === "INPUT" || tag === "TEXTAREA") {
+            return;
+        }
+        if (e.shiftKey && e.key === "D") {
+            setTheme(html.getAttribute("data-theme") !== "dark");
+        }
+    });
+
+    // Keep tabs in sync: another tab toggled, mirror it here without
+    // re-writing localStorage (would loop the storage event).
+    window.addEventListener("storage", (e) => {
+        if (e.key === KEY && e.newValue) {
+            applyTheme(e.newValue === "dark");
+        }
+    });
+})();
diff --git a/docs/_static/js/version-selector.js b/docs/_static/js/version-selector.js
new file mode 100644
index 0000000000..ab82737c6f
--- /dev/null
+++ b/docs/_static/js/version-selector.js
@@ -0,0 +1,51 @@
+// Copyright (c) 2009 Giampaolo Rodola. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Closes the topbar version dropdown on an outside click or Esc.
+
+(function () {
+    const details = document.getElementById("version-selector");
+    if (!details) {
+        return;
+    }
+
+    document.addEventListener("click", function (event) {
+        if (details.open && !details.contains(event.target)) {
+            details.removeAttribute("open");
+        }
+    });
+
+    document.addEventListener("keydown", function (event) {
+        if (event.key === "Escape" && details.open) {
+            details.removeAttribute("open");
+            details.querySelector("summary").focus();
+        }
+    });
+
+    // Land on the same page in the other version when it exists, else follow
+    // the link to that version's home page.
+    const page = details.dataset.versionPage;
+    if (!page) {
+        return;
+    }
+    for (const link of details.querySelectorAll(".topbar-versions-item")) {
+        if (link.classList.contains("is-current")) {
+            continue;
+        }
+        link.addEventListener("click", function (event) {
+            if (event.metaKey || event.ctrlKey || event.shiftKey) {
+                return;
+            }
+            const same = new URL(page + "/", link.href).href;
+            event.preventDefault();
+            fetch(same, { method: "HEAD" })
+                .then((resp) => {
+                    window.location.href = resp.ok ? same : link.href;
+                })
+                .catch(() => {
+                    window.location.href = link.href;
+                });
+        });
+    }
+})();
diff --git a/docs/_static/logo.png b/docs/_static/logo.png
deleted file mode 100644
index 7d975ec9d2..0000000000
Binary files a/docs/_static/logo.png and /dev/null differ
diff --git a/docs/_static/sidebar.js b/docs/_static/sidebar.js
deleted file mode 100644
index 3376963911..0000000000
--- a/docs/_static/sidebar.js
+++ /dev/null
@@ -1,161 +0,0 @@
-/*
- * sidebar.js
- * ~~~~~~~~~~
- *
- * This script makes the Sphinx sidebar collapsible.
- *
- * .sphinxsidebar contains .sphinxsidebarwrapper.  This script adds in
- * .sphixsidebar, after .sphinxsidebarwrapper, the #sidebarbutton used to
- * collapse and expand the sidebar.
- *
- * When the sidebar is collapsed the .sphinxsidebarwrapper is hidden and the
- * width of the sidebar and the margin-left of the document are decreased.
- * When the sidebar is expanded the opposite happens.  This script saves a
- * per-browser/per-session cookie used to remember the position of the sidebar
- * among the pages.  Once the browser is closed the cookie is deleted and the
- * position reset to the default (expanded).
- *
- * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-$(function() {
-  // global elements used by the functions.
-  // the 'sidebarbutton' element is defined as global after its
-  // creation, in the add_sidebar_button function
-  var bodywrapper = $('.bodywrapper');
-  var sidebar = $('.sphinxsidebar');
-  var sidebarwrapper = $('.sphinxsidebarwrapper');
-
-  // original margin-left of the bodywrapper and width of the sidebar
-  // with the sidebar expanded
-  var bw_margin_expanded = bodywrapper.css('margin-left');
-  var ssb_width_expanded = sidebar.width();
-
-  // margin-left of the bodywrapper and width of the sidebar
-  // with the sidebar collapsed
-  var bw_margin_collapsed = '.8em';
-  var ssb_width_collapsed = '.8em';
-
-  // colors used by the current theme
-  var dark_color = '#AAAAAA';
-  var light_color = '#CCCCCC';
-
-  function sidebar_is_collapsed() {
-    return sidebarwrapper.is(':not(:visible)');
-  }
-
-  function toggle_sidebar() {
-    if (sidebar_is_collapsed())
-      expand_sidebar();
-    else
-      collapse_sidebar();
-  }
-
-  function collapse_sidebar() {
-    sidebarwrapper.hide();
-    sidebar.css('width', ssb_width_collapsed);
-    bodywrapper.css('margin-left', bw_margin_collapsed);
-    sidebarbutton.css({
-        'margin-left': '0',
-        //'height': bodywrapper.height(),
-        'height': sidebar.height(),
-        'border-radius': '5px'
-    });
-    sidebarbutton.find('span').text('»');
-    sidebarbutton.attr('title', _('Expand sidebar'));
-    document.cookie = 'sidebar=collapsed';
-  }
-
-  function expand_sidebar() {
-    bodywrapper.css('margin-left', bw_margin_expanded);
-    sidebar.css('width', ssb_width_expanded);
-    sidebarwrapper.show();
-    sidebarbutton.css({
-        'margin-left': ssb_width_expanded-12,
-        //'height': bodywrapper.height(),
-        'height': sidebar.height(),
-        'border-radius': '0 5px 5px 0'
-    });
-    sidebarbutton.find('span').text('«');
-    sidebarbutton.attr('title', _('Collapse sidebar'));
-    //sidebarwrapper.css({'padding-top':
-    //  Math.max(window.pageYOffset - sidebarwrapper.offset().top, 10)});
-    document.cookie = 'sidebar=expanded';
-  }
-
-  function add_sidebar_button() {
-    sidebarwrapper.css({
-        'float': 'left',
-        'margin-right': '0',
-        'width': ssb_width_expanded - 28
-    });
-    // create the button
-    sidebar.append(
-      '<div id="sidebarbutton"><span>&laquo;</span></div>'
-    );
-    var sidebarbutton = $('#sidebarbutton');
-    // find the height of the viewport to center the '<<' in the page
-    var viewport_height;
-    if (window.innerHeight)
- 	  viewport_height = window.innerHeight;
-    else
-	  viewport_height = $(window).height();
-    var sidebar_offset = sidebar.offset().top;
-
-    var sidebar_height = sidebar.height();
-    //var sidebar_height = Math.max(bodywrapper.height(), sidebar.height());
-    sidebarbutton.find('span').css({
-        'display': 'block',
-        'margin-top': sidebar_height/2 - 10
-        //'margin-top': (viewport_height - sidebar.position().top - 20) / 2
-        //'position': 'fixed',
-        //'top': Math.min(viewport_height/2, sidebar_height/2 + sidebar_offset) - 10
-    });
-
-    sidebarbutton.click(toggle_sidebar);
-    sidebarbutton.attr('title', _('Collapse sidebar'));
-    sidebarbutton.css({
-        'border-radius': '0 5px 5px 0',
-        'color': '#444444',
-        'background-color': '#CCCCCC',
-        'font-size': '1.2em',
-        'cursor': 'pointer',
-        'height': sidebar_height,
-        'padding-top': '1px',
-        'padding-left': '1px',
-        'margin-left': ssb_width_expanded - 12
-    });
-
-    sidebarbutton.hover(
-      function () {
-          $(this).css('background-color', dark_color);
-      },
-      function () {
-          $(this).css('background-color', light_color);
-      }
-    );
-  }
-
-  function set_position_from_cookie() {
-    if (!document.cookie)
-      return;
-    var items = document.cookie.split(';');
-    for(var k=0; k<items.length; k++) {
-      var key_val = items[k].split('=');
-      var key = key_val[0];
-      if (key == 'sidebar') {
-        var value = key_val[1];
-        if ((value == 'collapsed') && (!sidebar_is_collapsed()))
-          collapse_sidebar();
-        else if ((value == 'expanded') && (sidebar_is_collapsed()))
-          expand_sidebar();
-      }
-    }
-  }
-
-  add_sidebar_button();
-  var sidebarbutton = $('#sidebarbutton');
-  set_position_from_cookie();
-});
diff --git a/docs/_template/globaltoc.html b/docs/_template/globaltoc.html
deleted file mode 100644
index f5fbb406cc..0000000000
--- a/docs/_template/globaltoc.html
+++ /dev/null
@@ -1,12 +0,0 @@
-{#
-    basic/globaltoc.html
-    ~~~~~~~~~~~~~~~~~~~~
-
-    Sphinx sidebar template: global table of contents.
-
-    :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-#}
-<h3>{{ _('Manual') }}</h3>
-{{ toctree() }}
-<a href="{{ pathto(master_doc) }}">Back to Welcome</a>
diff --git a/docs/_template/indexcontent.html b/docs/_template/indexcontent.html
deleted file mode 100644
index dd5e7249a0..0000000000
--- a/docs/_template/indexcontent.html
+++ /dev/null
@@ -1,4 +0,0 @@
-{% extends "defindex.html" %}
-{% block tables %}
-
-{% endblock %}
diff --git a/docs/_template/indexsidebar.html b/docs/_template/indexsidebar.html
deleted file mode 100644
index 903675d100..0000000000
--- a/docs/_template/indexsidebar.html
+++ /dev/null
@@ -1,8 +0,0 @@
-<h3>Useful links</h3>
-<ul>
-  <li><a href="https://github.com/giampaolo/psutil">Github project</a></li>
-  <li><a href="http://grodola.blogspot.com/search/label/psutil">Blog</a></li>
-  <li><a href="https://pypi.python.org/pypi?:action=display&name=psutil#downloads">Download</a></li>
-  <li><a href="https://github.com/giampaolo/psutil/issues">Issues</a></li>
-  <li><a href="http://groups.google.com/group/psutil/topics">Forum</a></li>
-</ul>
diff --git a/docs/_template/page.html b/docs/_template/page.html
deleted file mode 100644
index 04b47b4153..0000000000
--- a/docs/_template/page.html
+++ /dev/null
@@ -1,66 +0,0 @@
-{% extends "!page.html" %}
-{% block extrahead %}
-{{ super() }}
-{% if not embedded %}<script type="text/javascript" src="{{ pathto('_static/copybutton.js', 1) }}"></script>{% endif %}
-<script type="text/javascript">
-
-  // Store editor pop-up help state in localStorage
-  // so it does not re-pop-up itself between page loads.
-  // Do not even to pretend to support IE gracefully.
-  (function($) {
-
-    $(document).ready(function() {
-        var box = $("#editor-trap");
-        var klass = "toggled";
-        var storageKey = "toggled";
-
-        function toggle() {
-            box.toggleClass(klass);
-            // Store the toggle status in local storage as "has value string" or null
-            window.localStorage.setItem(storageKey, box.hasClass(klass) ? "toggled" : "not-toggled");
-        }
-
-        box.click(toggle);
-
-        // Check the persistent state of the editor pop-up
-        // Note that localStorage does not necessarily support boolean values (ugh!)
-        // http://stackoverflow.com/questions/3263161/cannot-set-boolean-values-in-localstorage
-        var v = window.localStorage.getItem(storageKey);
-        if(v == "toggled" || !v) {
-          box.addClass(klass);
-        }
-
-    });
-
-  })(jQuery);
-</script>
-<script type="text/javascript">
-
-  var _gaq = _gaq || [];
-  _gaq.push(['_setAccount', 'UA-2097050-4']);
-  _gaq.push(['_trackPageview']);
-
-  (function() {
-    var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
-    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
-    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
-  })();
-
-</script>
-{% endblock %}
-
-{% block rootrellink %}
-    <li><a href="https://github.com/giampaolo/psutil/"><img src="{{ pathto('_static/logo.png', 1) }}" style="height: 30px; vertical-align: middle; padding-right: 1em;" /> Project Homepage</a>{{ reldelim1 }}</li>
-	<li><a href="{{ pathto('index') }}">{{ shorttitle }}</a>{{ reldelim1 }}</li>
-{% endblock %}
-
-
-{% block footer %}
-<div class="footer">
-    &copy; Copyright {{ copyright|e }}.
-    <br />
-    Last updated on {{ last_updated|e }}.
-    <br />
-    Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> {{ sphinx_version|e }}.
-</div>
-{% endblock %}
\ No newline at end of file
diff --git a/docs/_templates/ablog/collection.html b/docs/_templates/ablog/collection.html
new file mode 100644
index 0000000000..50ae2ca155
--- /dev/null
+++ b/docs/_templates/ablog/collection.html
@@ -0,0 +1,71 @@
+{#-
+  Override of ablog/collection.html. Renders blog.html (all posts),
+  tag pages, year archives. Card-style listing inspired by
+  blog.python.org.
+-#}
+{%- extends "page.html" %}
+
+{%- macro postlink(post) -%}
+  {%- if post.external_link -%}{{ post.external_link }}
+  {%- else -%}{{ pathto(post.docname) }}{{ anchor(post) }}
+  {%- endif -%}
+{%- endmacro -%}
+
+{%- set month_abbr = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'] -%}
+
+{% block body %}
+<div class="blog-listing">
+  <div class="blog-listing-header">
+    <h1 class="blog-listing-title">
+      {%- if pagename == ablog.blog_path -%}
+      <span class="blog-listing-title-value">{{ _('All posts') }}</span>
+      {%- else -%}
+      {%- set is_tag = '/tag/' in pagename -%}
+      {%- set lq = '“' if is_tag else '' -%}
+      {%- set rq = '�' if is_tag else '' -%}
+      {{ header }} {{ lq }}{% if collection.href %}<a class="blog-listing-title-value" href="{{ collection.href }}">{{ collection }}</a>{% else %}<span class="blog-listing-title-value">{{ collection }}</span>{% endif %}{{ rq }}
+      {%- endif -%}
+    </h1>
+  </div>
+
+  <ol class="blog-cards"{% if giscus_repo %} data-comments-repo="{{ giscus_repo|e }}"{% endif %}>
+  {% for post in collection %}
+    {% set ns = namespace(featured=false) %}
+    {% for tag in post.tags or [] %}{% if tag|string == 'featured' %}{% set ns.featured = true %}{% endif %}{% endfor %}
+    {% set featured = ns.featured %}
+    <li class="blog-card" data-docname="{{ post.docname|e }}">
+      <div class="blog-card-head">
+        <span class="blog-card-meta">
+          {% if post.published %}
+            <time datetime="{{ post.date.strftime('%Y-%m-%d') }}">{{ month_abbr[post.date.month - 1] }} {{ post.date.day }}, {{ post.date.year }}</time>
+          {% else %}
+            <span class="blog-card-draft">{{ _('Draft') }}</span>
+          {% endif %}
+        </span>
+        <div class="blog-card-titlerow">
+          <h2 class="blog-card-title">
+            <a href="{{ postlink(post) }}">{{ post.title }}</a>
+          </h2>
+          {% if featured %}<span class="post-meta-featured-wrap"><a class="post-meta-featured" href="{{ pathto(ablog.blog_path ~ '/tag/featured') }}">{{ _('Featured') }}</a></span>{% endif %}
+        </div>
+      </div>
+      {% if post.excerpt %}
+      <div class="blog-card-summary">{{ post.to_html(pagename) | safe }}</div>
+      {% endif %}
+      {% if post.tags %}
+      <ul class="blog-card-tags">
+        {% for tag in post.tags|sort %}
+          {% if tag|string != 'featured' %}
+          <li><a href="{{ pathto(tag.docname) }}">{{ tag }}</a></li>
+          {% endif %}
+        {% endfor %}
+      </ul>
+      {% endif %}
+    </li>
+  {% endfor %}
+  </ol>
+</div>
+{% if giscus_repo %}
+<script defer src="{{ pathto('_static/js/blog-comment-counts.js', 1)|e }}"></script>
+{% endif %}
+{% endblock body %}
diff --git a/docs/_templates/ablog/postnavy.html b/docs/_templates/ablog/postnavy.html
new file mode 100644
index 0000000000..dced364332
--- /dev/null
+++ b/docs/_templates/ablog/postnavy.html
@@ -0,0 +1,28 @@
+{#-
+  Override of ablog/postnavy.html: emit the same markup as the doc
+  prev/next at the bottom of regular pages, so a single CSS rule
+  (prev-next.css) styles both.
+-#}
+{% set post = ablog[pagename] %}
+{% if post.published and ablog.post_show_prev_next and (post.prev or post.next) %}
+<nav class="prev-next no-visited" aria-label="{{ _('Previous and next posts') }}">
+  {% if post.prev %}
+  <a class="prev-next-prev" href="{{ pathto(post.prev.docname) }}{{ anchor(post.prev) }}" rel="prev">
+    <span class="prev-next-arrow" aria-hidden="true">&lsaquo;</span>
+    <span class="prev-next-block">
+      <span class="prev-next-label">{{ _('Previous') }}</span>
+      <span class="prev-next-title">{{ post.prev.title|striptags|e }}</span>
+    </span>
+  </a>
+  {% endif %}
+  {% if post.next %}
+  <a class="prev-next-next" href="{{ pathto(post.next.docname) }}{{ anchor(post.next) }}" rel="next">
+    <span class="prev-next-block">
+      <span class="prev-next-label">{{ _('Next') }}</span>
+      <span class="prev-next-title">{{ post.next.title|striptags|e }}</span>
+    </span>
+    <span class="prev-next-arrow" aria-hidden="true">&rsaquo;</span>
+  </a>
+  {% endif %}
+</nav>
+{% endif %}
diff --git a/docs/_templates/banner.html b/docs/_templates/banner.html
new file mode 100644
index 0000000000..a268cce7fe
--- /dev/null
+++ b/docs/_templates/banner.html
@@ -0,0 +1,13 @@
+{#-
+  Dismissal is remembered per data-banner-id. The message below is
+  TEMPORARY, the component isn't.
+-#}
+<div class="site-banner" role="note" data-banner-id="{{ banner_id }}">
+  <span>
+    You're reading the <strong>development</strong> version of the docs.
+    For the current release see <a href="https://psutil.readthedocs.io/stable/">psutil.readthedocs.io/stable</a>.
+  </span>
+  <button class="site-banner-close" type="button"
+          title="{{ _('Dismiss') }}"
+          aria-label="{{ _('Dismiss this notice') }}"></button>
+</div>
diff --git a/docs/_templates/breadcrumbs.html b/docs/_templates/breadcrumbs.html
new file mode 100644
index 0000000000..99d0e607b6
--- /dev/null
+++ b/docs/_templates/breadcrumbs.html
@@ -0,0 +1,30 @@
+{#-
+  Breadcrumbs / section banner. Currently used only by the blog
+  sub-site to render a "Blog" banner at the top of every blog page,
+  so the visitor knows they're in the blog area. Other pages render
+  nothing here.
+-#}
+{%- if ablog is defined %}
+{%- set in_blog = pagename == ablog.blog_path or pagename.startswith(ablog.blog_path ~ '/') %}
+{%- if in_blog %}
+<div class="blog-section-banner">
+  <div class="blog-section-label">
+    <svg class="blog-section-icon" viewBox="0 0 24 24" aria-hidden="true"
+         xmlns="http://www.w3.org/2000/svg" fill="none"
+         stroke="currentColor" stroke-width="2"
+         stroke-linecap="round" stroke-linejoin="round">
+      <path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20"/>
+      <path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z"/>
+    </svg>
+    <a class="blog-section-title" href="{{ pathto(ablog.blog_path) }}">{{ _('Blog') }}</a>
+    <div class="blog-section-subtitle">{{ _('Releases, deep dives, war stories') }}</div>
+  </div>
+  <a class="blog-rss"
+     href="{{ pathto(ablog.blog_path ~ '/atom', 1) }}.xml"
+     title="{{ _('Subscribe (Atom feed)') }}">
+    <span class="rss-icon blog-rss-icon"></span>
+    <span>RSS</span>
+  </a>
+</div>
+{%- endif %}
+{%- endif %}
diff --git a/docs/_templates/comments.html b/docs/_templates/comments.html
new file mode 100644
index 0000000000..ee1638b30e
--- /dev/null
+++ b/docs/_templates/comments.html
@@ -0,0 +1,21 @@
+{#-
+  Blog comments (giscus). Post pages only, unless the post carries a
+  bare ":no_comments:" field. Config comes from conf.py via
+  _ext/giscus.py.
+
+  Hidden until js/giscus.js has the widget up, so a reader with JS
+  off gets nothing rather than an empty box. data-term is the source
+  path, not the URL, so a domain change keeps threads attached.
+-#}
+{% if is_blog_post and giscus_repo %}
+<section class="comments" aria-labelledby="comments-heading" hidden>
+  <h2 id="comments-heading">{{ _('Comments') }}</h2>
+  <div class="giscus"
+       data-repo="{{ giscus_repo|e }}"
+       data-repo-id="{{ giscus_repo_id|e }}"
+       data-category="{{ giscus_category|e }}"
+       data-category-id="{{ giscus_category_id|e }}"
+       data-term="{{ pagename|e }}"
+       data-theme-url="{{ pathto('_static/css/giscus.css', 1)|e }}"></div>
+</section>
+{% endif %}
diff --git a/docs/_templates/footer.html b/docs/_templates/footer.html
new file mode 100644
index 0000000000..2e87d8e2fe
--- /dev/null
+++ b/docs/_templates/footer.html
@@ -0,0 +1,40 @@
+<footer class="footer" role="contentinfo">
+  <div class="footer-content">
+    <div class="footer-text">
+      {%- if show_copyright %}
+      <span><a class="footer-egg" href="{{ pathto('404') }}" title="🥚">&copy;</a> {{ copyright|e }}</span>
+      {%- endif %}
+      {%- if last_updated and has_rst_source %}
+      <span>{{ _('Updated ') }}<a
+        href="https://github.com/giampaolo/psutil/commits/master/docs/{{ pagename }}.rst"
+        rel="noopener noreferrer" target="_blank"
+        title="{{ _('View commit history on GitHub') }}">{{ last_updated|e }}</a></span>
+      {%- endif %}
+      <span><a href="{{ pathto('about') }}"
+               title="{{ _('About this documentation site') }}">{{ _('About') }}</a></span>
+      {%- if has_rst_source %}
+      <span><a href="https://github.com/giampaolo/psutil/edit/master/docs/{{ pagename }}.rst"
+               rel="noopener noreferrer" target="_blank"
+               title="{{ _('Edit this page on GitHub') }}">{{ _('Edit on GitHub') }}</a></span>
+      {%- endif %}
+    </div>
+    <div class="footer-icons">
+      <a class="footer-github" href="https://github.com/giampaolo/psutil"
+         title="{{ _('psutil on GitHub') }}" aria-label="{{ _('psutil on GitHub') }}"
+         rel="noopener noreferrer" target="_blank">
+        <i class="fa-brands fa-github" aria-hidden="true"></i>
+      </a>
+      <a class="footer-pypi" href="https://pypi.org/project/psutil/"
+         title="{{ _('psutil on PyPI') }}" aria-label="{{ _('psutil on PyPI') }}"
+         rel="noopener noreferrer" target="_blank">
+        <i class="fa-brands fa-python" aria-hidden="true"></i>
+      </a>
+      {%- if ablog is defined %}
+      <a class="footer-rss" href="{{ pathto(ablog.blog_path ~ '/atom', 1) }}.xml"
+         title="{{ _('Subscribe to blog (Atom feed)') }}" aria-label="{{ _('Subscribe to blog') }}">
+        <span class="rss-icon"></span>
+      </a>
+      {%- endif %}
+    </div>
+  </div>
+</footer>
diff --git a/docs/_templates/globaltoc.html b/docs/_templates/globaltoc.html
new file mode 100644
index 0000000000..cab494fc18
--- /dev/null
+++ b/docs/_templates/globaltoc.html
@@ -0,0 +1,5 @@
+{# Override of basic theme's globaltoc.html: render only the toctree,
+   without the "Table of Contents" h3 heading. #}
+{{ toctree(includehidden=theme_globaltoc_includehidden,
+           collapse=theme_globaltoc_collapse,
+           maxdepth=theme_globaltoc_maxdepth) }}
diff --git a/docs/_templates/layout.html b/docs/_templates/layout.html
new file mode 100644
index 0000000000..5f81a8aef2
--- /dev/null
+++ b/docs/_templates/layout.html
@@ -0,0 +1,121 @@
+{#-
+  psutil-sphinx-theme: page layout.
+
+  Skeleton: topbar / left sidebar / main column (article + right
+  sidebar) / prev-next / footer. Each chunk lives in its own include
+  to keep this file scan-able. Built on Sphinx's `basic` theme,
+  overriding only the blocks needed to assemble the grid.
+-#}
+{% extends "basic/layout.html" %}
+
+{#- Bumping this brings the banner back for anyone who dismissed the
+    previous message. -#}
+{% set banner_id = 'dev' %}
+
+{% block htmltitle %}
+{%- if pagename == root_doc -%}
+<title>{{ _('psutil: Process and System Utilities for Python') }}</title>
+{%- else -%}
+{{ super() }}
+{%- endif -%}
+{% endblock %}
+{% block extrahead %}
+{{ super() }}
+
+{%- set _parts = pagename.split('/') %}
+{%- set _collections = ['blog/tag', 'blog/category', 'blog/author',
+                        'blog/archive', 'blog/drafts'] %}
+{%- set _year = _parts | length == 2 and _parts[0] == 'blog'
+                and _parts[1].isdigit() %}
+{%- if pagename in ['genindex', 'py-modindex', '404']
+       or _parts[:2] | join('/') in _collections
+       or _year %}
+<meta name="robots" content="noindex">
+{%- endif %}
+
+{# Larger icon for iOS home-screen / share sheet. #}
+<link rel="apple-touch-icon" href="{{ pathto('_static/images/logo-psutil.png', 1) }}">
+
+<script>
+(function() {
+    const html = document.documentElement;
+    html.classList.add('no-transition');
+    // Keeps an already-dismissed banner from flashing.
+    if (localStorage.getItem('psutil-banner') === '{{ banner_id }}') {
+        html.classList.add('site-banner-dismissed');
+    }
+    const saved = localStorage.getItem('psutil-sphinx-theme');
+    const theme = saved || (
+        window.matchMedia('(prefers-color-scheme: dark)').matches
+            ? 'dark'
+            : 'light'
+    );
+    html.setAttribute('data-theme', theme);
+    requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+            html.classList.remove('no-transition');
+        });
+    });
+})();
+</script>
+
+{# GoatCounter. Dashboard: https://psutil.goatcounter.com #}
+<script data-goatcounter="https://psutil.goatcounter.com/count"
+        async src="//gc.zgo.at/count.js"></script>
+
+{# Google Analytics #}
+<script async src="https://www.googletagmanager.com/gtag/js?id=G-G7374TFB11"></script>
+<script>
+  window.dataLayer = window.dataLayer || [];
+  function gtag(){dataLayer.push(arguments);}
+  gtag('js', new Date());
+  gtag('config', 'G-G7374TFB11');
+</script>
+{% endblock %}
+
+{# Expose the page name on <body> so CSS can match the active sidebar
+   item, whose link Sphinx renders as href="#". #}
+{% block body_tag %}<body data-page="{{ pagename }}">{% endblock %}
+
+{% block header %}
+<div class="header-stack">
+  {% include "banner.html" %}
+  {% include "topbar.html" %}
+</div>
+{% endblock %}
+
+{# Suppress basic's default top/bottom breadcrumb. #}
+{% block relbar1 %}{% endblock %}
+{% block relbar2 %}{% endblock %}
+
+{# Suppress basic's body-level footer; ours is rendered in-column
+   below, inside .main, by footer.html. #}
+{% block footer %}{% endblock %}
+
+{# Pages that don't get a right-side TOC. The article column expands
+   to fill the row. #}
+{% set _no_toc_pages = ['index', 'search', 'genindex'] %}
+{% set _has_toc = pagename not in _no_toc_pages %}
+
+{% block content %}
+<div class="page">
+  {% include "sidebar.html" %}
+  <main class="main" id="main-content">
+    {% include "breadcrumbs.html" %}
+    <div class="article-with-toc{% if not _has_toc %} no-toc{% endif %}">
+      <div class="article-column">
+        <article class="article">
+          {% block body %}{% endblock %}
+        </article>
+        {% include "prev-next.html" %}
+        {% include "comments.html" %}
+      </div>
+
+      {% if _has_toc %}{% include "toc.html" %}{% endif %}
+    </div>
+  </main>
+
+  {# Footer lives outside <main> so its contentinfo landmark is top-level. #}
+  {% include "footer.html" %}
+</div>
+{% endblock %}
diff --git a/docs/_templates/prev-next.html b/docs/_templates/prev-next.html
new file mode 100644
index 0000000000..507bb06b2d
--- /dev/null
+++ b/docs/_templates/prev-next.html
@@ -0,0 +1,26 @@
+{#-
+  Prev / next page navigation. Renders below the article, full width
+  of the main column. Styled by static/css/prev-next.css.
+-#}
+{% if prev or next %}
+<nav class="prev-next no-visited" aria-label="{{ _('Previous and next pages') }}">
+  {% if prev %}
+  <a class="prev-next-prev" href="{{ prev.link|e }}" rel="prev">
+    <span class="prev-next-arrow" aria-hidden="true">&lsaquo;</span>
+    <span class="prev-next-block">
+      <span class="prev-next-label">{{ _('Previous') }}</span>
+      <span class="prev-next-title">{{ prev.title|striptags|e }}</span>
+    </span>
+  </a>
+  {% endif %}
+  {% if next %}
+  <a class="prev-next-next" href="{{ next.link|e }}" rel="next">
+    <span class="prev-next-block">
+      <span class="prev-next-label">{{ _('Next') }}</span>
+      <span class="prev-next-title">{{ next.title|striptags|e }}</span>
+    </span>
+    <span class="prev-next-arrow" aria-hidden="true">&rsaquo;</span>
+  </a>
+  {% endif %}
+</nav>
+{% endif %}
diff --git a/docs/_templates/search.html b/docs/_templates/search.html
new file mode 100644
index 0000000000..6e9223d954
--- /dev/null
+++ b/docs/_templates/search.html
@@ -0,0 +1,33 @@
+{%- extends "!search.html" %}
+
+{# Suppress basic theme's "Searching for multiple words…" line,
+   redundant once we have our own prominent input at the top. #}
+{% block searchtext %}{% endblock %}
+
+{# Replace the basic theme's tiny default form with our prominent
+   one. The hidden inputs preserve search semantics. #}
+{% block searchbox %}
+{# Empty action submits to the current URL, so this works under any
+   builder (dirhtml serves this page as /search/, not search.html). #}
+<form class="search-page-form" action="" method="get">
+  <i class="fa-solid fa-magnifying-glass search-page-icon" aria-hidden="true"></i>
+  <input type="text"
+         name="q"
+         class="search-page-input"
+         autofocus
+         autocomplete="off"
+         placeholder="{{ _('Search the docs…') }}"
+         aria-label="{{ _('Search the docs') }}">
+  <button type="submit" class="search-page-btn">{{ _('Search') }}</button>
+  <input type="hidden" name="check_keywords" value="yes">
+  <input type="hidden" name="area" value="default">
+</form>
+<script>
+  (function () {
+    const input = document.querySelector('.search-page-input');
+    if (!input) { return; }
+    const q = new URLSearchParams(window.location.search).get('q');
+    if (q) { input.value = q; }
+  })();
+</script>
+{% endblock %}
diff --git a/docs/_templates/sidebar.html b/docs/_templates/sidebar.html
new file mode 100644
index 0000000000..2015439e63
--- /dev/null
+++ b/docs/_templates/sidebar.html
@@ -0,0 +1,17 @@
+{#-
+  Left sidebar: search box at top, then global table of contents
+  (toctree). Sticky to the viewport, scrolls independently of the
+  main column. Styled by static/css/left-sidebar.css.
+-#}
+<nav class="left-sidebar no-visited" aria-label="{{ _('Main navigation') }}">
+  <div class="search-box">
+    <form action="{{ pathto('search') }}" method="get" role="search">
+      <input id="search-input" type="text" name="q"
+             placeholder="{{ _('Search') }}" aria-label="{{ _('Search docs') }}"
+             autocomplete="off" autocorrect="off"
+             autocapitalize="off" spellcheck="false">
+      <span class="search-kbd" aria-hidden="true"><kbd>Ctrl</kbd>+<kbd>K</kbd></span>
+    </form>
+  </div>
+  {% include "globaltoc.html" %}
+</nav>
diff --git a/docs/_templates/toc.html b/docs/_templates/toc.html
new file mode 100644
index 0000000000..bded595c1e
--- /dev/null
+++ b/docs/_templates/toc.html
@@ -0,0 +1,52 @@
+{#-
+  Right-side per-page TOC. Three modes:
+
+    1. Blog: show tags sorted by post count.
+    2. Glossary page: show list of terms.
+    3. Default: Sphinx's {{ toc }} headings tree.
+
+  Renders nothing when there's no content (e.g. py-modindex, blog
+  landing pages with an empty toc).
+-#}
+{%- set _is_blog_collection = collection is defined and collection -%}
+{%- if _is_blog_collection or glossary_terms or (toc and toc.strip()) -%}
+{%- if glossary_terms -%}
+{%- set _aside_class = "right-sidebar right-sidebar--glossary" -%}
+{%- else -%}
+{%- set _aside_class = "right-sidebar" -%}
+{%- endif -%}
+<aside class="{{ _aside_class }}"
+       {% if glossary_terms %}data-toc-mode="glossary"{% endif %}
+       aria-label="{% if _is_blog_collection %}{{ _('Browse blog') }}{% else %}{{ _('On this page') }}{% endif %}">
+  <div class="right-sidebar-title">{% if _is_blog_collection %}{{ _('Tags') }}{% else %}{{ _('On this page') }}{% endif %}</div>
+
+  {#- Blog ----------------------------------------------------------------- #}
+  {%- if _is_blog_collection and ablog.tags %}
+  {%- set tag_pairs = [] %}
+  {%- for tag in ablog.tags %}
+    {%- if tag|string != 'featured' %}
+      {%- set _ = tag_pairs.append((tag|length, tag)) %}
+    {%- endif %}
+  {%- endfor %}
+  <ul class="blog-tags">
+    {%- for count, tag in tag_pairs|sort(reverse=true) %}
+    <li>
+      <a href="{{ pathto(tag.docname) }}">{{ tag }}<span class="blog-tag-count">{{ count }}</span></a>
+    </li>
+    {%- endfor %}
+  </ul>
+
+  {#- Glossary ----------------------------------------------------------------- #}
+  {%- elif glossary_terms %}
+  <ul class="glossary-toc">
+    {%- for t in glossary_terms %}
+    <li><a href="#{{ t.id }}">{{ t.text }}</a></li>
+    {%- endfor %}
+  </ul>
+
+  {#- Page ----------------------------------------------------------------- #}
+  {%- else %}
+  {{ toc }}
+  {%- endif %}
+</aside>
+{%- endif -%}
diff --git a/docs/_templates/topbar.html b/docs/_templates/topbar.html
new file mode 100644
index 0000000000..6c2301095e
--- /dev/null
+++ b/docs/_templates/topbar.html
@@ -0,0 +1,73 @@
+{#-
+  Top bar: logo on the left, action cluster (Blog, theme toggle,
+  GitHub stars, version selector) on the right. Fixed at the top of
+  the viewport. Styled by static/css/topbar.css.
+
+  The version list comes from html_context in conf.py.
+-#}
+<header class="topbar no-visited" role="banner">
+  <div class="topbar-inner">
+    <button class="topbar-hamburger" id="sidebar-toggle"
+            type="button" aria-label="{{ _('Toggle navigation') }}" aria-expanded="false">
+      <i class="fa-solid fa-bars" aria-hidden="true"></i>
+    </button>
+    {#- Logo lands on the site root. The 404 is served from arbitrary
+        paths, so it needs the absolute root. -#}
+    {%- if pagename == '404' -%}
+    <a class="topbar-logo" href="/">
+    {%- elif pagename == root_doc -%}
+    <a class="topbar-logo" href="./">
+    {%- else -%}
+    <a class="topbar-logo" href="{{ pathto(root_doc) }}">
+    {%- endif -%}
+      <img src="{{ pathto('_static/images/logo-psutil.svg', 1) }}" alt="">
+      <span>psutil</span>
+    </a>
+    <nav class="topbar-actions" aria-label="{{ _('Site actions') }}">
+      <a class="topbar-text" href="{{ pathto('blog') }}">{{ _('Blog') }}</a>
+      <button class="topbar-btn" id="theme-toggle"
+              type="button" title="{{ _('Toggle dark mode (shift+D)') }}" aria-label="{{ _('Toggle theme') }}">
+        <i class="fa-regular fa-moon" aria-hidden="true"></i>
+      </button>
+      <a class="topbar-link topbar-github"
+         href="https://github.com/giampaolo/psutil"
+         target="_blank" rel="noopener" title="{{ _('GitHub') }}" aria-label="{{ _('GitHub repository') }}">
+        <i class="fa-brands fa-github" aria-hidden="true"></i>
+        <span class="topbar-stars" data-repo="giampaolo/psutil"></span>
+      </a>
+      {%- if versions %}
+      <details class="topbar-versions" id="version-selector"
+               data-version-page="{% if pagename != root_doc and pagename != '404' %}{{ pagename }}{% endif %}">
+        <summary title="{{ _('Switch documentation version') }}"
+                 aria-label="{{ _('Switch documentation version') }}">
+          <span class="topbar-versions-current">{{ versions_current }}</span>
+        </summary>
+        <div class="topbar-versions-menu">
+          {%- for v in versions %}
+          {%- if v.ref and not (loop.previtem and loop.previtem.ref) %}
+          <hr class="topbar-versions-sep">
+          {%- endif %}
+          {%- if v.url.startswith('http') or pagename == '404' -%}
+            {%- set href = v.url -%}
+          {%- elif v.url == '/' -%}
+            {%- set href = './' if pagename == root_doc else pathto(root_doc) -%}
+          {%- else -%}
+            {%- set href = pathto(v.url.strip('/') ~ '/', 1) -%}
+          {%- endif -%}
+          <a class="topbar-versions-item{% if v.name == versions_current %} is-current{% endif %}"
+             href="{{ href }}">
+            <span class="topbar-versions-name">{{ v.name }}</span>
+            {%- if v.note %}<span class="topbar-versions-note">{{ v.note }}</span>{% endif %}
+          </a>
+          {%- endfor %}
+        </div>
+      </details>
+      {%- endif %}
+      <button class="topbar-btn topbar-toc-toggle" id="toc-toggle"
+              type="button" title="{{ _('On this page') }}"
+              aria-label="{{ _('On this page') }}" aria-expanded="false">
+        <i class="fa-solid fa-list-ul" aria-hidden="true"></i>
+      </button>
+    </nav>
+  </div>
+</header>
diff --git a/docs/_themes/pydoctheme/static/pydoctheme.css b/docs/_themes/pydoctheme/static/pydoctheme.css
deleted file mode 100644
index 4196e5582c..0000000000
--- a/docs/_themes/pydoctheme/static/pydoctheme.css
+++ /dev/null
@@ -1,187 +0,0 @@
-@import url("default.css");
-
-body {
-    background-color: white;
-    margin-left: 1em;
-    margin-right: 1em;
-}
-
-div.related {
-    margin-bottom: 1.2em;
-    padding: 0.5em 0;
-    border-top: 1px solid #ccc;
-    margin-top: 0.5em;
-}
-
-div.related a:hover {
-    color: #0095C4;
-}
-
-div.related:first-child {
-    border-top: 0;
-    padding-top: 0;
-    border-bottom: 1px solid #ccc;
-}
-
-div.sphinxsidebar {
-    background-color: #eeeeee;
-    border-radius: 5px;
-    line-height: 130%;
-    font-size: smaller;
-}
-
-div.sphinxsidebar h3, div.sphinxsidebar h4 {
-    margin-top: 1.5em;
-}
-
-div.sphinxsidebarwrapper > h3:first-child {
-    margin-top: 0.2em;
-}
-
-div.sphinxsidebarwrapper > ul > li > ul > li {
-    margin-bottom: 0.4em;
-}
-
-div.sphinxsidebar a:hover {
-    color: #0095C4;
-}
-
-div.sphinxsidebar input {
-    font-family: 'Lucida Grande','Lucida Sans','DejaVu Sans',Arial,sans-serif;
-    border: 1px solid #999999;
-    font-size: smaller;
-    border-radius: 3px;
-}
-
-div.sphinxsidebar input[type=text] {
-    max-width: 150px;
-}
-
-div.body {
-    padding: 0 0 0 1.2em;
-}
-
-div.body p {
-    line-height: 140%;
-}
-
-div.body h1, div.body h2, div.body h3, div.body h4, div.body h5, div.body h6 {
-    margin: 0;
-    border: 0;
-    padding: 0.3em 0;
-}
-
-div.body hr {
-    border: 0;
-    background-color: #ccc;
-    height: 1px;
-}
-
-div.body pre {
-    border-radius: 3px;
-    border: 1px solid #ac9;
-}
-
-div.body div.admonition, div.body div.impl-detail {
-    border-radius: 3px;
-}
-
-div.body div.impl-detail > p {
-    margin: 0;
-}
-
-div.body div.seealso {
-    border: 1px solid #dddd66;
-}
-
-div.body a {
-    color: #00608f;
-}
-
-div.body a:visited {
-    color: #30306f;
-}
-
-div.body a:hover {
-    color: #00B0E4;
-}
-
-tt, pre {
-    font-family: monospace, sans-serif;
-    font-size: 96.5%;
-}
-
-div.body tt {
-    border-radius: 3px;
-}
-
-div.body tt.descname {
-    font-size: 120%;
-}
-
-div.body tt.xref, div.body a tt {
-    font-weight: normal;
-}
-
-p.deprecated {
-    border-radius: 3px;
-}
-
-table.docutils {
-    border: 1px solid #ddd;
-    min-width: 20%;
-    border-radius: 3px;
-    margin-top: 10px;
-    margin-bottom: 10px;
-}
-
-table.docutils td, table.docutils th {
-    border: 1px solid #ddd !important;
-    border-radius: 3px;
-}
-
-table p, table li {
-    text-align: left !important;
-}
-
-table.docutils th {
-    background-color: #eee;
-    padding: 0.3em 0.5em;
-}
-
-table.docutils td {
-    background-color: white;
-    padding: 0.3em 0.5em;
-}
-
-table.footnote, table.footnote td {
-    border: 0 !important;
-}
-
-div.footer {
-    line-height: 150%;
-    margin-top: -2em;
-    text-align: right;
-    width: auto;
-    margin-right: 10px;
-}
-
-div.footer a:hover {
-    color: #0095C4;
-}
-
-div.body h1,
-div.body h2,
-div.body h3 {
-    background-color: #EAEAEA;
-    border-bottom: 1px solid #CCC;
-    padding-top: 2px;
-    padding-bottom: 2px;
-    padding-left: 5px;
-    margin-top: 5px;
-    margin-bottom: 5px;
-}
-
-div.body h2 {
-    padding-left:10px;
-}
diff --git a/docs/_themes/pydoctheme/theme.conf b/docs/_themes/pydoctheme/theme.conf
deleted file mode 100644
index 95b97e5369..0000000000
--- a/docs/_themes/pydoctheme/theme.conf
+++ /dev/null
@@ -1,23 +0,0 @@
-[theme]
-inherit = default
-stylesheet = pydoctheme.css
-pygments_style = sphinx
-
-[options]
-bodyfont = 'Lucida Grande', 'Lucida Sans', 'DejaVu Sans', Arial, sans-serif
-headfont = 'Lucida Grande', 'Lucida Sans', 'DejaVu Sans', Arial, sans-serif
-footerbgcolor = white
-footertextcolor = #555555
-relbarbgcolor = white
-relbartextcolor = #666666
-relbarlinkcolor = #444444
-sidebarbgcolor = white
-sidebartextcolor = #444444
-sidebarlinkcolor = #444444
-bgcolor = white
-textcolor = #222222
-linkcolor = #0090c0
-visitedlinkcolor = #00608f
-headtextcolor = #1a1a1a
-headbgcolor = white
-headlinkcolor = #aaaaaa
diff --git a/docs/about.rst b/docs/about.rst
new file mode 100644
index 0000000000..aeee7cc1fe
--- /dev/null
+++ b/docs/about.rst
@@ -0,0 +1,191 @@
+:orphan:
+
+.. _tips:
+
+About this site
+===============
+
+This site is built with `Sphinx <https://www.sphinx-doc.org/>`__, on top of its
+built-in ``basic`` theme. From there it has been heavily customized: the
+layout, navigation, search, dark mode, code blocks, mobile behavior, and many
+small details were rebuilt or extended specifically for these docs.
+
+Keyboard shortcuts
+------------------
+
+.. list-table::
+   :widths: 30 70
+   :header-rows: 1
+
+   * - Key
+     - Action
+   * - :kbd:`Shift+D`
+     - Toggle dark / light mode
+   * - :kbd:`Ctrl+K`
+     - Open search
+   * - :kbd:`↑` / :kbd:`↓`
+     - Navigate search results
+   * - :kbd:`Enter`
+     - Open highlighted search result
+   * - :kbd:`Escape`
+     - Close search / dialog
+   * - :kbd:`?`
+     - Show this help
+
+Dark mode
+---------
+
+.. |moon| raw:: html
+
+   <i class="fa-regular fa-moon" aria-hidden="true"></i>
+
+By default the site matches your operating system's light or dark setting.
+Click the |moon| icon in the top-right corner, or press :kbd:`Shift+D`
+anywhere, to override it. Your choice is saved and restored on your next visit.
+
+.. container:: about-shot-pair
+
+   .. image:: /_static/images/about/darkmode-light.png
+      :alt: Light mode
+      :class: about-shot
+
+   .. image:: /_static/images/about/darkmode-dark.png
+      :alt: Dark mode
+      :class: about-shot
+
+Documentation versions
+----------------------
+
+.. |tag| raw:: html
+
+   <i class="fa-solid fa-tag" aria-hidden="true"></i>
+
+The |tag| menu in the top-right corner switches between this development
+version of the docs, built from the master branch, and past releases.
+
+.. image:: /_static/images/about/versions.png
+   :alt: Version selector
+   :class: about-shot
+
+Clickable API references
+------------------------
+
+Identifiers in code blocks (e.g. ``p = psutil.Process()``, ``p.cpu_percent()``)
+are clickable. Hover over one of those to see the highlight, then click to jump
+to the corresponding API reference doc. This is powered by
+`sphinx-codeautolink <https://sphinx-codeautolink.readthedocs.io/>`__.
+
+.. image:: /_static/images/about/clickable.png
+   :alt: Clickable API reference
+   :class: about-shot
+
+Copy buttons
+------------
+
+Every code block has a copy button in its top-right corner which appears on
+hover. For interactive (``>>>``) examples it copies just the code, leaving out
+the prompts and the output, so you can paste it straight into a shell.
+
+.. image:: /_static/images/about/copy.png
+   :alt: Copy button
+   :class: about-shot
+
+Copy page
+---------
+
+Next to the title of every documentation page there's a *Copy page* button,
+which copies the page's RsT source to your clipboard. Handy for for pasting a
+whole page into an LLM.
+
+.. image:: /_static/images/about/copypage.png
+   :alt: Copy page button
+   :class: about-shot
+
+Search
+------
+
+Press :kbd:`Ctrl+K` to jump straight to the search box. Once results appear,
+use the :kbd:`↑` and :kbd:`↓` arrow keys to move through them and :kbd:`Enter`
+to open one.
+
+.. image:: /_static/images/about/search.png
+   :alt: Search results
+   :class: about-shot
+
+TOC / On this page
+------------------
+
+Wide screens show an "On this page" sidebar on the right, listing the current
+page's sections. As you scroll it highlights the section you're in, and
+clicking an entry jumps straight to it.
+
+.. image:: /_static/images/about/toc.png
+   :alt: On this page outline
+   :class: about-shot
+
+Back to top
+-----------
+
+On a long page, start scrolling back up and a small button will appear in the
+bottom-right corner. Click it to go back to the top of the page.
+
+.. image:: /_static/images/about/backtotop.png
+   :alt: Back-to-top button
+   :class: about-shot
+
+Reading on mobile
+-----------------
+
+On a phone the navigation collapses behind the **☰** button in the top bar. Tap
+it to open the menu, then swipe left anywhere on the page (or tap outside it)
+to close it again.
+
+.. image:: /_static/images/about/mobile.png
+   :alt: Mobile sidebar
+   :class: about-shot
+
+Blog
+----
+
+New releases and deep-dives are written up on the :doc:`blog <blog>`. Blog
+provides a RSS feed (the icon at the top of the blog page) so you can receive
+notifications of new blog posts from your reader + a commenting system provided
+by `giscus <https://giscus.app/>`_.
+
+Other internal optimizations
+----------------------------
+
+- Fonts and icons are served directly from this site, not from third-party CDNs
+  such as Google Fonts. This means the docs renders the same from all countries
+  (e.g. mainland China). Each font includes only the glyphs used by the site,
+  keeping page weight small.
+
+- Links to this site shared on social medias show rich preview cards.
+
+- Every page declares a canonical URL and is listed in a generated
+  ``sitemap.xml``, so search engines can discover and index the whole site.
+
+- The docs build is strict: Python code snippets are syntax-checked, and broken
+  links or unresolved API cross-references make the build fail.
+
+Linking from your own docs
+--------------------------
+
+Other Sphinx projects can cross-reference psutil's API directly through the
+`intersphinx <https://www.sphinx-doc.org/en/master/usage/extensions/intersphinx.html>`_
+extension. Add psutil to ``intersphinx_mapping`` in your ``conf.py``:
+
+.. code-block:: python
+
+   intersphinx_mapping = {
+       "psutil": ("https://psutil.io/", None),
+   }
+
+You can then reference any psutil object and it links straight here, e.g.:
+
+.. code-block:: rst
+
+   See :func:`psutil.cpu_times` function.
+
+This will automatically turn ``psutil.cpu_times`` into a link pointing to this
+site.
diff --git a/docs/adoption.rst b/docs/adoption.rst
new file mode 100644
index 0000000000..4360d563f3
--- /dev/null
+++ b/docs/adoption.rst
@@ -0,0 +1,213 @@
+Who uses psutil
+===============
+
+.. Numbers below are refreshed by `make refresh-adoption-stats`,
+   which writes them in-place from PyPI / GitHub. Run it before
+   tagging a release.
+
+psutil is among the
+`top 100 <https://clickpy.clickhouse.com/dashboard/psutil>`__ most-downloaded
+packages on PyPI, with **390+ million** downloads per month and **780,000+**
+`GitHub repositories <https://github.com/giampaolo/psutil/network/dependents>`__
+using it. The projects below are a small sample of notable software that
+depends on psutil. See also :doc:`alternatives` for related Python libraries
+and equivalents in other languages.
+
+Infrastructure / automation
+---------------------------
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 32 14 26
+
+   * - Project
+     - Description
+     - Stars
+     - psutil usage
+   * - `Home Assistant <https://github.com/home-assistant/core>`__
+     - Open source home automation platform
+     - |homeassistant-stars|
+     - system monitor integration
+   * - `Ansible <https://github.com/ansible/ansible>`__
+     - IT automation platform
+     - |ansible-stars|
+     - system fact gathering
+   * - `Apache Airflow <https://github.com/apache/airflow>`__
+     - Workflow orchestration platform
+     - |airflow-stars|
+     - process supervisor, unit testing
+   * - `Celery <https://github.com/celery/celery>`__
+     - Distributed task queue
+     - |celery-stars|
+     - worker process monitoring, memleak detection
+   * - `Salt <https://github.com/saltstack/salt>`__
+     - Infrastructure automation at scale
+     - |salt-stars|
+     - deep system data collection (grains)
+   * - `Dask <https://github.com/dask/dask>`__
+     - Parallel computing with task scheduling
+     - |dask-stars|
+     - `metrics dashboard <https://github.com/dask/dask/blob/0d40a604284e021d098682b71c55d0387a414925/docs/source/dashboard.rst#L147>`__, profiling
+   * - `Ajenti <https://github.com/ajenti/ajenti>`__
+     - Web-based server administration panel
+     - |ajenti-stars|
+     - monitoring plugins, deep integration
+
+AI / machine learning
+---------------------
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 32 14 26
+
+   * - Project
+     - Description
+     - Stars
+     - psutil usage
+   * - `TensorFlow <https://github.com/tensorflow/tensorflow>`__
+     - Open source machine learning framework by Google
+     - |tensorflow-stars|
+     - unit tests
+   * - `PyTorch <https://github.com/pytorch/pytorch>`__
+     - Tensors and dynamic neural networks with GPU acceleration
+     - |pytorch-stars|
+     - benchmark scripts
+   * - `Ray <https://github.com/ray-project/ray>`__
+     - AI compute engine with distributed runtime
+     - |ray-stars|
+     - metrics dashboard
+   * - `MLflow <https://github.com/mlflow/mlflow>`__
+     - AI/ML engineering platform
+     - |mlflow-stars|
+     - deep system monitoring integration
+
+Developer tools
+---------------
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 32 14 26
+
+   * - Project
+     - Description
+     - Stars
+     - psutil usage
+   * - `Sentry <https://github.com/getsentry/sentry>`__
+     - Error tracking and performance monitoring
+     - |sentry-stars|
+     - send telemetry metrics
+   * - `Locust <https://github.com/locustio/locust>`__
+     - Scalable load testing in Python
+     - |locust-stars|
+     - monitoring of the Locust process
+   * - `Spyder <https://github.com/spyder-ide/spyder>`__
+     - Scientific Python IDE
+     - |spyder-stars|
+     - deep integration, UI stats, process management
+   * - `psleak <https://github.com/giampaolo/psleak>`__
+     - Test framework to detect memory leaks in Python C extensions
+     - |psleak-stars|
+     - heap process memory (:func:`heap_info()`)
+
+System monitoring
+-----------------
+
+.. list-table::
+   :header-rows: 1
+   :widths: 28 32 14 26
+
+   * - Project
+     - Description
+     - Stars
+     - psutil usage
+   * - `Glances <https://github.com/nicolargo/glances>`__
+     - System monitoring tool (top/htop alternative)
+     - |glances-stars|
+     - core dependency for all metrics
+   * - `bpytop <https://github.com/aristocratos/bpytop>`__
+     - Terminal resource monitor
+     - |bpytop-stars|
+     - core dependency for all metrics
+   * - `auto-cpufreq <https://github.com/AdnanHodzic/auto-cpufreq>`__
+     - Automatic CPU speed and power optimizer for Linux
+     - |auto-cpufreq-stars|
+     - core dependency for CPU monitoring
+   * - `GRR <https://github.com/google/grr>`__
+     - Remote live forensics by Google
+     - |grr-stars|
+     - core dependency for system data collection
+   * - `s-tui <https://github.com/amanusk/s-tui>`__
+     - Terminal CPU stress and monitoring utility
+     - |stui-stars|
+     - core dependency for metrics
+   * - `asitop <https://github.com/tlkh/asitop>`__
+     - Apple Silicon performance monitoring CLI
+     - |asitop-stars|
+     - core dependency for system metrics
+   * - `psdash <https://github.com/Jahaja/psdash>`__
+     - Web dashboard using psutil and Flask
+     - |psdash-stars|
+     - core dependency for all metrics
+   * - `dd-agent <https://github.com/DataDog/dd-agent>`__
+     - Original monitoring agent by Datadog
+     - |dd-agent-stars|
+     - system metrics collection
+   * - `dd-trace-py <https://github.com/DataDog/dd-trace-py>`__
+     - Python tracing and profiling library
+     - |ddtrace-stars|
+     - system metrics collection
+
+How this list was compiled
+--------------------------
+
+- `GitHub dependency graph <https://github.com/giampaolo/psutil/network/dependents>`__
+  was used to identify packages and repositories that depend on psutil.
+- GitHub code search with query "psutil in:readme language:Python", sorted by
+  stars, was used to find additional projects that mention psutil in their
+  README.
+- Each candidate was then manually verified by checking the project's
+  pyproject.toml, setup.py, setup.cfg or requirements.txt to confirm that
+  psutil is an actual dependency (direct, build-time, or optional), not just a
+  passing mention.
+- Projects were excluded if they only mention psutil in documentation or
+  examples without declaring it as a dependency.
+- Star counts are pulled dynamically from `shields.io <https://shields.io/>`__
+  badges.
+- The final list was manually curated to include notable projects and
+  meaningful usages of psutil across different areas of the Python ecosystem.
+
+.. ============================================================================
+.. ============================================================================
+.. ============================================================================
+
+.. Star badges
+.. ============================================================================
+
+.. |airflow-stars| image:: https://img.shields.io/github/stars/apache/airflow.svg?style=social&label=%20
+.. |ajenti-stars| image:: https://img.shields.io/github/stars/ajenti/ajenti.svg?style=social&label=%20
+.. |ansible-stars| image:: https://img.shields.io/github/stars/ansible/ansible.svg?style=social&label=%20
+.. |asitop-stars| image:: https://img.shields.io/github/stars/tlkh/asitop.svg?style=social&label=%20
+.. |auto-cpufreq-stars| image:: https://img.shields.io/github/stars/AdnanHodzic/auto-cpufreq.svg?style=social&label=%20
+.. |bpytop-stars| image:: https://img.shields.io/github/stars/aristocratos/bpytop.svg?style=social&label=%20
+.. |celery-stars| image:: https://img.shields.io/github/stars/celery/celery.svg?style=social&label=%20
+.. |dask-stars| image:: https://img.shields.io/github/stars/dask/dask.svg?style=social&label=%20
+.. |ddtrace-stars| image:: https://img.shields.io/github/stars/DataDog/dd-trace-py.svg?style=social&label=%20
+.. |dd-agent-stars| image:: https://img.shields.io/github/stars/DataDog/dd-agent.svg?style=social&label=%20
+.. |glances-stars| image:: https://img.shields.io/github/stars/nicolargo/glances.svg?style=social&label=%20
+.. |grr-stars| image:: https://img.shields.io/github/stars/google/grr.svg?style=social&label=%20
+.. |homeassistant-stars| image:: https://img.shields.io/github/stars/home-assistant/core.svg?style=social&label=%20
+.. |locust-stars| image:: https://img.shields.io/github/stars/locustio/locust.svg?style=social&label=%20
+.. |mlflow-stars| image:: https://img.shields.io/github/stars/mlflow/mlflow.svg?style=social&label=%20
+.. |psdash-stars| image:: https://img.shields.io/github/stars/Jahaja/psdash.svg?style=social&label=%20
+.. |psleak-stars| image:: https://img.shields.io/github/stars/giampaolo/psleak.svg?style=social&label=%20
+.. |pytorch-stars| image:: https://img.shields.io/github/stars/pytorch/pytorch.svg?style=social&label=%20
+.. |ray-stars| image:: https://img.shields.io/github/stars/ray-project/ray.svg?style=social&label=%20
+.. |salt-stars| image:: https://img.shields.io/github/stars/saltstack/salt.svg?style=social&label=%20
+.. |sentry-stars| image:: https://img.shields.io/github/stars/getsentry/sentry.svg?style=social&label=%20
+.. |spyder-stars| image:: https://img.shields.io/github/stars/spyder-ide/spyder.svg?style=social&label=%20
+.. |stui-stars| image:: https://img.shields.io/github/stars/amanusk/s-tui.svg?style=social&label=%20
+.. |tensorflow-stars| image:: https://img.shields.io/github/stars/tensorflow/tensorflow.svg?style=social&label=%20
+
+.. --- Notes
+.. Stars shield:
+.. https://shields.io/badges/git-hub-repo-stars
diff --git a/docs/alternatives.rst b/docs/alternatives.rst
new file mode 100644
index 0000000000..9dee2ba145
--- /dev/null
+++ b/docs/alternatives.rst
@@ -0,0 +1,183 @@
+Alternatives
+============
+
+This page describes Python tools and modules that overlap with psutil, to help
+you pick the right tool for the job. See also :doc:`adoption` for notable
+projects that use psutil.
+
+Python standard library
+-----------------------
+
+.. seealso::
+   :doc:`stdlib-equivalents` for a detailed function-by-function comparison.
+
+os module
+^^^^^^^^^
+
+The :mod:`os` module provides a handful of process-related functions:
+:func:`os.getpid`, :func:`os.getppid`, :func:`os.getuid`, :func:`os.cpu_count`,
+:func:`os.getloadavg` (UNIX only). These are cheap wrappers around POSIX
+syscalls and are perfectly fine when you only need information about the
+*current* process and don't need cross-platform code.
+
+psutil goes further in several directions. Its primary goal is to provide a
+**single portable interface** for concepts that are traditionally UNIX-only.
+Things like process CPU and memory usage, open file descriptors, network
+connections, signals, :term:`nice` levels, and I/O counters exist as
+first-class OS primitives on Linux and macOS, but have no direct equivalent on
+Windows. psutil implements all of them on Windows too (using Win32 APIs,
+``NtQuerySystemInformation`` and WMI) so that code written against psutil runs
+unmodified on every supported platform. Beyond portability, it also exposes the
+same information for *any* process (not just the current one), and returns
+structured named tuples instead of raw values.
+
+resource module
+^^^^^^^^^^^^^^^
+
+:mod:`resource` (UNIX only) lets you read and set resource limits
+(``RLIMIT_*``) and get basic usage counters (user/system time, page faults, I/O
+ops) for the *current* process or its children via :func:`resource.getrusage`.
+It is the right tool when you specifically want to enforce or inspect
+``ulimit``-style limits.
+
+psutil's :meth:`Process.rlimit` exposes the same interface but extends it to
+all processes, not just the caller.
+
+subprocess module
+^^^^^^^^^^^^^^^^^
+
+Calling tools like ``ps``, ``top``, ``netstat``, ``vmstat`` via
+:mod:`subprocess` and parsing their output is fragile: output formats differ
+across OS versions and locales, parsing is error-prone, and spawning a
+subprocess per sample is slow. psutil reads the same kernel data sources
+directly without spawning any external processes.
+
+platform module
+^^^^^^^^^^^^^^^
+
+:mod:`platform` provides information about the OS and Python runtime, such as
+OS name, kernel version, architecture, and machine type. It is useful for
+identifying the environment, but does not expose runtime metrics or process
+information like psutil. Overlaps with psutil's OS constants (:data:`LINUX`,
+:data:`WINDOWS`, :data:`MACOS`, etc.).
+
+/proc filesystem
+^^^^^^^^^^^^^^^^
+
+On Linux, ``/proc`` exposes process and system information as virtual files.
+Reading :proc:`/proc/pid/status` or :proc:`/proc/meminfo` directly is fast and
+has no dependencies, which is why some minimal containers or scripts do this.
+The downsides are that it is Linux-only, the format may vary across kernel
+versions, and you have to parse raw text yourself. psutil parses ``/proc``
+internally, exposes the same information through a consistent cross-platform
+API and handles edge cases (invalid format, compatibility with old kernels,
+graceful fallbacks, etc.).
+
+Third-party libraries
+---------------------
+
+Libraries that cover areas psutil does not, or that go deeper on a specific
+platform or subsystem.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 5 25
+   :class: longtable
+
+   * - Library
+     - Focus
+
+   * - `distro <https://github.com/python-distro/distro>`_
+     - Linux distro info (name, version, codename). psutil does not
+       expose OS details.
+
+   * - `GPUtil <https://github.com/anderskm/gputil>`_ /
+       `pynvml <https://github.com/gpuopenanalytics/pynvml>`_
+     - NVIDIA GPU utilization and VRAM usage.
+
+   * - `ifaddr <https://github.com/ifaddr/ifaddr>`_
+     - Network interface address enumeration.
+       Overlaps with :func:`net_if_addrs`.
+
+   * - `libvirt-python <https://github.com/libvirt/libvirt-python>`_
+     - Manage KVM/QEMU/Xen VMs: enumerate guests, query
+       CPU/memory allocation. Complements psutil's host-level view.
+
+   * - `prometheus_client <https://github.com/prometheus/client_python>`_
+     - Export metrics to Prometheus. Use *alongside* psutil.
+
+   * - `py-cpuinfo <https://github.com/workhorsy/py-cpuinfo>`_
+     - CPU brand string, micro architecture, feature flags.
+
+   * - `pyroute2 <https://github.com/svinota/pyroute2>`_
+     - Linux netlink (interfaces, routes, connections).
+       Overlaps with :func:`net_if_addrs`, :func:`net_if_stats`,
+       :func:`net_connections`.
+
+   * - `pywifi <https://github.com/awkman/pywifi>`_
+     - WiFi scanning, signal strength, SSID. Exposes wireless
+       details that :func:`net_if_addrs` does not.
+
+   * - `pySMART <https://github.com/truenas/py-SMART>`_
+     - S.M.A.R.T. disk health data. Complements
+       :func:`disk_io_counters`.
+
+   * - `pywin32 <https://github.com/mhammond/pywin32>`_
+     - Win32 API bindings (Windows only).
+
+   * - `setproctitle <https://github.com/dvarrazzo/py-setproctitle>`_
+     - Set process title shown by ``ps``/``top``. Writes what
+       :meth:`Process.name` reads.
+
+   * - `wmi <https://github.com/tjguk/wmi>`_
+     - WMI interface (Windows only).
+
+Other languages
+---------------
+
+Equivalent libraries in other languages providing cross-platform system and
+process information.
+
+.. list-table::
+   :header-rows: 1
+   :widths: 5 5 20
+   :class: longtable
+
+   * - Library
+     - Language
+     - Focus
+
+   * - `gopsutil <https://github.com/shirou/gopsutil>`_
+     - Go
+     - CPU, memory, disk, network, processes. Directly inspired
+       by psutil and follows a similar API.
+
+   * - `heim <https://github.com/heim-rs/heim>`_
+     - Rust
+     - Async-first library covering CPU, memory, disk, network,
+       processes and sensors.
+
+   * - `Hardware.Info <https://github.com/Jinjinov/Hardware.Info>`_
+     - C# / .NET
+     - CPU, RAM, GPU, disk, network, battery.
+
+   * - `hwinfo <https://github.com/lfreist/hwinfo>`_
+     - C++
+     - CPU, RAM, GPU, disks, mainboard. More hardware-focused.
+
+   * - `OSHI <https://github.com/oshi/oshi>`_
+     - Java
+     - OS and hardware information: CPU, memory, disk, network,
+       processes, sensors, USB devices.
+
+   * - `rust-psutil <https://github.com/rust-psutil/rust-psutil>`_
+     - Rust
+     - Directly inspired by psutil and follows a similar API.
+
+   * - `sysinfo <https://github.com/GuillaumeGomez/sysinfo>`_
+     - Rust
+     - CPU, memory, disk, network, processes, components.
+
+   * - `systeminformation <https://github.com/sebhildebrandt/systeminformation>`_
+     - Node.js
+     - CPU, memory, disk, network, processes, battery, Docker.
diff --git a/docs/api-overview.rst b/docs/api-overview.rst
new file mode 100644
index 0000000000..f4096ee6f5
--- /dev/null
+++ b/docs/api-overview.rst
@@ -0,0 +1,573 @@
+API overview
+============
+
+Overview of the entire psutil API (on Linux). This serves as a quick reference
+to all available functions. For detailed documentation of each function see the
+full :doc:`API reference <api>`.
+
+System related functions
+------------------------
+
+.. _api-overview-cpu:
+
+CPU
+^^^
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> psutil.cpu_times()
+    scputimes(user=3961.46,
+              nice=169.729,
+              system=2150.659,
+              idle=16900.540,
+              iowait=629.59,
+              irq=0.0,
+              softirq=19.42,
+              steal=0.0,
+              guest=0,
+              guest_nice=0.0)
+    >>>
+    >>> for x in range(3):
+    ...     psutil.cpu_percent(interval=1)
+    ...
+    4.0
+    5.9
+    3.8
+    >>>
+    >>> for x in range(3):
+    ...     psutil.cpu_percent(interval=1, percpu=True)
+    ...
+    [4.0, 6.9, 3.7, 9.2]
+    [7.0, 8.5, 2.4, 2.1]
+    [1.2, 9.0, 9.9, 7.2]
+    >>>
+    >>> for x in range(3):
+    ...     psutil.cpu_times_percent(interval=1, percpu=False)
+    ...
+    scputimes(user=1.5, nice=0.0, system=0.5, idle=96.5, iowait=1.5, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
+    scputimes(user=1.0, nice=0.0, system=0.0, idle=99.0, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
+    scputimes(user=2.0, nice=0.0, system=0.0, idle=98.0, iowait=0.0, irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
+    >>>
+    >>> psutil.cpu_count()
+    4
+    >>> psutil.cpu_count(logical=False)
+    2
+    >>>
+    >>> psutil.cpu_stats()
+    scpustats(ctx_switches=20455687, interrupts=6598984, soft_interrupts=2134212, syscalls=0)
+    >>>
+    >>> psutil.cpu_freq()
+    scpufreq(current=931.42925, min=800.0, max=3500.0)
+    >>>
+    >>> psutil.getloadavg()  # also on Windows (emulated)
+    (3.14, 3.89, 4.67)
+    >>>
+
+.. _api-overview-memory:
+
+Memory
+^^^^^^
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> psutil.virtual_memory()
+    svmem(total=10367352832,
+          available=6472179712,
+          percent=37.6,
+          used=8186245120,
+          free=2181107712,
+          active=4748992512,
+          inactive=2758115328,
+          buffers=790724608,
+          cached=3500347392,
+          shared=787554304)
+    >>>
+    >>> psutil.swap_memory()
+    sswap(total=2097147904,
+          used=296128512,
+          free=1801019392,
+          percent=14.1,
+          sin=304193536,
+          sout=677842944)
+    >>>
+
+.. _api-overview-disks:
+
+Disks
+^^^^^
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> psutil.disk_partitions()
+    [sdiskpart(device='/dev/sda1', mountpoint='/', fstype='ext4', opts='rw,nosuid'),
+     sdiskpart(device='/dev/sda2', mountpoint='/home', fstype='ext', opts='rw')]
+    >>>
+    >>> psutil.disk_usage('/')
+    sdiskusage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)
+    >>>
+    >>> psutil.disk_io_counters(perdisk=False)
+    sdiskio(read_count=719566,
+            write_count=1082197,
+            read_bytes=18626220032,
+            write_bytes=24081764352,
+            read_time=5023392,
+            write_time=63199568,
+            read_merged_count=619166,
+            write_merged_count=812396,
+            busy_time=4523412)
+    >>>
+
+.. _api-overview-network:
+
+Network
+^^^^^^^
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> psutil.net_io_counters(pernic=True)
+    {'eth0': netio(bytes_sent=485291293,
+                   bytes_recv=6004858642,
+                   packets_sent=3251564,
+                   packets_recv=4787798,
+                   errin=0,
+                   errout=0,
+                   dropin=0,
+                   dropout=0),
+     'lo': netio(bytes_sent=2838627,
+                 bytes_recv=2838627,
+                 packets_sent=30567,
+                 packets_recv=30567,
+                 errin=0,
+                 errout=0,
+                 dropin=0,
+                 dropout=0)}
+    >>>
+    >>> psutil.net_connections(kind='tcp')
+    [sconn(fd=115,
+           family=<AddressFamily.AF_INET: 2>,
+           type=<SocketType.SOCK_STREAM: 1>,
+           laddr=addr(ip='10.0.0.1', port=48776),
+           raddr=addr(ip='93.186.135.91', port=80),
+           status='ESTABLISHED',
+           pid=1254),
+     sconn(fd=117,
+           family=<AddressFamily.AF_INET: 2>,
+           type=<SocketType.SOCK_STREAM: 1>,
+           laddr=addr(ip='10.0.0.1', port=43761),
+           raddr=addr(ip='72.14.234.100', port=80),
+           status='CLOSING',
+           pid=2987),
+     ...]
+    >>>
+    >>> psutil.net_if_addrs()
+    {'lo': [snicaddr(family=<AddressFamily.AF_INET: 2>,
+                     address='127.0.0.1',
+                     netmask='255.0.0.0',
+                     broadcast='127.0.0.1',
+                     ptp=None),
+            snicaddr(family=<AddressFamily.AF_INET6: 10>,
+                     address='::1',
+                     netmask='ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
+                     broadcast=None,
+                     ptp=None),
+            snicaddr(family=<AddressFamily.AF_LINK: 17>,
+                     address='00:00:00:00:00:00',
+                     netmask=None,
+                     broadcast='00:00:00:00:00:00',
+                     ptp=None)],
+     'wlan0': [snicaddr(family=<AddressFamily.AF_INET: 2>,
+                        address='192.168.1.3',
+                        netmask='255.255.255.0',
+                        broadcast='192.168.1.255',
+                        ptp=None),
+               snicaddr(family=<AddressFamily.AF_INET6: 10>,
+                        address='fe80::c685:8ff:fe45:641%wlan0',
+                        netmask='ffff:ffff:ffff:ffff::',
+                        broadcast=None,
+                        ptp=None),
+               snicaddr(family=<AddressFamily.AF_LINK: 17>,
+                        address='c4:85:08:45:06:41',
+                        netmask=None,
+                        broadcast='ff:ff:ff:ff:ff:ff',
+                        ptp=None)]}
+    >>>
+    >>> psutil.net_if_stats()
+    {'lo': snicstats(isup=True,
+                     duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN: 0>,
+                     speed=0,
+                     mtu=65536,
+                     flags='up,loopback,running'),
+     'wlan0': snicstats(isup=True,
+                        duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>,
+                        speed=100,
+                        mtu=1500,
+                        flags='up,broadcast,running,multicast')}
+    >>>
+
+.. _api-overview-sensors:
+
+Sensors
+^^^^^^^
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> psutil.sensors_temperatures()
+    {'acpitz': [shwtemp(label='', current=47.0, high=103.0, critical=103.0)],
+     'asus': [shwtemp(label='', current=47.0, high=None, critical=None)],
+     'coretemp': [shwtemp(label='Physical id 0', current=52.0, high=100.0, critical=100.0),
+                  shwtemp(label='Core 0', current=45.0, high=100.0, critical=100.0)]}
+    >>>
+    >>> psutil.sensors_fans()
+    {'asus': [sfan(label='cpu_fan', current=3200)]}
+    >>>
+    >>> psutil.sensors_battery()
+    sbattery(percent=93, secsleft=16628, power_plugged=False)
+    >>>
+
+Other system info
+^^^^^^^^^^^^^^^^^
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> psutil.users()
+    [suser(name='giampaolo', terminal='pts/2', host='localhost', started=1340737536.0, pid=1352),
+     suser(name='giampaolo', terminal='pts/3', host='localhost', started=1340737792.0, pid=1788)]
+    >>>
+    >>> psutil.boot_time()
+    1365519115.0
+    >>>
+
+.. _api-overview-processes:
+
+Processes
+---------
+
+Oneshot
+^^^^^^^
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> p = psutil.Process(7055)
+    >>> with p.oneshot():
+    ...     p.name()
+    ...     p.cpu_times()
+    ...     p.memory_info()
+    ...
+    'python3'
+    pcputimes(user=1.02, system=0.31, children_user=0.32, children_system=0.1, iowait=0.0)
+    pmem(rss=3164160, vms=4410163, shared=897433, text=302694, data=2422374)
+    >>>
+
+Identity
+^^^^^^^^
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> p = psutil.Process(7055)
+    >>> p
+    psutil.Process(pid=7055, name='python3', status=<ProcessStatus.STATUS_RUNNING: 'running'>, started='09:04:44')
+    >>> p.pid
+    7055
+    >>>
+    >>> p.name()
+    'python3'
+    >>>
+    >>> p.exe()
+    '/usr/bin/python3'
+    >>>
+    >>> p.cwd()
+    '/home/giampaolo'
+    >>>
+    >>> p.cmdline()
+    ['/usr/bin/python3', 'main.py']
+    >>>
+    >>> p.status()
+    <ProcessStatus.STATUS_RUNNING: 'running'>
+    >>>
+    >>> p.create_time()
+    1267551141.5019531
+    >>>
+    >>> p.terminal()
+    '/dev/pts/0'
+    >>>
+    >>> p.environ()
+    {'GREP_OPTIONS': '--color=auto',
+     'LC_PAPER': 'it_IT.UTF-8',
+     'SHELL': '/bin/bash',
+     'XDG_CONFIG_DIRS': '/etc/xdg/xdg-ubuntu:/usr/share/upstart/xdg:/etc/xdg',
+     ...}
+    >>>
+    >>> p.is_running()
+    True
+    >>>
+    >>> p.as_dict()
+    {'num_ctx_switches': pctxsw(voluntary=63, involuntary=1),
+     'pid': 5457,
+     'status': <ProcessStatus.STATUS_RUNNING: 'running'>,
+     ...}
+    >>>
+
+Process tree
+^^^^^^^^^^^^
+
+.. code-block:: pycon
+
+    >>> p.ppid()
+    7054
+    >>> p.parent()
+    psutil.Process(pid=4699, name='bash', status=<ProcessStatus.STATUS_SLEEPING: 'sleeping'>, started='09:06:44')
+    >>>
+    >>> p.parents()
+    [psutil.Process(pid=4699, name='bash', started='09:06:44'),
+     psutil.Process(pid=4689, name='gnome-terminal-server', status=<ProcessStatus.STATUS_SLEEPING: 'sleeping'>, started='0:06:44'),
+     psutil.Process(pid=1, name='systemd', status=<ProcessStatus.STATUS_SLEEPING: 'sleeping'>, started='05:56:55')]
+    >>>
+    >>> p.children(recursive=True)
+    [psutil.Process(pid=29835, name='python3', status=<ProcessStatus.STATUS_SLEEPING: 'sleeping'>, started='11:45:38'),
+     psutil.Process(pid=29836, name='python3', status=<ProcessStatus.STATUS_WAKING: 'waking'>, started='11:43:39')]
+    >>>
+
+Credentials
+^^^^^^^^^^^^
+
+.. code-block:: pycon
+
+    >>> p.username()
+    'giampaolo'
+    >>> p.uids()
+    puids(real=1000, effective=1000, saved=1000)
+    >>> p.gids()
+    pgids(real=1000, effective=1000, saved=1000)
+    >>>
+
+CPU / scheduling
+^^^^^^^^^^^^^^^^
+
+.. code-block:: pycon
+
+    >>> p.cpu_times()
+    pcputimes(user=1.02, system=0.31, children_user=0.32, children_system=0.1, iowait=0.0)
+    >>>
+    >>> p.cpu_percent(interval=1.0)
+    12.1
+    >>>
+    >>> p.cpu_affinity()
+    [0, 1, 2, 3]
+    >>> p.cpu_affinity([0, 1])  # set
+    >>>
+    >>> p.cpu_num()
+    1
+    >>>
+    >>> p.num_ctx_switches()
+    pctxsw(voluntary=78, involuntary=19)
+    >>>
+    >>> p.nice()
+    0
+    >>> p.nice(10)  # set
+    >>>
+    >>> p.ionice(psutil.IOPRIO_CLASS_IDLE)  # set IO priority
+    >>> p.ionice()
+    pionice(ioclass=<ProcessIOPriority.IOPRIO_CLASS_IDLE: 3>, value=0)
+    >>>
+    >>> p.rlimit(psutil.RLIMIT_NOFILE, (5, 5))  # set resource limits
+    >>> p.rlimit(psutil.RLIMIT_NOFILE)
+    (5, 5)
+    >>>
+
+Memory
+^^^^^^
+
+.. code-block:: pycon
+
+    >>> p.memory_info()
+    pmem(rss=3164160, vms=4410163, shared=897433, text=302694, data=2422374)
+    >>>
+    >>> p.memory_extras()
+    pmem_extras(peak_rss=4172190,
+                peak_vms=6399001,
+                rss_anon=2266726,
+                rss_file=897433,
+                rss_shmem=0,
+                swap_anon=0,
+                hugetlb=0)
+    >>>
+    >>> p.memory_percent()
+    0.7823
+    >>>
+    >>> p.memory_footprint()  # "real" USS memory usage
+    pfootprint(uss=2355200, pss=2483712, swap=0)
+    >>>
+    >>> p.memory_maps()
+    pmmap_grouped(path='/lib/x8664-linux-gnu/libc-2.15.so',
+                  rss=3821568,
+                  size=3842048,
+                  pss=3821568,
+                  shared_clean=0,
+                  shared_dirty=0,
+                  private_clean=0,
+                  private_dirty=3821568,
+                  referenced=3575808,
+                  anonymous=3821568,
+                  swap=0),
+    pmmap_grouped(path='[heap]',
+                  rss=32768,
+                  size=139264,
+                  pss=32768,
+                  shared_clean=0,
+                  shared_dirty=0,
+                  private_clean=0,
+                  private_dirty=32768,
+                  referenced=32768,
+                  anonymous=32768,
+                  swap=0),
+    ...]
+    >>>
+    >>> p.page_faults()
+    ppagefaults(minor=5905, major=3)
+    >>>
+
+Threads
+^^^^^^^
+
+.. code-block:: pycon
+
+    >>> p.threads()
+    [pthread(id=5234, user_time=22.5, system_time=9.2891),
+     pthread(id=5237, user_time=0.0707, system_time=1.1)]
+    >>> p.num_threads()
+    4
+    >>>
+
+Files and connections
+^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: pycon
+
+    >>> p.io_counters()
+    pio(read_count=478001,
+        write_count=59371,
+        read_bytes=700416,
+        write_bytes=69632,
+        read_chars=456232,
+        write_chars=517543)
+    >>>
+    >>> p.open_files()
+    [popenfile(path='/home/giampaolo/monit.py', fd=3, position=0, mode='r', flags=32768),
+     popenfile(path='/var/log/monit.log', fd=4, position=235542, mode='a', flags=33793)]
+    >>>
+    >>> p.net_connections(kind='tcp')
+    [pconn(fd=115,
+           family=<AddressFamily.AF_INET: 2>,
+           type=<SocketType.SOCK_STREAM: 1>,
+           laddr=addr(ip='10.0.0.1', port=48776),
+           raddr=addr(ip='93.186.135.91', port=80),
+           status=<ConnectionStatus.CONN_ESTABLISHED: 'ESTABLISHED'>),
+     pconn(fd=117,
+           family=<AddressFamily.AF_INET: 2>,
+           type=<SocketType.SOCK_STREAM: 1>,
+           laddr=addr(ip='10.0.0.1', port=43761),
+           raddr=addr(ip='72.14.234.100', port=80),
+           status=<ConnectionStatus.CONN_CLOSING: 'CLOSING'>)]
+    >>>
+    >>> p.num_fds()
+    8
+    >>>
+
+Signals
+^^^^^^^
+
+.. code-block:: pycon
+
+    >>> p.send_signal(signal.SIGTERM)
+    >>> p.suspend()
+    >>> p.resume()
+    >>> p.terminate()
+    >>> p.kill()
+    >>> p.wait(timeout=3)
+    <NegSignal.SIGTERM: -15>
+    >>>
+
+Other process functions
+^^^^^^^^^^^^^^^^^^^^^^^
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> psutil.pids()
+    [1, 2, 3, 4, 5, 6, 7, 46, 48, 50, 51, 178, 182, ...]
+    >>>
+    >>> psutil.pid_exists(3)
+    True
+    >>>
+    >>> for p in psutil.process_iter(['pid', 'name']):
+    ...     print(p.pid, p.name())
+    ...
+    1 systemd
+    2 kthreadd
+    3 ksoftirqd/0
+    ...
+    >>>
+    >>> def on_terminate(proc):
+    ...     print("process {} terminated".format(proc))
+    ...
+    >>> # waits for multiple processes to terminate
+    >>> gone, alive = psutil.wait_procs(procs_list, timeout=3, callback=on_terminate)
+    >>>
+
+C heap introspection
+--------------------
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> psutil.heap_info()
+    pheap(heap_used=5177792, mmap_used=819200)
+    >>>
+    >>> psutil.heap_trim()
+    >>>
+
+See also `psleak <https://github.com/giampaolo/psleak>`_.
+
+Windows services
+----------------
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> list(psutil.win_service_iter())
+    [<WindowsService(name='AeLookupSvc', display_name='Application Experience') at 38850096>,
+     <WindowsService(name='ALG', display_name='Application Layer Gateway Service') at 38850128>,
+     <WindowsService(name='APNMCP', display_name='Ask Update Service') at 38850160>,
+     <WindowsService(name='AppIDSvc', display_name='Application Identity') at 38850192>,
+     ...]
+    >>>
+    >>> s = psutil.win_service_get('alg')
+    >>> s.as_dict()
+    {'binpath': 'C:\\Windows\\System32\\alg.exe',
+     'description': 'Provides support for 3rd party protocol plug-ins for Internet Connection Sharing',
+     'display_name': 'Application Layer Gateway Service',
+     'name': 'alg',
+     'pid': None,
+     'start_type': 'manual',
+     'status': 'stopped',
+     'username': 'NT AUTHORITY\\LocalService'}
+    >>>
diff --git a/docs/api.rst b/docs/api.rst
new file mode 100644
index 0000000000..78bc4f8c08
--- /dev/null
+++ b/docs/api.rst
@@ -0,0 +1,2764 @@
+.. note::
+   psutil 8.0 introduces breaking API changes. See the
+   :ref:`migration guide <migration-8.0>` if upgrading from 7.x.
+
+API reference
+=============
+
+Complete reference for all psutil classes and functions. Provided as a single
+HTML page for ease of searchability.
+
+.. contents::
+   :local:
+   :depth: 1
+
+For a high-level overview with short examples see :doc:`api-overview`.
+
+System related functions
+------------------------
+
+CPU
+^^^
+
+.. function:: cpu_times(percpu=False)
+
+  Return system CPU times as a named tuple. All fields are
+  :term:`cumulative counters <cumulative counter>` (seconds) representing time
+  the CPU has spent in each mode since boot. The attributes availability varies
+  depending on the platform. Cross-platform fields:
+
+  - :field:`user`: time spent by processes executing in user mode; on Linux
+    this also includes :field:`guest` time.
+
+  - :field:`system`: time spent by processes executing in kernel mode.
+
+  - :field:`idle`: time spent doing nothing.
+
+  Platform-specific fields:
+
+  - :field:`nice` *(Linux, macOS, BSD)*: time spent by :term:`niced <nice>`
+    (lower-priority) processes executing in user mode; on Linux this also
+    includes :field:`guest_nice` time.
+
+  - :field:`iowait` *(Linux, SunOS, AIX)*: time spent waiting for I/O to
+    complete (:term:`iowait`). This is *not* accounted in :field:`idle` time
+    counter.
+
+  - :field:`irq` *(Linux, Windows, BSD)*: time spent for servicing
+    :term:`hardware interrupts <hardware interrupt>`.
+
+  - :field:`softirq` *(Linux)*: time spent for servicing
+    :term:`soft interrupts <soft interrupt>`.
+
+  - :field:`steal` *(Linux)*: CPU time the virtual machine wanted to run, but
+    was used by other virtual machines or the host.
+
+  - :field:`guest` *(Linux)*: time the host CPU spent running a guest operating
+    system (virtual machine). Already included in :field:`user` time.
+
+  - :field:`guest_nice` *(Linux)*: like :field:`guest`, but for virtual CPUs
+    running at a lower :term:`nice` priority. Already included in :field:`nice`
+    time.
+
+  - :field:`dpc` *(Windows)*: time spent servicing deferred procedure calls
+    (DPCs); DPCs are interrupts that run at a lower priority than standard
+    interrupts.
+
+  When *percpu* is ``True`` return a list for each :term:`logical CPU` on the
+  system. The list is ordered by CPU index. The order of the list is consistent
+  across calls.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.cpu_times()
+     scputimes(user=17411.7, system=3797.02, idle=51266.57, nice=77.99, iowait=732.58, irq=0.01, softirq=142.43, steal=0.0, guest=0.0, guest_nice=0.0)
+
+  .. note::
+    CPU times are always supposed to increase over time, or at least remain the
+    same, and that's because time cannot go backwards. Surprisingly sometimes
+    this might not be the case (at least on Windows and Linux), see
+    `#1210 <https://github.com/giampaolo/psutil/issues/1210#issuecomment-363046156>`_.
+
+  .. versionchanged:: 8.0.0
+     Windows: :field:`interrupt` field was renamed to :field:`irq`;
+     :field:`interrupt` still works but raises :exc:`DeprecationWarning`.
+
+  .. versionchanged:: 8.0.0
+     field order was standardized: :field:`user`, :field:`system`,
+     :field:`idle` are now always the first three fields. Previously on Linux,
+     macOS, and BSD the first three were :field:`user`, :field:`nice`,
+     :field:`system`. See :ref:`migration guide <migration-8.0>`.
+
+.. function:: cpu_percent(interval=None, percpu=False)
+
+  Return the current system-wide CPU utilization as a percentage.
+
+  If *interval* is > ``0.0``, measures CPU times before and after the interval
+  (blocking). If ``0.0`` or ``None``, returns the utilization since the last
+  call or module import, returning immediately. That means the first time this
+  is called it will return a meaningless ``0.0`` value which you are supposed
+  to ignore. In this case it is recommended for accuracy that this function be
+  called with at least ``0.1`` seconds between calls.
+
+  If *percpu* is ``True``, returns a list of floats representing each
+  :term:`logical CPU`. The list is ordered by CPU index and consistent across
+  calls.
+
+  This function is thread-safe. It maintains an internal map of thread IDs
+  (:func:`threading.get_ident`) so that independent results are returned when
+  called from different threads at different intervals.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> # blocking
+     >>> psutil.cpu_percent(interval=1)
+     2.0
+     >>> # non-blocking (percentage since last call)
+     >>> psutil.cpu_percent(interval=None)
+     2.9
+     >>> # blocking, per-cpu
+     >>> psutil.cpu_percent(interval=1, percpu=True)
+     [5.6, 1.0]
+     >>>
+
+  .. seealso:: :ref:`faq_cpu_percent`
+
+  .. versionchanged:: 5.9.6
+     the function is now thread safe.
+
+.. function:: cpu_times_percent(interval=None, percpu=False)
+
+  Similar to :func:`cpu_percent`, but provides utilization percentages for each
+  specific CPU time. *interval* and *percpu* arguments have the same meaning as
+  in :func:`cpu_percent`. On Linux, :field:`guest` and :field:`guest_nice`
+  percentages are not accounted in :field:`user` and :field:`user_nice`.
+
+  .. seealso:: :ref:`faq_cpu_percent`
+
+  .. versionchanged:: 5.9.6
+     function is now thread safe.
+
+.. function:: cpu_count(logical=True)
+
+  Return the number of :term:`logical CPUs <logical CPU>` in the system (same
+  as :func:`os.cpu_count`), or ``None`` if undetermined. Unlike
+  :func:`os.cpu_count`, this is not influenced by the
+  :envvar:`PYTHON_CPU_COUNT` environment variable (Python 3.13+).
+
+  If *logical* is ``False`` return the number of
+  :term:`physical CPUs <physical CPU>` only, or ``None`` if undetermined
+  (always ``None`` on OpenBSD and NetBSD).
+
+  Example on a system with 2 cores + Hyper Threading:
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.cpu_count()
+     4
+     >>> psutil.cpu_count(logical=False)
+     2
+
+  Note that this may differ from the number of CPUs the current process can
+  actually use (e.g. due to :term:`CPU affinity`, cgroups, or Windows processor
+  groups). The number of usable CPUs can be obtained with:
+
+  .. code-block:: pycon
+
+     >>> len(psutil.Process().cpu_affinity())
+     1
+
+  .. seealso:: :ref:`faq_cpu_count`
+
+.. function:: cpu_stats()
+
+  Return various CPU statistics. All fields are
+  :term:`cumulative counters <cumulative counter>` since boot.
+
+  - :field:`ctx_switches`: number of :term:`context switches <context switch>`
+    (voluntary + involuntary).
+  - :field:`interrupts`: number of
+    :term:`hardware interrupts <hardware interrupt>`.
+  - :field:`soft_interrupts`: number of
+    :term:`soft interrupts <soft interrupt>`; always set to ``0`` on Windows
+    and SunOS.
+  - :field:`syscalls`: number of system calls; always set to ``0`` on Linux.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.cpu_stats()
+     scpustats(ctx_switches=20455687, interrupts=6598984, soft_interrupts=2134212, syscalls=0)
+
+.. function:: cpu_freq(percpu=False)
+
+  Return :field:`current`, :field:`min` and :field:`max` CPU frequencies
+  expressed in MHz. On Linux, :field:`current` is the real-time frequency value
+  (changing), on all other platforms this usually represents the nominal
+  "fixed" value (never changing).
+
+  If *percpu* is ``True``, and the system supports per-CPU frequency retrieval
+  (Linux and FreeBSD), a list of frequencies is returned for each CPU; if not,
+  a list with a single element is returned.
+
+  If :field:`min` and :field:`max` cannot be determined they are set to
+  ``0.0``.
+
+  On some systems the CPU frequency cannot be determined at all (e.g. certain
+  virtual machines, containers or CPU architectures). In that case this returns
+  ``None``, or an empty list if *percpu* is ``True``. This can happen on Linux,
+  macOS and FreeBSD; on Windows and OpenBSD a value is always returned.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.cpu_freq()
+     scpufreq(current=931.42925, min=800.0, max=3500.0)
+     >>> psutil.cpu_freq(percpu=True)
+     [scpufreq(current=2394.945, min=800.0, max=3500.0),
+      scpufreq(current=2236.812, min=800.0, max=3500.0),
+      scpufreq(current=1703.609, min=800.0, max=3500.0),
+      scpufreq(current=1754.289, min=800.0, max=3500.0)]
+
+  .. availability:: Linux, macOS, Windows, FreeBSD, OpenBSD.
+
+  .. versionchanged:: 5.5.1
+     added FreeBSD support.
+
+  .. versionchanged:: 5.9.1
+     added OpenBSD support.
+
+  .. versionchanged:: 8.0.0
+     on macOS ARM64 this may return ``None`` when CPU frequency data is
+     unavailable (e.g. on virtual machines), instead of raising.
+
+.. function:: getloadavg()
+
+  Return the average system load over the last 1, 5 and 15 minutes as a tuple.
+  On UNIX, this relies on :func:`os.getloadavg`. On Windows, this is emulated
+  via a background thread that updates every 5 seconds; the first call (and for
+  the following 5 seconds) returns ``(0.0, 0.0, 0.0)``. The values only make
+  sense relative to the number of installed :term:`logical CPUs <logical CPU>`
+  (e.g. ``3.14`` on a 10-CPU system means 31.4% load).
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.getloadavg()
+     (3.14, 3.89, 4.67)
+     >>> psutil.cpu_count()
+     10
+     >>> # percentage representation
+     >>> [x / psutil.cpu_count() * 100 for x in psutil.getloadavg()]
+     [31.4, 38.9, 46.7]
+
+Memory
+^^^^^^
+
+.. function:: virtual_memory()
+
+  Return statistics about system memory usage. All values are expressed in
+  bytes.
+
+  - :field:`total`: total physical RAM.
+  - :field:`available`: memory that can be given instantly to processes without
+    the system going into :term:`swap <swap memory>`. This is the recommended
+    field for monitoring actual memory usage in a cross-platform fashion. See
+    :term:`available memory`.
+  - :field:`percent`: the percentage usage calculated as
+    ``(total - available) / total * 100``.
+  - :field:`used`: memory in use, calculated differently depending on the
+    platform (see the table below). It is meant for informational purposes.
+    Neither ``total - free`` nor ``total - available`` necessarily equals
+    ``used``.
+  - :field:`free`: memory not currently allocated to anything. This is
+    typically much lower than :field:`available` because the OS keeps recently
+    freed memory as reclaimable cache (see :field:`cached` and
+    :field:`buffers`) rather than zeroing it immediately. Do not use this to
+    check for memory pressure; use :field:`available` instead.
+  - :field:`active` *(Linux, macOS, BSD)*: memory currently mapped by processes
+    or recently accessed, held in RAM. It is unlikely to be reclaimed unless
+    the system is under significant memory pressure.
+  - :field:`inactive` *(Linux, macOS, BSD)*: memory not recently accessed. It
+    still holds valid data (:term:`page cache`, old allocations) but is a
+    candidate for reclamation or :term:`swapping <swap memory>`. On BSD systems
+    it is counted in :field:`available`.
+  - :field:`buffers` *(Linux, BSD)*: see :term:`buffers`. On OpenBSD
+    :field:`buffers` and :field:`cached` are aliases.
+  - :field:`cached` *(Linux, BSD, Windows)*: RAM used by the kernel to cache
+    file contents (data read from or written to disk). On OpenBSD
+    :field:`buffers` and :field:`cached` are aliases. See :term:`page cache`.
+  - :field:`shared` *(Linux, BSD)*: :term:`shared memory` accessible by
+    multiple processes simultaneously, such as in-memory ``tmpfs`` and POSIX
+    shared memory objects (``shm_open``). On Linux this corresponds to
+    ``Shmem`` in :proc:`/proc/meminfo` and is already counted within
+    :field:`active` / :field:`inactive`.
+  - :field:`slab` *(Linux)*: memory used by the kernel's internal object caches
+    (e.g. inode and dentry caches). The reclaimable portion (``SReclaimable``)
+    is already included in :field:`cached`.
+  - :field:`wired` *(macOS, BSD, Windows)*: memory pinned in RAM by the kernel
+    (e.g. kernel code and critical data structures). It can never be moved to
+    disk.
+
+  Below is a table showing implementation details. All info on Linux is
+  retrieved from :proc:`/proc/meminfo`. On macOS via ``host_statistics64()``.
+  On Windows via `GetPerformanceInfo`_.
+
+  .. list-table::
+     :header-rows: 1
+     :widths: 9 15 14 14 26
+     :class: wide-table
+
+     * - Field
+       - Linux
+       - macOS
+       - Windows
+       - FreeBSD
+     * - total
+       - ``MemTotal``
+       - ``sysctl() hw.memsize``
+       - ``PhysicalTotal``
+       - ``sysctl() hw.physmem``
+     * - available
+       - ``MemAvailable``
+       - ``inactive + free``
+       - ``PhysicalAvailable``
+       - ``inactive + cached + free``
+     * - used
+       - ``total - available``
+       - ``active + wired``
+       - ``total - available``
+       - ``active + wired + cached``
+     * - free
+       - ``MemFree``
+       - ``free - speculative``
+       - same as ``available``
+       - ``sysctl() vm.stats.vm.v_free_count``
+     * - active
+       - ``Active``
+       - ``active``
+       -
+       - ``sysctl() vm.stats.vm.v_active_count``
+     * - inactive
+       - ``Inactive``
+       - ``inactive``
+       -
+       - ``sysctl() vm.stats.vm.v_inactive_count``
+     * - buffers
+       - ``Buffers``
+       -
+       -
+       - ``sysctl() vfs.bufspace``
+     * - cached
+       - ``Cached + SReclaimable``
+       -
+       - ``SystemCache``
+       - ``sysctl() vm.stats.vm.v_cache_count``
+     * - shared
+       - ``Shmem``
+       -
+       -
+       - ``sysctl(CTL_VM/VM_METER) t_vmshr + t_rmshr``
+     * - slab
+       - ``Slab``
+       -
+       -
+       -
+     * - wired
+       -
+       - ``wired``
+       - ``KernelNonpaged``
+       - ``sysctl() vm.stats.vm.v_wire_count``
+
+  Example on Linux:
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> mem = psutil.virtual_memory()
+     >>> mem
+     svmem(total=10367352832, available=6472179712, percent=37.6, used=8186245120, free=2181107712, active=4748992512, inactive=2758115328, buffers=790724608, cached=3500347392, shared=787554304, slab=199348224)
+     >>>
+     >>> THRESHOLD = 500 * 1024 * 1024  # 500MB
+     >>> if mem.available <= THRESHOLD:
+     ...     print("warning")
+     ...
+     >>>
+
+  .. note::
+     - On Linux, :field:`total`, :field:`free`, :field:`used`, :field:`shared`,
+       and :field:`available` match the output of the ``free`` command.
+     - On macOS, :field:`free`, :field:`active`, :field:`inactive`, and
+       :field:`wired` match ``vm_stat`` command.
+     - On BSD, :field:`free`, :field:`active`, :field:`inactive`,
+       :field:`cached`, and :field:`wired` match ``vmstat -s`` command.
+     - On Windows, :field:`total`, :field:`used` ("In use"), and
+       :field:`available` match the Task Manager (Performance > Memory tab).
+
+  .. note::
+    if you just want to know how much physical memory is left in a
+    cross-platform manner, rely on :field:`available` and :field:`percent`
+    fields.
+
+  .. seealso::
+    - :src:`scripts/meminfo.py`
+    - :ref:`faq_virtual_memory_available`
+    - :ref:`faq_used_plus_free`
+
+  .. versionchanged:: 8.0.0
+     Windows: added :field:`cached` and :field:`wired` fields.
+
+.. function:: swap_memory()
+
+  Return system :term:`swap memory` statistics:
+
+  * :field:`total`: total swap space. On Windows this is derived as
+    ``CommitLimit - PhysicalTotal``, representing virtual memory backed by the
+    page file rather than the raw page-file size.
+  * :field:`used`: swap space currently in use.
+  * :field:`free`: swap space not in use (``total - used``).
+  * :field:`percent`: swap usage as a percentage, calculated as
+    ``used / total * 100``.
+  * :field:`sin`: number of bytes the system has moved from disk
+    (:term:`swap <swap memory>`) back into RAM. See :term:`swap-in`.
+  * :field:`sout`: number of bytes the system has moved from RAM to disk
+    (:term:`swap <swap memory>`). A continuously increasing :field:`sout` rate
+    is a sign of memory pressure. See :term:`swap-out`.
+
+  :field:`sin` and :field:`sout` are
+  :term:`cumulative counters <cumulative counter>` since boot. Monitor their
+  rate of change rather than the absolute value to detect active
+  :term:`swapping <swap memory>`. On Windows both are always ``0``.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.swap_memory()
+     sswap(total=2097147904, used=886620160, free=1210527744, percent=42.3, sin=1050411008, sout=1906720768)
+
+  .. seealso::
+    - :src:`scripts/meminfo.py`
+    - :ref:`Swap activity recipe <recipe_swap_activity>`
+
+  .. versionchanged:: 8.0.0
+     OpenBSD: :field:`sin` / :field:`sout` are no longer set to ``0``.
+
+Disks
+^^^^^
+
+.. function:: disk_partitions(all=False)
+
+  Return mounted disk partitions as a list. This is similar to the ``df``
+  command on UNIX. When *all* is ``False``, virtual/pseudo filesystems (tmpfs,
+  sysfs, devtmpfs, cgroup, etc.) are excluded, keeping only physical devices
+  (e.g., hard disks, CD-ROM drives, USB keys). The filtering logic varies by
+  platform: on Linux, it checks :proc:`/proc/filesystems` for ``nodev``-flagged
+  types (ZFS is always included); on macOS, it checks whether the device path
+  exists; on SunOS and AIX, it excludes filesystems with zero total size. On
+  BSD, *all* is ignored and all partitions are always returned.
+
+  * :field:`device`: the device path (e.g. "/dev/hda1"). On Windows this is the
+    drive letter (e.g. "C:\\").
+  * :field:`mountpoint`: the mount point path (e.g. "/"). On Windows this is
+    the drive letter (e.g. "C:\\").
+  * :field:`fstype`: the partition filesystem (e.g. "ext3" on UNIX or "NTFS" on
+    Windows).
+  * :field:`opts`: a comma-separated string indicating different mount options
+    for the drive/partition. Platform-dependent.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.disk_partitions()
+     [sdiskpart(device='/dev/sda3', mountpoint='/', fstype='ext4', opts='rw,errors=remount-ro'),
+      sdiskpart(device='/dev/sda7', mountpoint='/home', fstype='ext4', opts='rw')]
+
+  .. seealso:: :src:`scripts/disk_usage.py`.
+
+  .. versionchanged:: 5.7.4
+     added :field:`maxfile` and :field:`maxpath` fields.
+
+  .. versionchanged:: 6.0.0
+     removed :field:`maxfile` and :field:`maxpath` fields.
+
+.. function:: disk_usage(path)
+
+  Return disk usage statistics for the partition containing *path*. Values are
+  expressed in bytes and include :field:`total`, :field:`used` and
+  :field:`free` space, plus the :field:`percentage` usage. On UNIX, *path* must
+  point to a path within a **mounted** filesystem partition. This function was
+  later incorporated in Python 3.3 as :func:`shutil.disk_usage` (see
+  :bpo:`12442`).
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.disk_usage('/')
+     sdiskusage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)
+
+  .. note::
+    UNIX typically reserves 5% of disk space for root. :field:`total` and
+    :field:`used` refer to overall space, while :field:`free` and
+    :field:`percent` reflect unprivileged user usage. As a result,
+    :field:`percent` may appear ~5% higher than expected. All values match the
+    ``df`` command line utility.
+
+  .. seealso:: :src:`scripts/disk_usage.py`.
+
+.. function:: disk_io_counters(perdisk=False, nowrap=True)
+
+  Return system-wide disk I/O statistics. All fields are
+  :term:`cumulative counters <cumulative counter>` since boot.
+
+  - :field:`read_count`: number of reads.
+  - :field:`write_count`: number of writes.
+  - :field:`read_bytes`: number of bytes read.
+  - :field:`write_bytes`: number of bytes written.
+
+  Platform-specific fields:
+
+  - :field:`read_time`: (all except *NetBSD* and *OpenBSD*) time spent reading
+    from disk (in milliseconds).
+  - :field:`write_time`: (all except *NetBSD* and *OpenBSD*) time spent writing
+    to disk (in milliseconds).
+  - :field:`busy_time`: (*Linux*, *FreeBSD*) time spent doing actual I/Os (in
+    milliseconds); see :term:`busy_time`.
+  - :field:`read_merged_count` (*Linux*): number of merged reads (see
+    `iostats doc`_).
+  - :field:`write_merged_count` (*Linux*): number of merged writes (see
+    `iostats doc`_).
+
+  If *perdisk* is ``True``, return the same information for every physical disk
+  as a dictionary with partition names as the keys.
+
+  If *nowrap* is ``True`` (default), counters that overflow and wrap to zero
+  are automatically adjusted so they never decrease (this can happen on very
+  busy or long-lived systems). ``disk_io_counters.cache_clear()`` can be used
+  to invalidate the *nowrap* cache.
+
+  On diskless machines this function will return ``None`` or ``{}`` if
+  *perdisk* is ``True``.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.disk_io_counters()
+     sdiskio(read_count=8141, write_count=2431, read_bytes=290203, write_bytes=537676, read_time=5868, write_time=94922)
+     >>>
+     >>> psutil.disk_io_counters(perdisk=True)
+     {'sda1': sdiskio(read_count=920, write_count=1, read_bytes=2933248, write_bytes=512, read_time=6016, write_time=4),
+      'sda2': sdiskio(read_count=18707, write_count=8830, read_bytes=6060, write_bytes=3443, read_time=24585, write_time=1572),
+      'sdb1': sdiskio(read_count=161, write_count=0, read_bytes=786432, write_bytes=0, read_time=44, write_time=0)}
+
+  .. note::
+     On Windows, you may need to run ``diskperf -y`` command first, otherwise
+     this function might not detect any disks.
+
+  .. seealso::
+     - :src:`scripts/iotop.py`
+     - :ref:`Real-time disk I/O recipe <recipe_disk_io>`
+     - :ref:`Real-time disk I/O percent recipe <recipe_disk_io_percent>`
+
+Network
+^^^^^^^
+
+.. function:: net_io_counters(pernic=False, nowrap=True)
+
+  Return system-wide network I/O statistics. All fields are
+  :term:`cumulative counters <cumulative counter>` since boot.
+
+  - :field:`bytes_sent`: number of bytes sent.
+  - :field:`bytes_recv`: number of bytes received.
+  - :field:`packets_sent`: number of packets sent.
+  - :field:`packets_recv`: number of packets received.
+  - :field:`errin`: total number of errors while receiving.
+  - :field:`errout`: total number of errors while sending.
+  - :field:`dropin`: total number of incoming packets dropped at the
+    :term:`NIC` level. Unlike :field:`errin`, drops indicate the interface or
+    kernel buffer was overwhelmed.
+  - :field:`dropout`: total number of outgoing packets dropped (always 0 on
+    macOS and BSD). A non-zero and growing count is a sign of network
+    saturation.
+
+  If *pernic* is ``True``, return the same information for every network
+  interface as a dictionary, with interface names as the keys.
+
+  If *nowrap* is ``True`` (default), counters that overflow and wrap to zero
+  are automatically adjusted so they never decrease (this can happen on very
+  busy or long-lived systems). ``net_io_counters.cache_clear()`` can be used to
+  invalidate the *nowrap* cache.
+
+  On machines with no :term:`NICs <NIC>` installed this function will return
+  ``None`` or ``{}`` if *pernic* is ``True``.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.net_io_counters()
+     snetio(bytes_sent=14508483, bytes_recv=62749361, packets_sent=84311, packets_recv=94888, errin=0, errout=0, dropin=0, dropout=0)
+     >>>
+     >>> psutil.net_io_counters(pernic=True)
+     {'lo': snetio(bytes_sent=547971, bytes_recv=547971, packets_sent=5075, packets_recv=5075, errin=0, errout=0, dropin=0, dropout=0),
+      'wlan0': snetio(bytes_sent=13921765, bytes_recv=62162574, packets_sent=79097, packets_recv=89648, errin=0, errout=0, dropin=0, dropout=0)}
+
+  .. seealso:: :src:`scripts/nettop.py` and :src:`scripts/ifconfig.py`.
+
+.. function:: net_connections(kind="inet")
+
+  Return system-wide socket connections as a list. Each entry provides 7
+  fields:
+
+  - :field:`fd`: the socket :term:`file descriptor`; set to ``-1`` on Windows
+    and SunOS.
+  - :field:`family`: the address family, either :data:`socket.AF_INET`,
+    :data:`socket.AF_INET6` or :data:`socket.AF_UNIX`.
+  - :field:`type`: the address type, either :data:`socket.SOCK_STREAM`,
+    :data:`socket.SOCK_DGRAM` or :data:`socket.SOCK_SEQPACKET`.
+  - :field:`laddr`: the local address as a ``(ip, port)`` named tuple, or a
+    ``path`` for :data:`socket.AF_UNIX` sockets.
+  - :field:`raddr`: the remote address. When the socket is not connected, this
+    is either an empty tuple (``AF_INET*``) or an empty string (``""``) for
+    ``AF_UNIX`` sockets (see note below).
+  - :field:`status`: a :data:`CONN_* <psutil.CONN_ESTABLISHED>` constant;
+    always :data:`CONN_NONE` for UDP and UNIX sockets.
+  - :field:`pid`: PID of the process which opened the socket. Set to ``None``
+    if it can't be retrieved due to insufficient permissions (e.g. Linux).
+
+  The *kind* parameter is a string which filters for connections matching the
+  following criteria:
+
+  .. table::
+
+   +----------------+-----------------------------------------------------+
+   | Kind value     | Connections using                                   |
+   +================+=====================================================+
+   | ``'inet'``     | IPv4 and IPv6                                       |
+   +----------------+-----------------------------------------------------+
+   | ``'inet4'``    | IPv4                                                |
+   +----------------+-----------------------------------------------------+
+   | ``'inet6'``    | IPv6                                                |
+   +----------------+-----------------------------------------------------+
+   | ``'tcp'``      | TCP                                                 |
+   +----------------+-----------------------------------------------------+
+   | ``'tcp4'``     | TCP over IPv4                                       |
+   +----------------+-----------------------------------------------------+
+   | ``'tcp6'``     | TCP over IPv6                                       |
+   +----------------+-----------------------------------------------------+
+   | ``'udp'``      | UDP                                                 |
+   +----------------+-----------------------------------------------------+
+   | ``'udp4'``     | UDP over IPv4                                       |
+   +----------------+-----------------------------------------------------+
+   | ``'udp6'``     | UDP over IPv6                                       |
+   +----------------+-----------------------------------------------------+
+   | ``'unix'``     | UNIX socket (both UDP and TCP protocols)            |
+   +----------------+-----------------------------------------------------+
+   | ``'all'``      | the sum of all the possible families and protocols  |
+   +----------------+-----------------------------------------------------+
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.net_connections()
+     [pconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status=<ConnectionStatus.CONN_ESTABLISHED: 'ESTABLISHED'>, pid=1254),
+      pconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status=<ConnectionStatus.CONN_CLOSING: 'CLOSING'>, pid=2987),
+      pconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=60759), raddr=addr(ip='72.14.234.104', port=80), status=<ConnectionStatus.CONN_ESTABLISHED: 'ESTABLISHED'>, pid=None),
+      pconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=51314), raddr=addr(ip='72.14.234.83', port=443), status=<ConnectionStatus.CONN_SYN_SENT: 'SYN_SENT'>, pid=None)
+      ...]
+
+  .. warning::
+    on Linux, retrieving some connections requires root privileges. If psutil
+    is not run as root, those connections are silently skipped instead of
+    raising :exc:`PermissionError`. That means the returned list may be
+    incomplete.
+
+  .. note::
+    - Linux, FreeBSD, OpenBSD: :field:`raddr` field for UNIX sockets is always
+      set to ``""``; this is a limitation of the OS.
+    - macOS and AIX: :exc:`AccessDenied` is always raised unless running as
+      root; this is a limitation of the OS.
+    - Solaris: UNIX sockets are not supported.
+
+  .. seealso::
+
+    - :meth:`Process.net_connections` to get per-process connections
+    - :src:`scripts/netstat.py`
+
+  .. versionchanged:: 5.9.5
+     OpenBSD: retrieve :field:`laddr` path for :data:`socket.AF_UNIX` sockets
+     (before it was an empty string).
+
+  .. versionchanged:: 8.0.0
+     :field:`status` field is now a :class:`ConnectionStatus` enum member
+     instead of a plain ``str``. See :ref:`migration guide <migration-8.0>`.
+
+.. function:: net_if_addrs()
+
+  Return a dict mapping each :term:`NIC` to its addresses. Interfaces may have
+  multiple addresses per family. Each entry includes 5 fields (addresses may be
+  ``None``):
+
+  - :field:`family`: the address family, either :data:`socket.AF_INET` (IPv4),
+    :data:`socket.AF_INET6` (IPv6), :data:`socket.AF_UNSPEC` (a virtual or
+    unconfigured NIC), or :data:`AF_LINK` (a MAC address).
+  - :field:`address`: the primary NIC address.
+  - :field:`netmask`: the netmask address.
+  - :field:`broadcast`: the broadcast address; always ``None`` on Windows.
+  - :field:`ptp`: a "point to point" address (typically a VPN); always ``None``
+    on Windows.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.net_if_addrs()
+     {'lo': [snicaddr(family=<AddressFamily.AF_INET: 2>, address='127.0.0.1', netmask='255.0.0.0', broadcast='127.0.0.1', ptp=None),
+             snicaddr(family=<AddressFamily.AF_INET6: 10>, address='::1', netmask='ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', broadcast=None, ptp=None),
+             snicaddr(family=<AddressFamily.AF_LINK: 17>, address='00:00:00:00:00:00', netmask=None, broadcast='00:00:00:00:00:00', ptp=None)],
+      'wlan0': [snicaddr(family=<AddressFamily.AF_INET: 2>, address='192.168.1.3', netmask='255.255.255.0', broadcast='192.168.1.255', ptp=None),
+                snicaddr(family=<AddressFamily.AF_INET6: 10>, address='fe80::c685:8ff:fe45:641%wlan0', netmask='ffff:ffff:ffff:ffff::', broadcast=None, ptp=None),
+                snicaddr(family=<AddressFamily.AF_LINK: 17>, address='c4:85:08:45:06:41', netmask=None, broadcast='ff:ff:ff:ff:ff:ff', ptp=None)]}
+     >>>
+
+  .. seealso:: :src:`scripts/nettop.py` and :src:`scripts/ifconfig.py`.
+
+  .. versionchanged:: 7.0.0
+     Windows: added support for :field:`broadcast` field, which is no longer
+     ``None``.
+
+.. function:: net_if_stats()
+
+  Return a dictionary mapping each :term:`NIC` to its stats:
+
+  - :field:`isup`: whether the NIC is up and running (bool).
+  - :field:`duplex`: :data:`NIC_DUPLEX_FULL`, :data:`NIC_DUPLEX_HALF` or
+    :data:`NIC_DUPLEX_UNKNOWN`.
+  - :field:`speed`: NIC speed in megabits (Mbps); ``0`` if undetermined.
+  - :field:`mtu`: maximum transmission unit in bytes.
+  - :field:`flags`: a comma-separated string of interface flags (e.g.
+    ``"up,broadcast,running,multicast"``); may be an empty string.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.net_if_stats()
+     {'eth0': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=100, mtu=1500, flags='up,broadcast,running,multicast'),
+      'lo': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN: 0>, speed=0, mtu=65536, flags='up,loopback,running')}
+
+  .. seealso:: :src:`scripts/nettop.py` and :src:`scripts/ifconfig.py`.
+
+  .. versionchanged:: 5.7.3
+     UNIX: :field:`isup` also reflects whether the :term:`NIC` is running.
+
+  .. versionchanged:: 5.9.3
+     added :field:`flags` field.
+
+Sensors
+^^^^^^^
+
+.. function:: sensors_temperatures(fahrenheit=False)
+
+  Return hardware temperatures. Each entry represents a sensor (CPU, disk,
+  etc.). Values are in Celsius unless *fahrenheit* is ``True``. If unsupported,
+  an empty dict is returned. Each entry includes:
+
+  - :field:`label`: string label for the sensor, if available, else ``""``.
+  - :field:`current`: current temperature reading (changing), or ``None`` if
+    unavailable.
+  - :field:`high`: sensor-specified high temperature threshold (fixed), or
+    ``None`` if unavailable. Typically indicates when hardware may start
+    throttling to reduce heat.
+  - :field:`critical`: sensor-specified critical temperature threshold (fixed),
+    or ``None`` if unavailable. Typically indicates when hardware considers
+    itself at risk; behavior may include throttling, fan ramp-up, or shutdown.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.sensors_temperatures()
+     {'acpitz': [shwtemp(label='', current=47.0, high=103.0, critical=103.0)],
+      'asus': [shwtemp(label='', current=47.0, high=None, critical=None)],
+      'coretemp': [shwtemp(label='Physical id 0', current=52.0, high=100.0, critical=100.0),
+                   shwtemp(label='Core 0', current=45.0, high=100.0, critical=100.0),
+                   shwtemp(label='Core 1', current=52.0, high=100.0, critical=100.0),
+                   shwtemp(label='Core 2', current=45.0, high=100.0, critical=100.0),
+                   shwtemp(label='Core 3', current=47.0, high=100.0, critical=100.0)]}
+
+  .. seealso:: :src:`scripts/temperatures.py` and :src:`scripts/sensors.py`.
+
+  .. availability:: Linux, FreeBSD
+
+  .. versionchanged:: 5.5.0
+     added FreeBSD support.
+
+.. function:: sensors_fans()
+
+  Return hardware fan speeds in RPM (revolutions per minute). If unsupported,
+  return an empty dict.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.sensors_fans()
+     {'asus': [sfan(label='cpu_fan', current=3200)]}
+
+  .. seealso:: :src:`scripts/fans.py` and :src:`scripts/sensors.py`.
+
+  .. availability:: Linux
+
+.. function:: sensors_battery()
+
+  Return battery status information. If no battery is installed or metrics
+  can't be determined ``None`` is returned.
+
+  - :field:`percent`: battery power left as a percentage.
+  - :field:`secsleft`: a rough approximation of how many seconds are left
+    before the battery runs out of power. If the AC power cable is connected
+    this is set to :data:`POWER_TIME_UNLIMITED`. If it can't be determined it
+    is set to :data:`POWER_TIME_UNKNOWN`.
+  - :field:`power_plugged`: ``True`` if the AC power cable is connected,
+    ``False`` if not, or ``None`` if it can't be determined.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>>
+     >>> def secs2hours(secs):
+     ...     mm, ss = divmod(secs, 60)
+     ...     hh, mm = divmod(mm, 60)
+     ...     return "%d:%02d:%02d" % (hh, mm, ss)
+     ...
+     >>> battery = psutil.sensors_battery()
+     >>> battery
+     sbattery(percent=93, secsleft=16628, power_plugged=False)
+     >>> print("charge = %s%%, time left = %s" % (battery.percent, secs2hours(battery.secsleft)))
+     charge = 93%, time left = 4:37:08
+
+  .. seealso:: :src:`scripts/battery.py` and :src:`scripts/sensors.py`.
+
+  .. availability:: Linux, Windows, macOS, FreeBSD
+
+-------------------------------------------------------------------------------
+
+Other system info
+^^^^^^^^^^^^^^^^^
+
+.. function:: boot_time()
+
+  Return the system boot time expressed in seconds since the epoch (seconds
+  since January 1, 1970, at midnight UTC). The return value is based on the
+  system clock, which means it can be affected by changes such as manual
+  adjustments or time synchronization (e.g. NTP).
+
+  .. code-block:: pycon
+
+     >>> import psutil, datetime
+     >>> psutil.boot_time()
+     1389563460.0
+     >>> datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S")
+     '2014-01-12 22:51:00'
+
+.. function:: users()
+
+  Return users currently connected on the system as a list. Each entry
+  includes:
+
+  - :field:`name`: the name of the user.
+  - :field:`terminal`: the tty or pseudo-tty associated with the user, if any,
+    else ``None``.
+  - :field:`host`: the host name associated with the entry, if any (for
+    example, the remote host in an SSH session), else ``None``.
+  - :field:`started`: the creation time as a floating point number expressed in
+    seconds since the epoch.
+  - :field:`pid`: the PID of the login process (like sshd for remote logins,
+    tmux, etc.). On Windows and OpenBSD this is always ``None``.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.users()
+     [suser(name='giampaolo', terminal='pts/2', host='localhost', started=1340737536.0, pid=1352),
+      suser(name='giampaolo', terminal='pts/3', host='localhost', started=1340737792.0, pid=1788)]
+
+  .. note::
+    On UNIX this reads the ``utmp`` database, and returns an empty list if
+    nothing maintains it, e.g. on musl libc (Alpine Linux), which doesn't
+    implement it. ``who`` is empty too in that case.
+
+-------------------------------------------------------------------------------
+
+Processes
+---------
+
+Functions
+^^^^^^^^^
+
+.. function:: pids()
+
+  Return a sorted list of currently running PIDs. To iterate over all processes
+  and avoid race conditions :func:`process_iter` is preferred, see
+  :ref:`perf-process-iter`.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.pids()
+     [1, 2, 3, 5, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19, ..., 32498]
+
+  .. versionchanged:: 5.6.0
+     PIDs are returned in sorted order.
+
+.. function:: process_iter(attrs=None, ad_value=None)
+
+  Return an iterator yielding a :class:`Process` instance for all running
+  processes. This should be preferred over :func:`psutil.pids` to iterate over
+  processes, as retrieving info is safe from race conditions.
+
+  Every :class:`Process` instance is only created once, and then cached for the
+  next time :func:`psutil.process_iter` is called (if PID is still alive).
+  Cache can optionally be cleared via ``process_iter.cache_clear()``.
+
+  *attrs* and *ad_value* have the same meaning as in :meth:`Process.as_dict`.
+
+  If *attrs* is specified, :meth:`Process.as_dict` is called internally, and
+  the results are cached so that subsequent method calls (e.g. ``p.name()``,
+  ``p.status()``) return the cached values instead of issuing new system calls.
+  See :attr:`Process.attrs` for a list of valid *attrs* names.
+
+  If a method raises :exc:`AccessDenied` during pre-fetch, it will return
+  *ad_value* (default ``None``) instead of raising.
+
+  Processes are returned sorted by PID.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> for proc in psutil.process_iter(['pid', 'name', 'username']):
+     ...     print(proc.pid, proc.name(), proc.username())  # return cached values, never raise
+     ...
+     1 systemd root
+     2 kthreadd root
+     3 ksoftirqd/0 root
+     ...
+
+  All process *attrs* except slow ones:
+
+  .. code-block:: pycon
+
+    >>> for p in psutil.process_iter(psutil.Process.attrs - {'memory_footprint', 'memory_maps'}):
+    ...     print(p)
+
+  Clear internal cache:
+
+  .. code-block:: pycon
+
+     >>> psutil.process_iter.cache_clear()
+
+  .. note::
+
+    since :class:`Process` instances are reused across calls, a subsequent
+    :func:`process_iter` call will overwrite or clear any previously
+    pre-fetched values. Do not rely on cached values from a prior iteration.
+
+  .. seealso:: :ref:`perf-process-iter`
+
+  .. versionchanged:: 6.0.0
+
+     - No longer checks whether each yielded process PID has been reused.
+     - Added ``psutil.process_iter.cache_clear()`` API.
+
+  .. versionchanged:: 8.0.0
+
+     - When *attrs* is specified, the pre-fetched values are cached directly on
+       the :class:`Process` instance, so that subsequent method calls (e.g.
+       ``p.name()``, ``p.status()``) return the cached values instead of making
+       new system calls. The :attr:`Process.info` dict is deprecated in favor
+       of this new approach.
+     - Passing an empty list (``attrs=[]``) to mean "all attributes" is
+       deprecated; use :attr:`Process.attrs` instead.
+
+.. function:: pid_exists(pid)
+
+  Check whether the given PID exists in the current process list. This is
+  faster than doing ``pid in psutil.pids()``, and should be preferred.
+
+  .. seealso:: :ref:`faq_pid_exists_vs_isrunning`
+
+.. function:: wait_procs(procs, timeout=None, callback=None)
+
+  Bulk operation that waits for a list of :class:`Process` instances to
+  terminate. Return a ``(gone, alive)`` tuple. The ``gone`` processes will have
+  a new ``returncode`` attribute set by :meth:`Process.wait`.
+
+  *callback* is called with a :class:`Process` instance whenever a process
+  terminates.
+
+  Returns as soon as all processes terminate or *timeout* (seconds) expires.
+  Unlike :meth:`Process.wait`, it does not raise :exc:`TimeoutExpired` on
+  timeout.
+
+  Typical usage:
+
+  - send SIGTERM to a list of processes
+  - wait a short time
+  - send SIGKILL to any still alive
+
+  .. code-block:: python
+
+    import psutil
+
+    def on_terminate(proc):
+        print(f"{proc} terminated with exit code {proc.returncode}")
+
+    procs = psutil.Process().children()
+    for p in procs:
+        p.terminate()
+    gone, alive = psutil.wait_procs(procs, timeout=3, callback=on_terminate)
+    for p in alive:
+        print(f"{p} is still alive, send SIGKILL")
+        p.kill()
+
+Exceptions
+^^^^^^^^^^
+
+.. exception:: Error()
+
+  Base exception class. All other exceptions inherit from this one.
+
+.. exception:: NoSuchProcess(pid, name=None, msg=None)
+
+  Raised by :class:`Process` class or its methods when a process with the given
+  *pid* is not found, no longer exists, or its PID has been reused. *name*
+  attribute is set only if :meth:`Process.name` was called before the process
+  disappeared.
+
+  .. seealso:: :ref:`faq_no_such_process`
+
+.. exception:: ZombieProcess(pid, name=None, ppid=None, msg=None)
+
+  Subclass of :exc:`NoSuchProcess`. Raised by :class:`Process` methods when
+  encountering a :term:`zombie process` on UNIX (Windows does not have
+  zombies). *name* and *ppid* attributes are set if :meth:`Process.name` or
+  :meth:`Process.ppid` were called before the process became a zombie.
+
+  If you do not need to detect zombies, you can ignore this exception and just
+  catch :exc:`NoSuchProcess`.
+
+  .. seealso:: :ref:`faq_zombie_process`
+
+.. exception:: AccessDenied(pid=None, name=None, msg=None)
+
+  Raised by :class:`Process` methods when an action is denied due to
+  insufficient privileges. *name* is set if :meth:`Process.name` was called
+  before the exception was raised.
+
+  .. seealso:: :ref:`faq_access_denied`
+
+.. exception:: TimeoutExpired(seconds, pid=None, name=None, msg=None)
+
+  Raised by :meth:`Process.wait` method if timeout expires and the process is
+  still alive. *name* attribute is set if :meth:`Process.name` was previously
+  called.
+
+Process class
+^^^^^^^^^^^^^
+
+.. class:: Process(pid=None)
+
+  Represents an OS process with the given *pid*. If *pid* is omitted, the
+  current process *pid* (:func:`os.getpid`) is used. Raises
+  :exc:`NoSuchProcess` if *pid* does not exist.
+
+  On Linux, *pid* can also refer to a thread ID (the :field:`id` field returned
+  by :meth:`threads`).
+
+  When calling methods of this class, always be prepared to catch
+  :exc:`NoSuchProcess` and :exc:`AccessDenied` exceptions. Instances can be
+  compared for equality and used in a :class:`set` or as :class:`dict` keys:
+  two instances are equal if they have the same PID and creation time. If the
+  creation time of either instance is unknown (e.g. on :exc:`AccessDenied`, or
+  for zombie processes), identity falls back on the PID alone. The same applies
+  on the platforms where creation time is not part of process identity (see
+  :ref:`faq_pid_reuse`).
+
+  .. note::
+
+    This class is bound to a process via its **PID**. If the process terminates
+    and the OS reuses its PID, you may accidentally interact with another
+    process. To prevent this, use :meth:`is_running` first. Some methods (e.g.,
+    setters and signal-related methods) perform an additional check using PID +
+    creation time, and will raise :exc:`NoSuchProcess` if the PID has been
+    reused. This check is not available on all platforms. See
+    :ref:`faq_pid_reuse` for details.
+
+  .. note::
+
+    To fetch multiple attributes efficiently, use the :meth:`oneshot` context
+    manager or the :meth:`as_dict` utility method.
+
+  .. attribute:: pid
+
+    The process PID as a read-only property.
+
+  .. attribute:: attrs
+
+    A :class:`frozenset` of strings representing the valid attribute names
+    accepted by :meth:`as_dict` and :func:`process_iter`. It defaults to all
+    read-only :class:`Process` method names, minus the utility methods such as
+    :meth:`as_dict`, :meth:`children`, etc.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> psutil.Process.attrs
+       frozenset({'cmdline', 'cpu_num', 'cpu_percent', ...})
+       >>> # all attrs
+       >>> psutil.process_iter(attrs=psutil.Process.attrs)
+       >>> # all attrs except 'net_connections'
+       >>> psutil.process_iter(attrs=psutil.Process.attrs - {"net_connections"})
+
+    .. versionadded:: 8.0.0
+
+  .. attribute:: info
+
+    A dict containing pre-fetched process info, set by :func:`process_iter`
+    when called with ``attrs`` argument. Accessing this attribute is deprecated
+    and raises :exc:`DeprecationWarning`. Use method calls instead (e.g.
+    ``p.name()`` instead of ``p.info['name']``) or :func:`process_iter` +
+    :meth:`Process.as_dict` if you need a dict structure.
+
+    .. seealso:: :ref:`migration guide <migration-8.0>`.
+
+    .. deprecated:: 8.0.0
+
+  .. method:: oneshot()
+
+    Context manager that speeds up retrieval of multiple process attributes.
+    Internally, many attributes (e.g. :meth:`name`, :meth:`ppid`, :meth:`uids`,
+    :meth:`create_time`, ...) share the same underlying system call; within
+    this context, those calls are executed once and results are cached,
+    avoiding redundant syscalls.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> with p.oneshot():
+       ...     p.name()  # actual syscall
+       ...     p.cpu_times()  # from cache
+       ...     p.create_time()  # from cache
+       ...     p.ppid()  # from cache
+       ...     p.status()  # from cache
+       ...
+       >>>
+
+    Which methods share a syscall, and therefore get cached, depends on the
+    platform, so the example above is indicative. See
+    :ref:`perf-oneshot-methods` for the full list.
+
+    .. seealso::
+      - :doc:`performance`
+      - :doc:`/blog/2016/500-is-twice-as-fast`
+
+  .. method:: name()
+
+    The process name. On Windows the return value is cached after first call.
+    Not on POSIX because the process name may change.
+
+    .. seealso:: how to :ref:`find a process by name <recipe_find_process_by_name>`.
+
+  .. method:: exe()
+
+    The process executable as an absolute path. On some systems, if exe cannot
+    be determined for some internal reason (e.g. system process or path no
+    longer exists), this is an empty string. The return value is cached after
+    first call.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> psutil.Process().exe()
+       '/usr/bin/python3'
+
+  .. method:: cmdline()
+
+    The command line used to start this process, as a list of strings. The
+    return value is not cached because the cmdline of a process may change.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> psutil.Process().cmdline()
+       ['python3', 'manage.py', 'runserver']
+
+  .. method:: environ()
+
+    The environment variables of the process as a dict. Note: this might not
+    reflect changes made after the process started.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> psutil.Process().environ()
+       {'LC_NUMERIC': 'it_IT.UTF-8', 'QT_QPA_PLATFORMTHEME': 'appmenu-qt5', 'IM_CONFIG_PHASE': '1', 'XDG_GREETER_DATA_DIR': '/var/lib/lightdm-data/giampaolo', 'XDG_CURRENT_DESKTOP': 'Unity', 'UPSTART_EVENTS': 'started starting', 'GNOME_KEYRING_PID': '', 'XDG_VTNR': '7', 'QT_IM_MODULE': 'ibus', 'LOGNAME': 'giampaolo', 'USER': 'giampaolo', 'PATH': '/home/giampaolo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/home/giampaolo/svn/sysconf/bin', 'LC_PAPER': 'it_IT.UTF-8', 'GNOME_KEYRING_CONTROL': '', 'GTK_IM_MODULE': 'ibus', 'DISPLAY': ':0', 'LANG': 'en_US.UTF-8', 'LESS_TERMCAP_se': '\x1b[0m', 'TERM': 'xterm-256color', 'SHELL': '/bin/bash', 'XDG_SESSION_PATH': '/org/freedesktop/DisplayManager/Session0', 'XAUTHORITY': '/home/giampaolo/.Xauthority', 'LANGUAGE': 'en_US', 'COMPIZ_CONFIG_PROFILE': 'ubuntu', 'LC_MONETARY': 'it_IT.UTF-8', 'QT_LINUX_ACCESSIBILITY_ALWAYS_ON': '1', 'LESS_TERMCAP_me': '\x1b[0m', 'LESS_TERMCAP_md': '\x1b[01;38;5;74m', 'LESS_TERMCAP_mb': '\x1b[01;31m', 'HISTSIZE': '100000', 'UPSTART_INSTANCE': '', 'CLUTTER_IM_MODULE': 'xim', 'WINDOWID': '58786407', 'EDITOR': 'vim', 'SESSIONTYPE': 'gnome-session', 'XMODIFIERS': '@im=ibus', 'GPG_AGENT_INFO': '/home/giampaolo/.gnupg/S.gpg-agent:0:1', 'HOME': '/home/giampaolo', 'HISTFILESIZE': '100000', 'QT4_IM_MODULE': 'xim', 'GTK2_MODULES': 'overlay-scrollbar', 'XDG_SESSION_DESKTOP': 'ubuntu', 'SHLVL': '1', 'XDG_RUNTIME_DIR': '/run/user/1000', 'INSTANCE': 'Unity', 'LC_ADDRESS': 'it_IT.UTF-8', 'SSH_AUTH_SOCK': '/run/user/1000/keyring/ssh', 'VTE_VERSION': '4205', 'GDMSESSION': 'ubuntu', 'MANDATORY_PATH': '/usr/share/gconf/ubuntu.mandatory.path', 'VISUAL': 'vim', 'DESKTOP_SESSION': 'ubuntu', 'QT_ACCESSIBILITY': '1', 'XDG_SEAT_PATH': '/org/freedesktop/DisplayManager/Seat0', 'LESSCLOSE': '/usr/bin/lesspipe %s %s', 'LESSOPEN': '| /usr/bin/lesspipe %s', 'XDG_SESSION_ID': 'c2', 'DBUS_SESSION_BUS_ADDRESS': 'unix:abstract=/tmp/dbus-9GAJpvnt8r', '_': '/usr/bin/python', 'DEFAULTS_PATH': '/usr/share/gconf/ubuntu.default.path', 'LC_IDENTIFICATION': 'it_IT.UTF-8', 'LESS_TERMCAP_ue': '\x1b[0m', 'UPSTART_SESSION': 'unix:abstract=/com/ubuntu/upstart-session/1000/1294', 'XDG_CONFIG_DIRS': '/etc/xdg/xdg-ubuntu:/usr/share/upstart/xdg:/etc/xdg', 'GTK_MODULES': 'gail:atk-bridge:unity-gtk-module', 'XDG_SESSION_TYPE': 'x11', 'PYTHONSTARTUP': '/home/giampaolo/.pythonstart', 'LC_NAME': 'it_IT.UTF-8', 'OLDPWD': '/home/giampaolo/svn/curio_giampaolo/tests', 'GDM_LANG': 'en_US', 'LC_TELEPHONE': 'it_IT.UTF-8', 'HISTCONTROL': 'ignoredups:erasedups', 'LC_MEASUREMENT': 'it_IT.UTF-8', 'PWD': '/home/giampaolo/svn/curio_giampaolo', 'JOB': 'gnome-session', 'LESS_TERMCAP_us': '\x1b[04;38;5;146m', 'UPSTART_JOB': 'unity-settings-daemon', 'LC_TIME': 'it_IT.UTF-8', 'LESS_TERMCAP_so': '\x1b[38;5;246m', 'PAGER': 'less', 'XDG_DATA_DIRS': '/usr/share/ubuntu:/usr/share/gnome:/usr/local/share/:/usr/share/:/var/lib/snapd/desktop', 'XDG_SEAT': 'seat0'}
+
+    .. note::
+      on macOS Big Sur this function returns something meaningful only for the
+      current process or in
+      `other specific circumstances <https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/kern/kern_sysctl.c#L1315-L1321>`_.
+
+    .. versionchanged:: 5.6.3
+       added AIX support.
+
+    .. versionchanged:: 5.7.3
+       added BSD support.
+
+  .. method:: create_time()
+
+    The process creation time as a floating point number expressed in seconds
+    since the epoch (seconds since January 1, 1970, at midnight UTC). The
+    return value, which is cached after first call, is based on the system
+    clock, which means it is affected by changes such as manual adjustments or
+    time synchronization (e.g. NTP).
+
+    .. code-block:: pycon
+
+       >>> import psutil, datetime
+       >>> p = psutil.Process()
+       >>> p.create_time()
+       1307289803.47
+       >>> datetime.datetime.fromtimestamp(p.create_time()).strftime("%Y-%m-%d %H:%M:%S")
+       '2011-03-05 18:03:52'
+
+  .. method:: as_dict(attrs=None, ad_value=None)
+
+    Utility method returning multiple process information as a dictionary.
+
+    If *attrs* is specified, it must be a collection of strings reflecting
+    available :class:`Process` class's attribute names. If not passed all
+    :attr:`Process.attrs` names are assumed.
+
+    *ad_value* is the value which gets assigned to a dict key in case
+    :exc:`AccessDenied` or :exc:`ZombieProcess` exception is raised when
+    retrieving that particular process information (default ``None``).
+
+    The ``'net_connections'`` attribute is retrieved by calling
+    :meth:`Process.net_connections` with ``kind="inet"``.
+
+    Internally, :meth:`as_dict` uses :meth:`oneshot` context manager so there's
+    no need you use it also.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> p.as_dict(attrs=['pid', 'name', 'username'])
+       {'username': 'giampaolo', 'pid': 12366, 'name': 'python'}
+       >>> # all attrs except slow ones
+       >>> p.as_dict(attrs=p.attrs - {'memory_footprint', 'memory_maps'})
+       {'username': 'giampaolo', 'pid': 12366, 'name': 'python', ...}
+       >>>
+
+  .. method:: ppid()
+
+    The process parent PID. On Windows the return value is cached after the
+    first call. On POSIX it is not cached because it may change if the process
+    becomes a :term:`zombie <zombie process>`. See also :meth:`parent` and
+    :meth:`parents` methods.
+
+  .. method:: parent()
+
+    Utility method which returns the parent process as a :class:`Process`
+    object, preemptively checking whether PID has been reused. If no parent PID
+    is known return ``None``. See also :meth:`ppid` and :meth:`parents`
+    methods.
+
+  .. method:: parents()
+
+    Utility method which returns the parents of this process as a list of
+    :class:`Process` instances. If no parents are known return an empty list.
+    See also :meth:`ppid` and :meth:`parent` methods.
+
+  .. method:: status()
+
+    The current process status as a :class:`ProcessStatus` enum member. The
+    returned value is one of the :data:`STATUS_* <psutil.STATUS_RUNNING>`
+    constants. A common use case is detecting
+    :term:`zombie processes <zombie process>`
+    (``p.status() == psutil.STATUS_ZOMBIE``).
+
+    .. versionchanged:: 8.0.0
+       return value is now a :class:`ProcessStatus` enum member instead of a
+       plain ``str``. See :ref:`migration guide <migration-8.0>`.
+
+  .. method:: cwd()
+
+    The process current working directory as an absolute path. If it cannot be
+    determined (e.g. a system process or directory no longer exists) it returns
+    an empty string.
+
+    .. versionchanged:: 5.6.4
+       added support for NetBSD.
+
+  .. method:: username()
+
+    The name of the user that owns the process. On UNIX this is calculated by
+    using the :field:`real` process UID from :meth:`uids`.
+
+  .. method:: uids()
+
+    The :field:`real`, :field:`effective` and :field:`saved` user ID of this
+    process as a named tuple. This is the same as :func:`os.getresuid`, but can
+    be used for any process PID.
+
+    .. availability:: UNIX
+
+  .. method:: gids()
+
+    The :field:`real`, :field:`effective` and :field:`saved` group ID of this
+    process as a named tuple. This is the same as :func:`os.getresgid`, but can
+    be used for any process PID.
+
+    .. availability:: UNIX
+
+  .. method:: terminal()
+
+    The terminal associated with this process, if any, else ``None``. This is
+    similar to ``tty`` command but can be used for any process PID.
+
+    .. availability:: UNIX
+
+  .. method:: nice(value=None)
+
+    Get or set process :term:`niceness <nice>` (priority). On UNIX this is a
+    number which goes from ``-20`` to ``20``. The higher the nice value, the
+    lower the priority of the process.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> p.nice(10)  # set lower priority
+       >>> p.nice()  # get
+       10
+       >>>
+
+    On Windows *value* is one of the :ref:`*_PRIORITY_CLASS <const-proc-prio>`
+    constants:
+
+    .. code-block:: pycon
+
+       >>> p.nice(psutil.HIGH_PRIORITY_CLASS)  # set higher priority
+       >>> p.nice()  # get
+       <ProcessPriority.HIGH_PRIORITY_CLASS: 32768>
+
+    This method was later incorporated in Python 3.3 as :func:`os.getpriority`
+    and :func:`os.setpriority` (see :bpo:`10784`).
+
+    .. versionchanged:: 8.0.0
+       on Windows, the return value is now a :class:`ProcessPriority` enum
+       member. See :ref:`migration guide <migration-8.0>`.
+
+  .. method:: ionice(ioclass=None, value=None)
+
+    Get or set process :term:`I/O niceness <ionice>` (priority). Called with no
+    arguments (get), returns a ``(ioclass, value)`` named tuple on Linux or an
+    *ioclass* integer on Windows. Called with *ioclass* (one of the
+    :ref:`IOPRIO_* <const-proc-ioprio>` constants), sets the I/O priority. On
+    Linux, an additional *value* ranging from ``0`` to ``7`` can be specified
+    to further adjust the priority level specified by *ioclass*.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> if psutil.LINUX:
+       ...     p.ionice(psutil.IOPRIO_CLASS_RT, value=7)  # highest
+       ... else:
+       ...     p.ionice(psutil.IOPRIO_HIGH)
+       ...
+       >>> p.ionice()  # get
+       pionice(ioclass=<ProcessIOPriority.IOPRIO_CLASS_RT: 1>, value=7)
+
+    .. availability:: Linux, Windows
+
+    .. versionchanged:: 5.6.2
+       Windows: accept new :data:`IOPRIO_* <psutil.IOPRIO_VERYLOW>` constants.
+
+    .. versionchanged:: 8.0.0
+       *ioclass* is now a :class:`ProcessIOPriority` enum member. See
+       :ref:`migration guide <migration-8.0>`.
+
+  .. method:: rlimit(resource, limits=None)
+
+    Get or set process :term:`resource limits <resource limit>`. *resource*
+    must be one of the :ref:`RLIMIT_* <const-proc-rlimit>` constants. *limits*
+    is an optional ``(soft, hard)`` tuple. If provided, the method sets the
+    limits; if omitted, it returns the current ``(soft, hard)`` tuple. This is
+    the same as stdlib :func:`resource.getrlimit` and
+    :func:`resource.setrlimit`, but can be used for any process PID.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> p.rlimit(psutil.RLIMIT_NOFILE, (128, 128))   # max 128 file descriptors
+       >>> p.rlimit(psutil.RLIMIT_FSIZE, (1024, 1024))  # max file size 1024 bytes
+       >>> p.rlimit(psutil.RLIMIT_FSIZE)                # get current limits of ...
+       (1024, 1024)
+
+    .. seealso:: :src:`scripts/procinfo.py`.
+
+    .. availability:: Linux, FreeBSD
+
+    .. versionchanged:: 5.7.3
+       added FreeBSD support.
+
+  .. method:: io_counters()
+
+    Return process I/O statistics. All fields are
+    :term:`cumulative counters <cumulative counter>` since process creation.
+
+    - :field:`read_count`: number of read syscalls (e.g., :manpage:`read(2)`,
+      :manpage:`pread(2)`).
+    - :field:`write_count`: number of write syscalls (e.g.,
+      :manpage:`write(2)`, :manpage:`pwrite(2)`).
+    - :field:`read_bytes`: bytes read (``-1`` on BSD).
+    - :field:`write_bytes`: bytes written (``-1`` on BSD).
+
+    Linux specific:
+
+    - :field:`read_chars` *(Linux)*: bytes read via ``read()`` and ``pread()``
+      syscalls. Unlike :field:`read_bytes`, this includes tty I/O and counts
+      bytes regardless of whether actual disk I/O occurred (e.g. reads served
+      from :term:`page cache` are included).
+    - :field:`write_chars` *(Linux)*: bytes written via ``write()`` and
+      ``pwrite()`` syscalls. Same caveats as :field:`read_chars`.
+
+    Windows specific:
+
+    - :field:`other_count` *(Windows)*: the number of I/O operations performed
+      other than read and write operations.
+    - :field:`other_bytes` *(Windows)*: the number of bytes transferred during
+      operations other than read and write operations.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> p.io_counters()
+       pio(read_count=454556, write_count=3456, read_bytes=110592, write_bytes=0, read_chars=769931, write_chars=203)
+
+    .. availability:: Linux, Windows, BSD, AIX
+
+  .. method:: num_ctx_switches()
+
+    The number of :term:`context switches <context switch>` performed by this
+    process as a ``(voluntary, involuntary)`` named tuple
+    (:term:`cumulative counter`).
+
+    .. note::
+      (Windows, macOS) :field:`involuntary` value is always set to 0, while
+      :field:`voluntary` value reflects the total number of context switches
+      (voluntary + involuntary). This is a limitation of the OS.
+
+  .. method:: num_fds()
+
+    The number of :term:`file descriptors <file descriptor>` currently opened
+    by this process (non cumulative).
+
+    .. availability:: UNIX
+
+  .. method:: num_handles()
+
+    The number of :term:`handles <handle>` currently used by this process (non
+    cumulative).
+
+    .. availability:: Windows
+
+  .. method:: num_threads()
+
+    The number of threads currently used by this process (non cumulative).
+
+  .. method:: threads()
+
+    Return a list of threads spawned by this process. On OpenBSD, root
+    privileges are required. Each entry includes:
+
+    - :field:`id`: native thread ID assigned by the kernel. If :attr:`pid`
+      refers to the current process, this matches
+      :attr:`threading.Thread.native_id`, and can be used to reference
+      individual Python threads in your app.
+    - :field:`user_time`: time spent in user mode.
+    - :field:`system_time`: time spent in kernel mode.
+
+  .. method:: cpu_times()
+
+    Return accumulated process CPU times as
+    :term:`cumulative counters <cumulative counter>` expressed in seconds. Same
+    as :func:`os.times`, but works for any process PID.
+
+    - :field:`user`: time spent in user mode.
+    - :field:`system`: time spent in kernel mode.
+    - :field:`children_user`: user time of all child processes (always ``0`` on
+      Windows and macOS).
+    - :field:`children_system`: system time of all child processes (always
+      ``0`` on Windows and macOS).
+    - :field:`iowait`: (Linux) time spent waiting for blocking I/O to complete.
+      (:term:`iowait`). Excluded from :field:`user` and :field:`system` times
+      count (because the CPU is idle).
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> p.cpu_times()
+       pcputimes(user=0.03, system=0.67, children_user=0.0, children_system=0.0, iowait=0.08)
+       >>> sum(p.cpu_times()[:2])  # cumulative, excluding children and iowait
+       0.70
+
+    .. versionchanged:: 5.6.4
+       Linux: added :field:`iowait` field.
+
+  .. method:: cpu_percent(interval=None)
+
+    Return process CPU utilization as a percentage. Values can exceed ``100.0``
+    if the process runs multiple threads on different CPUs.
+
+    If *interval* is > ``0.0``, measures CPU times before and after the
+    interval (blocking). If ``0.0`` or ``None``, returns the utilization since
+    the last call or module import, returning immediately. That means the first
+    time this is called it will return a meaningless ``0.0`` value which you
+    are supposed to ignore. In this case it is recommended for accuracy that
+    this method be called with at least ``0.1`` seconds between calls.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> # blocking
+       >>> p.cpu_percent(interval=1)
+       2.0
+       >>> # non-blocking (percentage since last call)
+       >>> p.cpu_percent(interval=None)
+       2.9
+
+    .. note::
+      the returned value is *not* split evenly between all available CPUs
+      (differently from :func:`psutil.cpu_percent`). To emulate Windows
+      ``taskmgr.exe`` behavior: ``p.cpu_percent() / psutil.cpu_count()``.
+
+    .. seealso::
+      - :ref:`faq_cpu_percent`
+      - :ref:`faq_cpu_percent_gt_100`
+
+  .. method:: cpu_affinity(cpus=None)
+
+    Get or set process :term:`CPU affinity` (the set of CPUs the process is
+    allowed to run on). If no argument is passed, return the current affinity
+    as a list of integers. If passed, *cpus* must be a list of CPU integers. An
+    empty list sets affinity to all eligible CPUs.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> psutil.cpu_count()
+       4
+       >>> p = psutil.Process()
+       >>> # get
+       >>> p.cpu_affinity()
+       [0, 1, 2, 3]
+       >>> # set; from now on, process will run on CPU #0 and #1 only
+       >>> p.cpu_affinity([0, 1])
+       >>> p.cpu_affinity()
+       [0, 1]
+       >>> # reset affinity against all eligible CPUs
+       >>> p.cpu_affinity([])
+
+    .. availability:: Linux, Windows, FreeBSD
+
+  .. method:: cpu_num()
+
+    Return what CPU this process is currently running on. The returned number
+    should be ``<=`` :func:`psutil.cpu_count`. On FreeBSD certain kernel
+    process may return ``-1``. It may be used in conjunction with
+    ``psutil.cpu_percent(percpu=True)`` to observe the system workload
+    distributed across multiple CPUs.
+
+    .. seealso:: :src:`scripts/cpu_distribution.py`.
+
+    .. availability:: Linux, FreeBSD, SunOS
+
+  .. method:: memory_info()
+
+    Return memory information about the process. Fields vary by platform (all
+    values in bytes). The portable fields available on all platforms are
+    :field:`rss` and :field:`vms`.
+
+    +---------+---------+----------+---------+-----+-----------------+
+    | Linux   | macOS   | BSD      | Solaris | AIX | Windows         |
+    +=========+=========+==========+=========+=====+=================+
+    | rss     | rss     | rss      | rss     | rss | rss             |
+    +---------+---------+----------+---------+-----+-----------------+
+    | vms     | vms     | vms      | vms     | vms | vms             |
+    +---------+---------+----------+---------+-----+-----------------+
+    | shared  |         | text     |         |     |                 |
+    +---------+---------+----------+---------+-----+-----------------+
+    | text    |         | data     |         |     |                 |
+    +---------+---------+----------+---------+-----+-----------------+
+    | data    |         | stack    |         |     |                 |
+    +---------+---------+----------+---------+-----+-----------------+
+    |         |         | peak_rss |         |     | peak_rss        |
+    +---------+---------+----------+---------+-----+-----------------+
+    |         |         |          |         |     | peak_vms        |
+    +---------+---------+----------+---------+-----+-----------------+
+
+    - :field:`rss`: aka :term:`RSS`. On UNIX matches the ``top`` RES column. On
+      Windows maps to ``WorkingSetSize``.
+
+    - :field:`vms`: aka :term:`VMS`. On UNIX matches the ``top`` VIRT column.
+      On Windows maps to ``PrivateUsage`` (private committed pages only), which
+      differs from the UNIX definition; use :field:`virtual` from
+      :meth:`memory_extras` for the true virtual address space size.
+
+    - :field:`shared` *(Linux)*: :term:`shared memory` that *could* be shared
+      with other processes (shared libraries,
+      :term:`memory-mapped files <mapped memory>`). Counted even if no other
+      process is currently mapping it. Matches ``top``'s SHR column.
+
+    - :field:`text` *(Linux, BSD)*: aka TRS (Text Resident Set). Resident
+      memory devoted to executable code. This memory is read-only and typically
+      shared across all processes running the same binary. Matches ``top``'s
+      CODE column.
+
+    - :field:`data` *(Linux, BSD)*: aka DRS (Data Resident Set). On Linux this
+      covers the data **and** stack segments combined (from
+      :proc:`/proc/pid/statm`). On BSD it covers the data segment only (see
+      :field:`stack`). Matches ``top``'s DATA column.
+
+    - :field:`stack` *(BSD)*: size of the process stack segment. Reported
+      separately from :field:`data` (unlike Linux where both are combined).
+
+    - :field:`peak_rss` *(BSD, Windows)*: see :term:`peak_rss`. On BSD may be
+      ``0`` for kernel PIDs. On Windows maps to ``PeakWorkingSetSize``.
+
+    - :field:`peak_vms` *(Windows)*: see :term:`peak_vms`. Maps to
+      ``PeakPagefileUsage``.
+
+    For the full definitions of Windows fields see
+    `PROCESS_MEMORY_COUNTERS_EX`_.
+
+    Example on Linux:
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> p.memory_info()
+       pmem(rss=15491072, vms=84025344, shared=5206016, text=2555904, data=9891840)
+
+    .. seealso::
+      - :ref:`faq_memory_rss_vs_vms`
+      - :ref:`faq_memory_footprint`
+
+    .. versionchanged:: 8.0.0 (see :ref:`migration guide <migration-8.0>`)
+
+       - *Linux*: :field:`lib` and :field:`dirty` removed (always 0 since Linux
+         2.6). Deprecated aliases returning 0 and emitting
+         :exc:`DeprecationWarning` are kept.
+       - *macOS*: removed :field:`pfaults` and :field:`pageins` fields with no
+         backward-compatible aliases. Use :meth:`page_faults` instead.
+       - *Windows*: eliminated old aliases: :field:`wset` → :field:`rss`,
+         :field:`peak_wset` → :field:`peak_rss`, :field:`pagefile` and
+         :field:`private` → :field:`vms`, :field:`peak_pagefile` →
+         :field:`peak_vms`, :field:`num_page_faults` → :meth:`page_faults`
+         method. At the same time :field:`paged_pool`, :field:`nonpaged_pool`,
+         :field:`peak_paged_pool`, :field:`peak_nonpaged_pool` were moved to
+         :meth:`memory_extras`. All these old names still work but raise
+         :exc:`DeprecationWarning`.
+       - *BSD*: added :field:`peak_rss` field.
+
+  .. method:: memory_extras()
+
+    Return extra platform-specific memory metrics, complementing
+    :meth:`memory_info` (all values in bytes).
+
+    +-------------+----------------+--------------------+
+    | Linux       | macOS          | Windows            |
+    +=============+================+====================+
+    | peak_rss    | phys_footprint | virtual            |
+    +-------------+----------------+--------------------+
+    | peak_vms    | peak_footprint | peak_virtual       |
+    +-------------+----------------+--------------------+
+    | rss_anon    |                | paged_pool         |
+    +-------------+----------------+--------------------+
+    | rss_file    |                | nonpaged_pool      |
+    +-------------+----------------+--------------------+
+    | rss_shmem   |                | peak_paged_pool    |
+    +-------------+----------------+--------------------+
+    | swap_anon   |                | peak_nonpaged_pool |
+    +-------------+----------------+--------------------+
+    | hugetlb     |                |                    |
+    +-------------+----------------+--------------------+
+
+    Linux:
+
+    - :field:`peak_rss`: see :term:`peak_rss`.
+    - :field:`peak_vms`: see :term:`peak_vms`.
+    - :field:`rss_anon`: resident :term:`anonymous memory` (:term:`heap`,
+      stack, private mappings) not backed by any file. Set to 0 on Linux < 4.5.
+    - :field:`rss_file`: resident file-backed memory mapped from files
+      (:term:`shared libraries <shared memory>`,
+      :term:`memory-mapped files <mapped memory>`). Set to 0 on Linux < 4.5.
+    - :field:`rss_shmem`: resident :term:`shared memory` (``tmpfs``,
+      ``shm_open``). ``rss_anon + rss_file + rss_shmem`` equals :field:`rss`.
+      Set to 0 on Linux < 4.5.
+    - :field:`swap_anon`: :term:`anonymous memory` currently in
+      :term:`swap <swap memory>`. Cheaper than :meth:`memory_footprint`'s
+      :field:`swap` (it reads :proc:`/proc/pid/status` instead of smaps) but
+      does not count shmem swap. Set to 0 on Linux < 2.6.34.
+    - :field:`hugetlb`: resident memory backed by huge pages. Set to 0 on Linux
+      < 4.4.
+
+    macOS:
+
+    - :field:`phys_footprint`: memory footprint attributed to the process,
+      including compressed memory. This corresponds to the main memory usage
+      reported by macOS Activity Monitor. Prefer it over :field:`rss`.
+    - :field:`peak_footprint`: the highest :field:`phys_footprint` reached over
+      the process lifetime. Set to 0 on macOS < 10.13.
+
+    Windows (see `PROCESS_MEMORY_COUNTERS_EX`_):
+
+    - :field:`virtual`: true virtual address space size, including
+      reserved-but-uncommitted regions (unlike :field:`vms` in
+      :meth:`memory_info`).
+    - :field:`peak_virtual`: peak virtual address space size.
+    - :field:`paged_pool`: kernel memory used for objects created by this
+      process (open file handles, registry keys, etc.) that the OS may swap to
+      disk under memory pressure.
+    - :field:`nonpaged_pool`: kernel memory used for objects that must stay in
+      RAM at all times (I/O request packets, device driver buffers, etc.). A
+      large or growing value may indicate a driver memory leak.
+    - :field:`peak_paged_pool`: peak paged-pool usage.
+    - :field:`peak_nonpaged_pool`: peak non-paged-pool usage.
+
+    .. availability:: Linux, macOS, Windows
+
+    .. versionadded:: 8.0.0
+
+  .. method:: memory_footprint()
+
+    Return :field:`uss`, :field:`pss` and :field:`swap` memory metrics. These
+    give a more accurate picture of actual memory consumption than
+    :meth:`memory_info`. It walks the full process address space, so it is
+    slower than :meth:`memory_info` and may require elevated privileges.
+
+    - :field:`uss` *(Linux, macOS, Windows)*: aka :term:`USS`; the
+      :term:`private memory` of the process, which would be freed if the
+      process were terminated right now.
+
+    - :field:`pss` *(Linux)*: aka :term:`PSS`; shared memory divided evenly
+      among the processes sharing it. I.e. if a process has 10 MBs all to
+      itself, and 10 MBs shared with another process, its PSS will be 15 MBs.
+
+    - :field:`swap` *(Linux)*: process memory currently in
+      :term:`swap <swap memory>`, counted per-mapping.
+
+    Example on Linux:
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> p.memory_footprint()
+       pfootprint(uss=6545408, pss=6872064, swap=0)
+
+    .. seealso::
+      - :src:`scripts/procsmem.py`.
+      - :ref:`faq_memory_footprint`
+      - :doc:`/blog/2016/real-process-memory-in-python`
+
+    .. availability:: Linux, macOS, Windows
+
+    .. versionadded:: 8.0.0
+
+  .. method:: memory_full_info()
+
+    This deprecated method returns the same information as :meth:`memory_info`
+    plus :meth:`memory_footprint` in a single named tuple.
+
+    .. deprecated:: 8.0.0
+       use :meth:`memory_footprint` instead. See
+       :ref:`migration guide <migration-8.0>`.
+
+  .. method:: memory_percent(memtype="rss")
+
+    Return process memory usage as a percentage of total physical memory. Same
+    as:
+
+    .. code-block:: python
+
+       Process().memory_info().rss / virtual_memory().total * 100
+
+    *memtype* selects which memory field to use and can be any attribute from
+    :meth:`memory_info`, :meth:`memory_extras`, or :meth:`memory_footprint`
+    (default is ``"rss"``). The divisor is always total physical memory,
+    regardless of *memtype*.
+
+  .. method:: memory_maps(grouped=True)
+
+    Return the process's :term:`memory-mapped <mapped memory>` file regions as
+    a list. Fields vary by platform (all values in bytes).
+
+    If *grouped* is ``True``, regions with the same *path* are merged and their
+    numeric fields summed. If *grouped* is ``False``, each region is listed
+    individually; the tuple also includes *addr* (address range) and *perms*
+    (permission string, e.g., ``"r-xp"``).
+
+    +---------------+---------+--------------+-----------+
+    | Linux         | Windows | FreeBSD      | Solaris   |
+    +===============+=========+==============+===========+
+    | rss           | rss     | rss          | rss       |
+    +---------------+---------+--------------+-----------+
+    | size          |         | private      | anonymous |
+    +---------------+---------+--------------+-----------+
+    | pss           |         | ref_count    | locked    |
+    +---------------+---------+--------------+-----------+
+    | shared_clean  |         | shadow_count |           |
+    +---------------+---------+--------------+-----------+
+    | shared_dirty  |         |              |           |
+    +---------------+---------+--------------+-----------+
+    | private_clean |         |              |           |
+    +---------------+---------+--------------+-----------+
+    | private_dirty |         |              |           |
+    +---------------+---------+--------------+-----------+
+    | referenced    |         |              |           |
+    +---------------+---------+--------------+-----------+
+    | anonymous     |         |              |           |
+    +---------------+---------+--------------+-----------+
+    | swap          |         |              |           |
+    +---------------+---------+--------------+-----------+
+
+    Linux fields (from :proc:`/proc/pid/smaps`):
+
+    - :field:`rss`: :term:`RSS` for this mapping.
+    - :field:`size`: total virtual size; may far exceed :field:`rss` if parts
+      have never been accessed.
+    - :field:`pss`: :term:`PSS` for this mapping, that is :field:`rss` split
+      proportionally among all processes sharing it.
+    - :field:`shared_clean`: :term:`shared memory` not written to since loaded
+      (clean); can be discarded and reloaded from disk for free.
+    - :field:`shared_dirty`: :term:`shared memory` that has been written to
+      (dirty).
+    - :field:`private_clean`: :term:`private memory` not written to (clean).
+    - :field:`private_dirty`: :term:`private memory` that has been written to
+      (dirty); must be saved to swap before it can be freed. The key indicator
+      of real memory cost.
+    - :field:`referenced`: bytes recently accessed.
+    - :field:`anonymous`: :term:`anonymous memory` in this mapping
+      (:term:`heap`, stack).
+    - :field:`swap`: bytes from this mapping currently in
+      :term:`swap <swap memory>`.
+
+    FreeBSD fields:
+
+    - :field:`private`: :term:`private memory` in this mapping.
+    - :field:`ref_count`: reference count on the underlying memory object.
+    - :field:`shadow_count`: depth of the copy-on-write chain.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> p.memory_maps()
+       [pmmap_grouped(path='/lib/x8664-linux-gnu/libutil-2.15.so', rss=32768, size=2125824, pss=32768, shared_clean=0, shared_dirty=0, private_clean=20480, private_dirty=12288, referenced=32768, anonymous=12288, swap=0),
+        pmmap_grouped(path='/lib/x8664-linux-gnu/libc-2.15.so', rss=3821568, size=3842048, pss=3821568, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=3821568, referenced=3575808, anonymous=3821568, swap=0),
+        ...]
+
+    .. seealso:: :src:`scripts/pmap.py`.
+
+    .. availability:: Linux, Windows, FreeBSD, SunOS
+
+    .. versionchanged:: 5.6.0
+       removed macOS support because inherently broken (see issue :gh:`1291`)
+
+  .. method:: children(recursive=False)
+
+    Return the children of this process as a list of :class:`Process`
+    instances. If *recursive* is ``True``, return all descendants. Pseudo-code
+    example (assuming A is this process):
+
+    .. code-block:: none
+
+      A ─�
+         │
+         ├─ B (child) ─�
+         │             └─ X (grandchild) ─�
+         │                                └─ Y (great-grandchild)
+         ├─ C (child)
+         └─ D (child)
+
+    .. code-block:: pycon
+
+       >>> p.children()
+       B, C, D
+       >>> p.children(recursive=True)
+       B, X, Y, C, D
+
+    Note: if a process in the tree disappears (e.g., X), its descendants (Y)
+    won’t be returned since the reference to the parent is lost. This concept
+    is well illustrated by this
+    `unit test <https://github.com/giampaolo/psutil/blob/65a52341b55faaab41f68ebc4ed31f18f0929754/psutil/tests/test_process.py#L1064-L1075>`_.
+
+    .. seealso:: how to :ref:`kill a process tree <recipe_kill_proc_tree>`.
+
+  .. method:: page_faults()
+
+    Return the number of :term:`page faults <page fault>` for this process as a
+    ``(minor, major)`` named tuple. Both are
+    :term:`cumulative counters <cumulative counter>` since process creation.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process()
+       >>> p.page_faults()
+       ppagefaults(minor=5905, major=3)
+
+    .. versionadded:: 8.0.0
+
+  .. method:: open_files()
+
+    Return regular files opened by process as a list. Each entry includes:
+
+    - :field:`path`: the absolute file name.
+    - :field:`fd`: the :term:`file descriptor` number; on Windows this is
+      always ``-1``.
+
+    Linux only:
+
+    - :field:`position` (*Linux*): the file position (offset).
+    - :field:`mode` (*Linux*): a string indicating how the file was opened,
+      similarly to :func:`open` builtin *mode* argument. Possible values are
+      ``'r'``, ``'w'``, ``'a'``, ``'r+'`` and ``'a+'``. There's no distinction
+      between files opened in binary or text mode (``"b"`` or ``"t"``).
+    - :field:`flags` (*Linux*): the flags which were passed to the underlying
+      :func:`os.open` C call when the file was opened (e.g.
+      :data:`os.O_RDONLY`, :data:`os.O_TRUNC`, etc).
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> f = open('file.ext', 'w')
+       >>> p = psutil.Process()
+       >>> p.open_files()
+       [popenfile(path='/home/giampaolo/svn/psutil/file.ext', fd=3, position=0, mode='w', flags=32769)]
+
+    .. warning::
+      - Windows: this is not guaranteed to enumerate all file handles (see
+        :ref:`faq_open_files_windows`)
+      - NetBSD, OpenBSD: :field:`path` is always an empty string. The kernel
+        doesn't expose it (there's no path field in ``struct kinfo_file``).
+      - FreeBSD: :field:`path` can be an empty string (:gh:`595`).
+
+  .. method:: net_connections(kind="inet")
+
+    Same as :func:`psutil.net_connections` but for this process only (the
+    returned named tuples have no :field:`pid` field). The *kind* parameter and
+    the same limitations apply (root may be needed on some platforms).
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process(1694)
+       >>> p.name()
+       'firefox'
+       >>> p.net_connections()
+       [pconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status=<ConnectionStatus.CONN_ESTABLISHED: 'ESTABLISHED'>),
+        pconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status=<ConnectionStatus.CONN_CLOSING: 'CLOSING'>),
+        pconn(fd=119, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=60759), raddr=addr(ip='72.14.234.104', port=80), status=<ConnectionStatus.CONN_ESTABLISHED: 'ESTABLISHED'>),
+        pconn(fd=123, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=addr(ip='10.0.0.1', port=51314), raddr=addr(ip='72.14.234.83', port=443), status=<ConnectionStatus.CONN_SYN_SENT: 'SYN_SENT'>)]
+
+  .. method:: connections()
+
+    Same as :meth:`net_connections` (deprecated).
+
+    .. deprecated:: 6.0.0
+       use :meth:`net_connections` instead.
+
+  .. method:: is_running()
+
+    Return whether the current process is running. Differently from
+    ``psutil.pid_exists(p.pid)``, this is reliable also in case the process is
+    gone and its PID reused by another process.
+
+    If PID has been reused, this method will also remove the process from
+    :func:`process_iter` internal cache.
+
+    This will return ``True`` also if the process is a :term:`zombie process`
+    (``p.status() == psutil.STATUS_ZOMBIE``).
+
+    .. seealso::
+      - :ref:`faq_pid_reuse`
+      - :ref:`faq_pid_exists_vs_isrunning`
+
+    .. versionchanged:: 6.0.0
+       automatically remove process from :func:`process_iter` internal cache if
+       PID has been reused by another process.
+
+  .. method:: send_signal(sig)
+
+    Send signal *sig* to process (see :mod:`signal` module constants),
+    preemptively checking whether PID has been reused. On UNIX this is the same
+    as ``os.kill(pid, sig)``. On Windows only ``SIGTERM``, ``CTRL_C_EVENT`` and
+    ``CTRL_BREAK_EVENT`` signals are supported, and ``SIGTERM`` is treated as
+    an alias for :meth:`kill`.
+
+    .. seealso:: how to :ref:`kill a process tree <recipe_kill_proc_tree>`
+
+  .. method:: suspend()
+
+    Suspend process execution with ``SIGSTOP`` signal, preemptively checking
+    whether PID has been reused. On UNIX this is the same as
+    ``os.kill(pid, signal.SIGSTOP)``. On Windows this is done by suspending all
+    process threads.
+
+  .. method:: resume()
+
+    Resume process execution with ``SIGCONT`` signal, preemptively checking
+    whether PID has been reused. On UNIX this is the same as
+    ``os.kill(pid, signal.SIGCONT)``. On Windows this is done by resuming all
+    process threads.
+
+  .. method:: terminate()
+
+    Terminate the process with ``SIGTERM`` signal, preemptively checking
+    whether PID has been reused. On UNIX this is the same as
+    ``os.kill(pid, signal.SIGTERM)``. On Windows this is an alias for
+    :meth:`kill`.
+
+    .. seealso:: how to :ref:`kill a process tree <recipe_kill_proc_tree>`.
+
+  .. method:: kill()
+
+    Kill the current process by using ``SIGKILL`` signal, preemptively checking
+    whether PID has been reused. On UNIX this is the same as
+    ``os.kill(pid, signal.SIGKILL)``. On Windows this is done by using
+    `TerminateProcess`_.
+
+    .. seealso:: how to :ref:`kill a process tree <recipe_kill_proc_tree>`.
+
+  .. method:: wait(timeout=None)
+
+    Wait for a process PID to terminate. The details about the return value
+    differ on UNIX and Windows.
+
+    *On UNIX*: if the process terminated normally, the return value is an
+    integer >= 0 indicating the exit code. If the process was terminated by a
+    signal, returns the negated value of the signal which caused the
+    termination (e.g. ``-SIGTERM``). If PID is not a child of :func:`os.getpid`
+    (current process), it just waits until the process disappears and return
+    ``None``. If PID does not exist return ``None`` immediately.
+
+    *On Windows*: always return the exit code via `GetExitCodeProcess`_.
+
+    *timeout* is expressed in seconds. If specified, and the process is still
+    alive, raise :exc:`TimeoutExpired`. ``timeout=0`` can be used in
+    non-blocking apps: it will either return immediately or raise
+    :exc:`TimeoutExpired`.
+
+    The return value is cached. To wait for multiple processes use
+    :func:`psutil.wait_procs`.
+
+    .. code-block:: pycon
+
+       >>> import psutil
+       >>> p = psutil.Process(9891)
+       >>> p.terminate()
+       >>> p.wait()
+       <NegSignal.SIGTERM: -15>
+
+    .. seealso:: :doc:`/blog/2026/event-driven-process-waiting`
+
+    .. note::
+
+      when *timeout* is not ``None`` and the platform supports it, an efficient
+      event-driven mechanism is used to wait for process termination:
+
+      - Linux >= 5.3 with Python >= 3.9 uses :func:`os.pidfd_open` +
+        :func:`select.poll`
+      - macOS and other BSD variants use :func:`select.kqueue` +
+        ``KQ_FILTER_PROC`` + ``KQ_NOTE_EXIT``
+      - Windows uses `WaitForSingleObject`_
+
+      If none of these mechanisms are available, the function falls back to a
+      busy loop (non-blocking call and short sleeps).
+
+      Functionality also ported to the :mod:`subprocess` module in Python 3.15,
+      see :cpy-pr:`144047`.
+
+    .. versionchanged:: 5.7.2
+       if *timeout* is not ``None``, use efficient event-driven implementation
+       on Linux >= 5.3 and macOS / BSD.
+
+    .. versionchanged:: 5.7.1
+       return value is cached (instead of returning ``None``).
+
+    .. versionchanged:: 5.7.1
+       POSIX: if the signal is negative, return it as a human readable
+       :mod:`enum`.
+
+    .. versionchanged:: 7.2.2
+       on Linux >= 5.3 + Python >= 3.9 and macOS/BSD, use :func:`os.pidfd_open`
+       and :func:`select.kqueue` respectively, instead of less efficient
+       busy-loop polling.
+
+-------------------------------------------------------------------------------
+
+Popen class
+^^^^^^^^^^^
+
+.. class:: Popen(*args, **kwargs)
+
+  Same as :class:`subprocess.Popen`, but in addition it provides all
+  :class:`psutil.Process` methods in a single class. For the following methods,
+  which are common to both classes, psutil implementation takes precedence:
+  :meth:`send_signal() <psutil.Process.send_signal()>`,
+  :meth:`terminate() <psutil.Process.terminate()>`,
+  :meth:`kill() <psutil.Process.kill()>`. This is done to avoid killing another
+  process if its PID has been reused, fixing :bpo:`6973`.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> from subprocess import PIPE
+     >>>
+     >>> p = psutil.Popen(["/usr/bin/python3", "-c", "print('hello')"], stdout=PIPE)
+     >>> p.name()
+     'python3'
+     >>> p.username()
+     'giampaolo'
+     >>> p.communicate()
+     ('hello\n', None)
+     >>> p.wait(timeout=2)
+     0
+     >>>
+
+-------------------------------------------------------------------------------
+
+C heap introspection
+--------------------
+
+The following functions provide direct access to the platform's native
+:term:`heap` allocator (such as glibc's ``malloc`` on Linux or ``jemalloc`` on
+BSD). They are low-level interfaces intended for detecting memory leaks in C
+extensions, which are usually not revealed via standard :term:`RSS` /
+:term:`VMS` metrics. These functions do not reflect Python object memory; they
+operate solely on allocations made in C via :manpage:`malloc(3)`,
+:manpage:`free(3)`, and related calls.
+
+The general idea behind these functions is straightforward: capture the state
+of the :term:`heap` before and after repeatedly invoking a function implemented
+in a C extension, and compare the results. If ``heap_used`` or ``mmap_used``
+grows steadily across iterations, the C code is likely retaining memory it
+should be releasing. This provides an allocator-level way to spot native leaks
+that Python's memory tracking misses.
+
+.. seealso::
+
+  :doc:`/blog/2025/heap-introspection-apis`
+
+.. tip::
+
+  Check out `psleak`_ project to see a practical example of how these APIs can
+  be used to detect memory leaks in C extensions.
+
+.. function:: heap_info()
+
+  Return low-level heap statistics from the system's C allocator. On Linux,
+  this exposes ``uordblks`` and ``hblkhd`` fields from glibc
+  :manpage:`mallinfo2(3)`.
+
+  - ``heap_used``: total number of bytes currently allocated via ``malloc()``
+    (small allocations).
+  - ``mmap_used``: total number of bytes currently allocated via
+    :manpage:`mmap(2)` or via large ``malloc()`` allocations. Always set to 0
+    on macOS.
+  - ``heap_count``: (Windows only) number of private heaps created via
+    ``HeapCreate()``.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.heap_info()
+     pheap(heap_used=5177792, mmap_used=819200)
+
+  These fields reflect how unreleased C allocations affect the heap:
+
+  +---------------+------------------------------------------------------------------------------------+-----------------+
+  | Platform      | Allocation type                                                                    | Affected field  |
+  +===============+====================================================================================+=================+
+  | UNIX / glibc  | small ``malloc()`` ≤128KB without ``free()``                                       | ``heap_used``   |
+  +---------------+------------------------------------------------------------------------------------+-----------------+
+  | UNIX / glibc  | large ``malloc()`` >128KB without ``free()`` , or ``mmap()`` without ``munmap()``  | ``mmap_used``   |
+  +---------------+------------------------------------------------------------------------------------+-----------------+
+  | Windows       | ``HeapAlloc()`` without ``HeapFree()``                                             | ``heap_used``   |
+  +---------------+------------------------------------------------------------------------------------+-----------------+
+  | Windows       | ``VirtualAlloc()`` without ``VirtualFree()``                                       | ``mmap_used``   |
+  +---------------+------------------------------------------------------------------------------------+-----------------+
+  | Windows       | ``HeapCreate()`` without ``HeapDestroy()``                                         | ``heap_count``  |
+  +---------------+------------------------------------------------------------------------------------+-----------------+
+
+  .. availability:: Linux with glibc, Windows, macOS, FreeBSD, NetBSD
+
+  .. versionadded:: 7.2.0
+
+.. function:: heap_trim()
+
+  Request that the underlying allocator free any unused memory it's holding in
+  the :term:`heap` (typically small ``malloc()`` allocations).
+
+  In practice, modern allocators rarely comply, so this is not a
+  general-purpose memory-reduction tool and won't meaningfully shrink
+  :term:`RSS` in real programs. Its primary value is in
+  **leak detection tools**.
+
+  Calling ``heap_trim()`` before taking measurements helps reduce allocator
+  noise, giving you a cleaner baseline so that changes in ``heap_used`` come
+  from the code you're testing, not from internal allocator caching or
+  fragmentation. Its effectiveness depends on allocator behavior and
+  fragmentation patterns.
+
+  .. availability:: Linux with glibc, Windows, macOS, FreeBSD, NetBSD
+
+  .. versionadded:: 7.2.0
+
+-------------------------------------------------------------------------------
+
+Windows services
+----------------
+
+.. function:: win_service_iter()
+
+  Return an iterator yielding :class:`WindowsService` instances for all
+  installed Windows services.
+
+  .. availability:: Windows
+
+.. function:: win_service_get(name)
+
+  Get a Windows service by name, returning a :class:`WindowsService` instance.
+  Raise :exc:`NoSuchProcess` if no service with such name exists.
+
+  .. availability:: Windows
+
+.. class:: WindowsService
+
+  Represents a Windows service with the given *name*. This class is returned by
+  :func:`win_service_iter` and :func:`win_service_get` functions, and it's not
+  supposed to be instantiated directly.
+
+  .. method:: name()
+
+    The service name. This string is how a service is referenced, and can be
+    passed to :func:`win_service_get` to get a new :class:`WindowsService`
+    instance.
+
+  .. method:: display_name()
+
+    The service display name. The value is cached when this class is
+    instantiated.
+
+  .. method:: binpath()
+
+    The fully qualified path to the service binary/exe file as a string,
+    including command line arguments.
+
+  .. method:: username()
+
+    The name of the user that owns this service.
+
+  .. method:: start_type()
+
+    A string which can either be either ``'automatic'``, ``'manual'`` or
+    ``'disabled'``.
+
+  .. method:: pid()
+
+    The process PID, if any, else ``None``. This can be passed to
+    :class:`Process` class to control the service's process.
+
+  .. method:: status()
+
+    Service status as a string, which can be either ``'running'``,
+    ``'paused'``, ``'start_pending'``, ``'pause_pending'``,
+    ``'continue_pending'``, ``'stop_pending'`` or ``'stopped'``.
+
+  .. method:: description()
+
+    Service long description.
+
+  .. method:: as_dict()
+
+    Utility method retrieving all the information above as a dictionary.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> list(psutil.win_service_iter())
+     [<WindowsService(name='AeLookupSvc', display_name='Application Experience') at 38850096>,
+      <WindowsService(name='ALG', display_name='Application Layer Gateway Service') at 38850128>,
+      <WindowsService(name='APNMCP', display_name='Ask Update Service') at 38850160>,
+      <WindowsService(name='AppIDSvc', display_name='Application Identity') at 38850192>,
+      ...]
+     >>> s = psutil.win_service_get('alg')
+     >>> s.as_dict()
+     {'binpath': 'C:\\Windows\\System32\\alg.exe',
+      'description': 'Provides support for 3rd party protocol plug-ins for Internet Connection Sharing',
+      'display_name': 'Application Layer Gateway Service',
+      'name': 'alg',
+      'pid': None,
+      'start_type': 'manual',
+      'status': 'stopped',
+      'username': 'NT AUTHORITY\\LocalService'}
+
+  .. availability:: Windows
+
+-------------------------------------------------------------------------------
+
+Constants
+---------
+
+The following enum classes group related constants, and are useful for type
+annotations and introspection. The individual constants (e.g.
+:data:`STATUS_RUNNING`) are also accessible directly from the psutil namespace
+as aliases for the enum members, and should be preferred over accessing them
+via the enum class (e.g. prefer ``psutil.STATUS_RUNNING`` over
+``psutil.ProcessStatus.STATUS_RUNNING``).
+
+.. class:: ProcessStatus
+
+  :class:`enum.StrEnum` collection of :data:`STATUS_* <psutil.STATUS_RUNNING>`
+  constants. Returned by :meth:`Process.status`.
+
+  .. versionadded:: 8.0.0
+
+.. class:: ProcessPriority
+
+  :class:`enum.IntEnum` collection of
+  :data:`*_PRIORITY_CLASS <psutil.ABOVE_NORMAL_PRIORITY_CLASS>` constants for
+  :meth:`Process.nice` on Windows.
+
+  .. availability:: Windows
+
+  .. versionadded:: 8.0.0
+
+.. class:: ProcessIOPriority
+
+  :class:`enum.IntEnum` collection of I/O priority constants for
+  :meth:`Process.ionice`.
+
+  :data:`IOPRIO_CLASS_* <psutil.IOPRIO_CLASS_NONE>` on Linux,
+  :data:`IOPRIO_* <psutil.IOPRIO_VERYLOW>` on Windows.
+
+  .. availability:: Linux, Windows
+
+  .. versionadded:: 8.0.0
+
+.. class:: ProcessRlimit
+
+  :class:`enum.IntEnum` collection of :data:`RLIMIT_* <psutil.RLIMIT_NOFILE>`
+  constants for :meth:`Process.rlimit`.
+
+  .. availability:: Linux, FreeBSD
+
+  .. versionadded:: 8.0.0
+
+.. class:: ConnectionStatus
+
+  :class:`enum.StrEnum` collection of :data:`CONN_* <psutil.CONN_ESTABLISHED>`
+  constants. Returned in the :field:`status` field of
+  :func:`psutil.net_connections` and :meth:`Process.net_connections`.
+
+  .. versionadded:: 8.0.0
+
+.. class:: NicDuplex
+
+  :class:`enum.IntEnum` collection of
+  :data:`NIC_DUPLEX_* <psutil.NIC_DUPLEX_FULL>` constants. Returned in the
+  *duplex* field of :func:`psutil.net_if_stats`.
+
+.. class:: BatteryTime
+
+  :class:`enum.IntEnum` collection of
+  :data:`POWER_TIME_* <psutil.POWER_TIME_UNKNOWN>` constants. May appear in the
+  *secsleft* field of :func:`psutil.sensors_battery`.
+
+.. _const-oses:
+
+Operating system constants
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``bool`` constants which define what platform you're on. ``True`` if on the
+platform, ``False`` otherwise.
+
+.. data:: POSIX
+.. data:: LINUX
+.. data:: WINDOWS
+.. data:: MACOS
+.. data:: FREEBSD
+.. data:: NETBSD
+.. data:: OPENBSD
+.. data:: BSD
+.. data:: SUNOS
+.. data:: AIX
+.. data:: OSX
+
+  Alias for :data:`MACOS`.
+
+  .. deprecated:: 5.4.7
+     use :data:`MACOS` instead.
+
+.. _const-pstatus:
+
+Process status constants
+^^^^^^^^^^^^^^^^^^^^^^^^
+
+Represent the current status of a process. Returned by :meth:`Process.status`.
+
+.. versionchanged:: 8.0.0
+   constants are now :class:`ProcessStatus` enum members (were plain strings).
+   See :ref:`migration guide <migration-8.0>`.
+
+.. data:: STATUS_RUNNING
+
+   The process is running or ready to run (e.g. ``while True: pass``).
+
+.. data:: STATUS_SLEEPING
+
+   The process is dormant (e.g. during ``time.sleep()``) but can be woken up,
+   e.g. via a signal.
+
+.. data:: STATUS_DISK_SLEEP
+
+   The process is waiting for disk I/O to complete. The kernel usually ignores
+   signals in this state to prevent data corruption. E.g. ``os.read(fd, 1024)``
+   on a slow / blocked device can produce this state.
+
+.. data:: STATUS_STOPPED
+
+   The process is stopped (e.g., by ``SIGSTOP`` or ``SIGTSTP``, which is sent
+   on Ctrl+Z) and will not run until resumed (e.g., via ``SIGCONT``).
+
+.. data:: STATUS_TRACING_STOP
+
+   The process is temporarily halted because it is being inspected by a
+   debugger (e.g. via ``strace -p <pid>``).
+
+.. data:: STATUS_ZOMBIE
+
+   The process has finished execution and released its resources, but it
+   remains in the process table until the parent reaps it via ``wait()``. See
+   also :ref:`faq_zombie_process`.
+
+.. data:: STATUS_DEAD
+
+   The process is about to disappear (final state before it is gone).
+
+.. data:: STATUS_WAKE_KILL
+
+   (Linux only) A variant of :data:`STATUS_DISK_SLEEP` where the process can be
+   awakened by ``SIGKILL``. Used for tasks which might otherwise remain blocked
+   indefinitely, e.g. unresponsive network filesystems such as NFS, as in
+   ``open("/mnt/nfs_hung/file").read()``.
+
+.. data:: STATUS_WAKING
+
+   (Linux only) A transient state right before the process becomes runnable
+   (:data:`STATUS_RUNNING`).
+
+.. data:: STATUS_PARKED
+
+   (Linux only) A dormant state for kernel threads tied to a specific CPU.
+   These threads are "parked" when a CPU core is taken offline and will remain
+   inactive until the core is re-enabled.
+
+.. data:: STATUS_IDLE
+
+   (Linux, macOS, FreeBSD) A sleep for kernel threads waiting for work.
+
+.. data:: STATUS_LOCKED
+
+   (FreeBSD only) The process is blocked specifically waiting for a
+   kernel-level synchronization primitive (e.g. a mutex).
+
+.. data:: STATUS_WAITING
+
+   (FreeBSD only) The process is waiting in a kernel sleep queue for a specific
+   system event to occur.
+
+.. data:: STATUS_SUSPENDED
+
+   (NetBSD only) The process has been explicitly paused, similar to the stopped
+   state but managed by the NetBSD scheduler.
+
+.. _const-proc-prio:
+
+Process priority constants
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Represent the priority of a process on Windows (see `SetPriorityClass`_ doc).
+They can be used in conjunction with :meth:`Process.nice` to get or set process
+priority.
+
+.. availability:: Windows
+
+.. versionchanged:: 8.0.0
+   constants are now :class:`ProcessPriority` enum members (were plain
+   integers). See :ref:`migration guide <migration-8.0>`.
+
+.. _const-prio:
+
+.. data:: REALTIME_PRIORITY_CLASS
+.. data:: HIGH_PRIORITY_CLASS
+.. data:: ABOVE_NORMAL_PRIORITY_CLASS
+.. data:: NORMAL_PRIORITY_CLASS
+.. data:: IDLE_PRIORITY_CLASS
+.. data:: BELOW_NORMAL_PRIORITY_CLASS
+
+-------------------------------------------------------------------------------
+
+.. _const-proc-ioprio:
+
+Process I/O priority constants
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Represent the I/O priority class of a process (Linux and Windows only). They
+can be used in conjunction with :meth:`Process.ionice` (*ioclass* argument).
+
+- Linux (see :manpage:`ioprio_get(2)`):
+
+  .. data:: IOPRIO_CLASS_RT
+
+     Highest priority.
+
+  .. data:: IOPRIO_CLASS_BE
+
+     Normal priority.
+
+  .. data:: IOPRIO_CLASS_IDLE
+
+     Lowest priority.
+
+  .. data:: IOPRIO_CLASS_NONE
+
+     No priority set (default; treated as :data:`IOPRIO_CLASS_BE`).
+
+- Windows:
+
+  .. data:: IOPRIO_VERYLOW
+  .. data:: IOPRIO_LOW
+  .. data:: IOPRIO_NORMAL
+  .. data:: IOPRIO_HIGH
+
+.. versionchanged:: 8.0.0
+   constants are now :class:`ProcessIOPriority` enum members. See
+   :ref:`migration guide <migration-8.0>`.
+
+.. _const-proc-rlimit:
+
+Process resource constants
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Constants for getting or setting process resource limits, to be used in in
+conjunction with :meth:`Process.rlimit`. The meaning of each constant is
+explained in :func:`resource.getrlimit` documentation.
+
+.. availability:: Linux, FreeBSD
+
+.. versionchanged:: 8.0.0
+   these constants are now :class:`ProcessRlimit` enum members (were plain
+   integers). See :ref:`migration guide <migration-8.0>`.
+
+- Linux / FreeBSD:
+
+  .. data:: RLIM_INFINITY
+  .. data:: RLIMIT_AS
+  .. data:: RLIMIT_CORE
+  .. data:: RLIMIT_CPU
+  .. data:: RLIMIT_DATA
+  .. data:: RLIMIT_FSIZE
+  .. data:: RLIMIT_MEMLOCK
+  .. data:: RLIMIT_NOFILE
+  .. data:: RLIMIT_NPROC
+  .. data:: RLIMIT_RSS
+  .. data:: RLIMIT_STACK
+
+- Linux specific:
+
+  .. data:: RLIMIT_LOCKS
+  .. data:: RLIMIT_MSGQUEUE
+  .. data:: RLIMIT_NICE
+  .. data:: RLIMIT_RTPRIO
+  .. data:: RLIMIT_RTTIME
+  .. data:: RLIMIT_SIGPENDING
+
+- FreeBSD specific:
+
+  .. data:: RLIMIT_SWAP
+
+    .. versionadded:: 5.7.3
+
+
+  .. data:: RLIMIT_SBSIZE
+
+    .. versionadded:: 5.7.3
+
+  .. data:: RLIMIT_NPTS
+
+    .. versionadded:: 5.7.3
+
+.. _const-conn:
+
+Connections constants
+^^^^^^^^^^^^^^^^^^^^^
+
+:class:`enum.StrEnum` constants representing the status of a TCP connection.
+Returned by :meth:`Process.net_connections` and :func:`psutil.net_connections`
+(:field:`status` field).
+
+.. versionchanged:: 8.0.0
+   constants are now :class:`ConnectionStatus` enum members (were plain
+   strings). See :ref:`migration guide <migration-8.0>`.
+
+.. data:: CONN_ESTABLISHED
+.. data:: CONN_SYN_SENT
+.. data:: CONN_SYN_RECV
+.. data:: CONN_FIN_WAIT1
+.. data:: CONN_FIN_WAIT2
+.. data:: CONN_TIME_WAIT
+.. data:: CONN_CLOSE
+.. data:: CONN_CLOSE_WAIT
+.. data:: CONN_LAST_ACK
+.. data:: CONN_LISTEN
+.. data:: CONN_CLOSING
+.. data:: CONN_NONE
+.. data:: CONN_DELETE_TCB (Windows)
+.. data:: CONN_IDLE (Solaris)
+.. data:: CONN_BOUND (Solaris)
+
+Hardware constants
+^^^^^^^^^^^^^^^^^^
+
+.. _const-aflink:
+
+.. data:: AF_LINK
+
+  Identifies a MAC address associated with a network interface. Returned by
+  :func:`psutil.net_if_addrs` (:field:`family` field).
+
+.. _const-duplex:
+
+.. data:: NIC_DUPLEX_FULL
+.. data:: NIC_DUPLEX_HALF
+.. data:: NIC_DUPLEX_UNKNOWN
+
+  Identifies whether a :term:`NIC` operates in full, half, or unknown duplex
+  mode. FULL allows simultaneous send/receive, HALF allows only one at a time.
+  Returned by :func:`psutil.net_if_stats` (:field:`duplex` field).
+
+.. _const-power:
+
+.. data:: POWER_TIME_UNKNOWN
+.. data:: POWER_TIME_UNLIMITED
+
+  Whether the remaining time of a battery cannot be determined or is unlimited.
+  May be assigned to :func:`psutil.sensors_battery`'s :field:`secsleft` field.
+
+Other constants
+^^^^^^^^^^^^^^^
+
+.. _const-procfs_path:
+
+.. data:: PROCFS_PATH
+
+  The path of the ``/proc`` filesystem on Linux, Solaris and AIX (defaults to
+  ``'/proc'``). You may want to re-set this constant right after importing
+  psutil in case ``/proc`` is mounted elsewhere, or if you want to retrieve
+  information about Linux containers such as Docker, Heroku or LXC (see
+  `here <https://fabiokung.com/2014/03/13/memory-inside-linux-containers/>`_
+  for more info).
+
+  It must be noted that this trick works only for APIs which rely on ``/proc``
+  filesystem (e.g. memory-related APIs and many (but not all) :class:`Process`
+  class methods).
+
+  .. availability:: Linux, SunOS, AIX
+
+Utilities
+---------
+
+.. function:: bytes2human(n)
+
+  Convert *n* bytes to a human-readable string.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> psutil.bytes2human(10000)
+     '9.8K'
+     >>> psutil.bytes2human(100001221)
+     '95.4M'
+
+  .. versionadded:: 8.0.0
+
+.. _const-version-info:
+
+.. data:: version_info
+
+  A tuple to check psutil installed version.
+
+  .. code-block:: pycon
+
+     >>> import psutil
+     >>> if psutil.version_info >= (4, 5):
+     ...    pass
+
+Environment variables
+---------------------
+
+.. envvar:: PSUTIL_DEBUG
+
+  If set, psutil will print debug messages to stderr. This is useful for
+  troubleshooting internal errors or understanding the library's behavior at
+  a lower level. The variable is checked at import time, and affects both the
+  Python layer and the underlying C extension modules. It can also be toggled
+  programmatically at runtime via ``psutil._set_debug(True)``.
+
+  .. code-block:: bash
+
+     $ PSUTIL_DEBUG=1 python3 script.py
+
+.. envvar:: PSUTIL_BUILD_JOBS
+
+  By default, psutil compiles its C source files in parallel, using one job per
+  CPU, which makes installing from source 2x to 3.6x faster. Set this variable
+  to change the number of jobs, or to 1 to compile serially.
+
+  .. code-block:: bash
+
+     $ PSUTIL_BUILD_JOBS=1 python3 -m pip install --no-binary=psutil psutil
+
+  .. versionadded:: 8.0.0
+
+.. ============================================================================
+
+.. _`iostats doc`: https://www.kernel.org/doc/Documentation/iostats.txt
+.. _`psleak`: https://github.com/giampaolo/psleak
+.. _`GetExitCodeProcess`: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getexitcodeprocess
+.. _`GetPerformanceInfo`: https://learn.microsoft.com/en-us/windows/win32/api/psapi/nf-psapi-getperformanceinfo
+.. _`PROCESS_MEMORY_COUNTERS_EX`: https://learn.microsoft.com/en-us/windows/win32/api/psapi/ns-psapi-process_memory_counters_ex
+.. _`SetPriorityClass`: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-setpriorityclass
+.. _`TerminateProcess`: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-terminateprocess
+.. _`WaitForSingleObject`: https://learn.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-waitforsingleobject
diff --git a/docs/blog.rst b/docs/blog.rst
new file mode 100644
index 0000000000..ce69700845
--- /dev/null
+++ b/docs/blog.rst
@@ -0,0 +1,7 @@
+..
+   Placeholder for the ``Blog <blog>`` toctree entry in index.rst.
+   Content is unused: ablog overrides blog.html at HTML-generation
+   time via docs/_templates/ablog/collection.html.
+
+Blog
+====
diff --git a/docs/blog/2014/announcing-20.rst b/docs/blog/2014/announcing-20.rst
new file mode 100644
index 0000000000..726915b722
--- /dev/null
+++ b/docs/blog/2014/announcing-20.rst
@@ -0,0 +1,85 @@
+.. post:: 2014-03-10
+   :tags: api-design, compatibility, release
+   :author: Giampaolo Rodola
+   :exclude:
+
+   A major rewrite with breaking API changes
+
+Announcing psutil 2.0
+=====================
+
+psutil 2.0 is out. This is a major rewrite and reorganization of both the
+Python and C extension modules. It costed me four months of work and more than
+**22,000 lines** (the diff against old 1.2.1). Many of the changes are not
+backward compatible; I'm sure this will cause some pain, but I think it's for
+the better and needed to be done.
+
+API changes
+-----------
+
+I already wrote a detailed :doc:`blog post </blog/2014/porting-to-20>` about
+this, so use that as the official reference on how to port your code.
+
+RST documentation
+-----------------
+
+I've never been happy with the old doc hosted on Google Code. The markup
+language provided by Google is pretty limited, plus it's not under revision
+control. The new doc is more detailed, uses reStructuredText as the markup
+language, lives in the same code repository as psutil, and is hosted on the
+excellent Read the Docs: http://psutil.readthedocs.org/
+
+Physical CPUs count
+-------------------
+
+You're now able to distinguish between :term:`logical <logical CPU>` and
+:term:`physical <physical CPU>` CPUs. The full story is in :gh:`427`.
+
+.. code-block:: pycon
+
+    >>> psutil.cpu_count()  # logical
+    4
+    >>> psutil.cpu_count(logical=False)  # physical cores only
+    2
+
+Process instances are hashable
+------------------------------
+
+:class:`psutil.Process` instances can now be compared for equality and used in
+sets and dicts. The most useful application is diffing process snapshots:
+
+.. code-block:: pycon
+
+    >>> before = set(psutil.process_iter())
+    >>> # ... some time passes ...
+    >>> after = set(psutil.process_iter())
+    >>> new_procs = after - before  # processes spawned in between
+
+Equality is not just PID-based. It also includes the process creation time, so
+a :class:`~psutil.Process` whose PID got reused by the kernel won't be mistaken
+for the original. The full story is in :gh:`452`.
+
+Speedups
+--------
+
+* :gh:`477`: :meth:`Process.cpu_percent` is about 30% faster.
+* :gh:`478`: [Linux] almost all APIs are about 30% faster on Python 3.X.
+
+Other improvements and bugfixes
+-------------------------------
+
+* :gh:`424`: published Windows installers for Python 3.X 64-bit.
+* :gh:`447`: the :func:`psutil.wait_procs` ``timeout`` parameter is now
+  optional.
+* :gh:`459`: a
+  `Makefile <https://github.com/giampaolo/psutil/blob/v2.0.0/Makefile>`_ is now
+  available for running tests and other repetitive tasks (also on Windows).
+* :gh:`463`: the ``timeout`` parameter of ``cpu_percent*`` functions defaults
+  to 0.0, because the previous default was a common source of slowdowns.
+* :gh:`340`: [Windows] :meth:`Process.open_files` no longer hangs.
+* :gh:`448`: [Windows] fixed a memory leak affecting :meth:`Process.children`
+  and :meth:`Process.ppid`.
+* :gh:`461`: namedtuples are now pickle-able.
+* :gh:`474`: [Windows] :meth:`Process.cpu_percent` is no longer capped at 100%.
+
+See the :ref:`changelog <200>` for a full list of changes.
diff --git a/docs/blog/2014/porting-to-20.rst b/docs/blog/2014/porting-to-20.rst
new file mode 100644
index 0000000000..6221714f57
--- /dev/null
+++ b/docs/blog/2014/porting-to-20.rst
@@ -0,0 +1,310 @@
+.. post:: 2014-01-11
+   :tags: api-design, compatibility
+   :author: Giampaolo Rodola
+   :exclude:
+
+   A migration guide for the breaking API changes in psutil 2.0
+
+Porting your code to psutil 2.0
+===============================
+
+This blog post is going to be about psutil 2.0, a major release in which I
+decided to reorganize the existing API for the sake of consistency. At the time
+of writing, psutil 2.0 is still under development, and the intent of this blog
+post is to serve as an official reference that describes how you should port
+your existing code base. In doing so, I will also explain why I decided to make
+these changes. Even though many APIs will still be available as aliases
+pointing to the newer ones, the overall changes are numerous and many of them
+are not backward compatible. I'm sure many people will be sorely bitten, but I
+think this is for the better and it needed to be done, hopefully for the first
+and last time.
+
+Module constants turned into functions
+--------------------------------------
+
+**What changed**
+
++---------------------------+-----------------------------------+
+| Old name                  | Replacement                       |
++===========================+===================================+
+| ``psutil.BOOT_TIME``      | ``psutil.boot_time()``            |
++---------------------------+-----------------------------------+
+| ``psutil.NUM_CPUS``       | ``psutil.cpu_count()``            |
++---------------------------+-----------------------------------+
+| ``psutil.TOTAL_PHYMEM``   | ``psutil.virtual_memory().total`` |
++---------------------------+-----------------------------------+
+
+**Why I did it**
+
+I already talked about this more extensively in the previous
+`Making constants part of your API is evil <https://gmpy.dev/blog/2013/making-constants-part-of-your-api-is-evil>`__
+blog post. In short: other than introducing unnecessary slowdowns, calculating
+a module-level constant at import time is dangerous because if something goes
+wrong the whole app will crash. Also, the represented values may be subject to
+change (think about the system clock), but the constant cannot be updated.
+Thanks to this hack, accessing the old constants still works and produces a
+:exc:`DeprecationWarning`.
+
+Renamed module functions
+------------------------
+
+**What changed**
+
++----------------------------+------------------------+
+| Old name                   | Replacement            |
++============================+========================+
+| ``psutil.get_boot_time()`` | ``psutil.boot_time()`` |
++----------------------------+------------------------+
+| ``psutil.get_pid_list()``  | ``psutil.pids()``      |
++----------------------------+------------------------+
+| ``psutil.get_users()``     | ``psutil.users()``     |
++----------------------------+------------------------+
+
+**Why I did it**
+
+They were the only module-level functions with a ``get_`` prefix. None of the
+others had one.
+
+Renamed Process class methods
+-----------------------------
+
+All methods lost their ``get_`` and ``set_`` prefixes. A single method can now
+be used for both getting and setting (if a value is passed). Assuming
+``p = psutil.Process()``:
+
++------------------------------+--------------------------+
+| Old name                     | Replacement              |
++==============================+==========================+
+| ``p.get_children()``         | ``p.children()``         |
++------------------------------+--------------------------+
+| ``p.get_connections()``      | ``p.connections()``      |
++------------------------------+--------------------------+
+| ``p.get_cpu_affinity()``     | ``p.cpu_affinity()``     |
++------------------------------+--------------------------+
+| ``p.get_cpu_percent()``      | ``p.cpu_percent()``      |
++------------------------------+--------------------------+
+| ``p.get_cpu_times()``        | ``p.cpu_times()``        |
++------------------------------+--------------------------+
+| ``p.get_io_counters()``      | ``p.io_counters()``      |
++------------------------------+--------------------------+
+| ``p.get_ionice()``           | ``p.ionice()``           |
++------------------------------+--------------------------+
+| ``p.get_memory_info()``      | ``p.memory_info()``      |
++------------------------------+--------------------------+
+| ``p.get_ext_memory_info()``  | ``p.memory_info_ex()``   |
++------------------------------+--------------------------+
+| ``p.get_memory_maps()``      | ``p.memory_maps()``      |
++------------------------------+--------------------------+
+| ``p.get_memory_percent()``   | ``p.memory_percent()``   |
++------------------------------+--------------------------+
+| ``p.get_nice()``             | ``p.nice()``             |
++------------------------------+--------------------------+
+| ``p.get_num_ctx_switches()`` | ``p.num_ctx_switches()`` |
++------------------------------+--------------------------+
+| ``p.get_num_fds()``          | ``p.num_fds()``          |
++------------------------------+--------------------------+
+| ``p.get_num_threads()``      | ``p.num_threads()``      |
++------------------------------+--------------------------+
+| ``p.get_open_files()``       | ``p.open_files()``       |
++------------------------------+--------------------------+
+| ``p.get_rlimit()``           | ``p.rlimit()``           |
++------------------------------+--------------------------+
+| ``p.get_threads()``          | ``p.threads()``          |
++------------------------------+--------------------------+
+| ``p.getcwd()``               | ``p.cwd()``              |
++------------------------------+--------------------------+
+
+...as for ``set_*`` methods:
+
++--------------------------+-------------------------------------+
+| Old name                 | Replacement                         |
++==========================+=====================================+
+| ``p.set_cpu_affinity()`` | ``p.cpu_affinity(cpus)``            |
++--------------------------+-------------------------------------+
+| ``p.set_ionice()``       | ``p.ionice(ioclass, value=None)``   |
++--------------------------+-------------------------------------+
+| ``p.set_nice()``         | ``p.nice(value)``                   |
++--------------------------+-------------------------------------+
+| ``p.set_rlimit()``       | ``p.rlimit(resource, limits=None)`` |
++--------------------------+-------------------------------------+
+
+**Why I did it**
+
+I wanted to be consistent with system-wide module-level functions, which have
+no ``get_`` prefix. After I got rid of the ``get_`` prefixes, removing ``set_``
+too seemed natural and helped reduce the number of methods.
+
+Process properties are now methods
+----------------------------------
+
+**What changed**
+
+Assuming ``p = psutil.Process()``:
+
++-------------------+---------------------+
+| Old name          | Replacement         |
++===================+=====================+
+| ``p.cmdline``     | ``p.cmdline()``     |
++-------------------+---------------------+
+| ``p.create_time`` | ``p.create_time()`` |
++-------------------+---------------------+
+| ``p.exe``         | ``p.exe()``         |
++-------------------+---------------------+
+| ``p.gids``        | ``p.gids()``        |
++-------------------+---------------------+
+| ``p.name``        | ``p.name()``        |
++-------------------+---------------------+
+| ``p.parent``      | ``p.parent()``      |
++-------------------+---------------------+
+| ``p.ppid``        | ``p.ppid()``        |
++-------------------+---------------------+
+| ``p.status``      | ``p.status()``      |
++-------------------+---------------------+
+| ``p.uids``        | ``p.uids()``        |
++-------------------+---------------------+
+| ``p.username``    | ``p.username()``    |
++-------------------+---------------------+
+
+**Why I did it**
+
+Different reasons:
+
+* Having a mixed API that uses both properties and methods for no particular
+  reason is confusing and messy, because you don't know whether to use ``()``
+  or not.
+* A property is usually expected not to perform heavy computations internally,
+  whereas psutil invokes a function every time it is accessed. This has two
+  drawbacks:
+
+  * You may get an exception just by accessing the property (e.g. ``p.name``
+    may raise :exc:`NoSuchProcess` or :exc:`AccessDenied`).
+  * You may erroneously think properties are cached, but this is true only for
+    ``name``, ``exe``, and ``create_time``.
+
+CPU percent intervals
+---------------------
+
+**What changed**
+
+The timeout parameter of ``cpu_percent*`` functions now defaults to 0.0 instead
+of 0.1. The functions affected are:
+
+* :meth:`Process.cpu_percent`
+* :func:`psutil.cpu_percent`
+* :func:`psutil.cpu_times_percent`
+
+**Why I did it**
+
+I originally set 0.1 as the default timeout because you need to wait some time
+in order to get a meaningful percent value. Having an API that "sleeps" by
+default is risky, though, because it's easy to forget it does so. That is
+particularly problematic when calling :meth:`Process.cpu_percent` for all
+processes: it's very easy to forget to specify ``timeout=0``, resulting in
+dramatic slowdowns that are hard to spot. For example, this code snippet might
+take a variable number of seconds to complete depending on the number of active
+processes:
+
+.. code-block:: pycon
+
+    >>> # this will be slow
+    >>> for p in psutil.process_iter():
+    ...    print(p.cpu_percent())
+
+Migration strategy
+------------------
+
+Except for :class:`Process` properties (:meth:`Process.name`,
+:meth:`Process.exe`, :meth:`Process.cmdline`, etc.), all the old APIs are still
+available as aliases pointing to the newer names and raising
+:exc:`DeprecationWarning`. psutil will be very clear on what you should use
+instead of the deprecated API, as long as you start the interpreter with the
+``-Wd`` option. This will enable deprecation warnings, which were
+`silenced in Python 2.7 <http://bugs.python.org/issue7319>`__ (IMHO, from a
+developer standpoint this was a bad decision).
+
+::
+
+    giampaolo@ubuntu:/tmp$ python -Wd
+    Python 2.7.3 (default, Sep 26 2013, 20:03:06)
+    [GCC 4.6.3] on linux2
+    Type "help", "copyright", "credits" or "license" for more information.
+    >>> import psutil
+    >>> psutil.get_pid_list()
+    __main__:1: DeprecationWarning: psutil.get_pid_list is deprecated; use psutil.pids() instead
+    [1, 2, 3, 6, 7, 13, ...]
+    >>>
+    >>>
+    >>> p = psutil.Process()
+    >>> p.get_cpu_times()
+    __main__:1: DeprecationWarning: get_cpu_times() is deprecated; use cpu_times() instead
+    pcputimes(user=0.08, system=0.03)
+    >>>
+
+If you have a solid test suite, you can run tests and fix the warnings one by
+one. As for the Process properties that were turned into methods, it's more
+difficult because, whereas psutil 1.2.1 returns the actual value, psutil 2.0.0
+returns the bound method:
+
+.. code-block:: pycon
+
+    # psutil 1.2.1
+    >>> psutil.Process().name
+    'python'
+    >>>
+
+    # psutil 2.0.0
+    >>> psutil.Process().name
+    <bound method Process.name of psutil.Process(pid=19816, name='python') at 139845631328144>
+    >>>
+
+What I would recommend, if you want to drop support for 1.2.1, is to grep for
+``".name"``, ``".exe"``, etc. and just replace them with ``".exe()"`` and
+``".name()"`` one by one. If, on the other hand, you want to write code that
+works with both versions, I see two possibilities:
+
+* #1 check version info, like this:
+
+.. code-block:: pycon
+
+    >>> PSUTIL2 = psutil.version_info >= (2, 0)
+    >>> p = psutil.Process()
+    >>> name = p.name() if PSUTIL2 else p.name
+    >>> exe = p.exe() if PSUTIL2 else p.exe
+
+* #2 get rid of all ``".name"``, ``".exe"`` occurrences you have in your code
+  and use :meth:`Process.as_dict` instead:
+
+.. code-block:: pycon
+
+    >>> p = psutil.Process()
+    >>> pinfo = p.as_dict(attrs=["name", "exe"])
+    >>> pinfo
+    {'exe': '/usr/bin/python2.7', 'name': 'python'}
+    >>> name = pinfo['name']
+    >>> exe = pinfo['exe']
+
+New features introduced in 2.0.0
+--------------------------------
+
+psutil 2.0.0 is not only about code breakage. I also had the chance to
+integrate a bunch of interesting features.
+
+* :gh:`427`: you're now able to distinguish between the number of
+  :term:`logical <logical CPU>` and :term:`physical <physical CPU>` CPUs:
+
+.. code-block:: pycon
+
+    >>> psutil.cpu_count()  # logical
+    4
+    >>> psutil.cpu_count(logical=False)  # physical cores only
+    2
+
+* :gh:`452`: :class:`Process` instances are now hashable and can be checked for
+  equality. That means you can use :class:`Process` objects with sets
+  (finally!).
+* :gh:`447`: the ``timeout`` parameter of :func:`psutil.wait_procs` is now
+  optional.
+* :gh:`461`: functions returning namedtuples are now picklable.
+* :gh:`459`: a Makefile is now available to automate repetitive tasks such as
+  build, install, running tests, etc. There's also a make.bat for Windows.
+* Introduced the ``unittest2`` module as a requirement for running tests.
diff --git a/docs/blog/2015/openbsd-support.rst b/docs/blog/2015/openbsd-support.rst
new file mode 100644
index 0000000000..e8ee38d61f
--- /dev/null
+++ b/docs/blog/2015/openbsd-support.rst
@@ -0,0 +1,73 @@
+.. post:: 2015-11-25
+   :tags: bsd, new-platform, community, release
+   :author: Giampaolo Rodola
+   :exclude:
+
+   psutil 3.3.0 now runs on OpenBSD, sharing most of the implementation with FreeBSD
+
+OpenBSD support
+===============
+
+Starting from version 3.3.0 (released just now) psutil officially supports
+OpenBSD. This was contributed by `Landry Breuil <https://github.com/landryb>`__
+and myself in :pr:`615`.
+
+Differences with FreeBSD
+------------------------
+
+As expected, the OpenBSD implementation is very similar to FreeBSD's, so I
+merged most of it into a single C file
+(`_psutil_bsd.c <https://github.com/giampaolo/psutil/blob/release-3.3.0/psutil/_psutil_bsd.c>`__),
+with 2 separate files
+(`freebsd.c <https://github.com/giampaolo/psutil/blob/release-3.3.0/psutil/arch/bsd/freebsd.c>`__,
+`openbsd.c <https://github.com/giampaolo/psutil/blob/release-3.3.0/psutil/arch/bsd/openbsd.c>`__)
+for the parts that differ. Here are the functional differences with FreeBSD:
+
+* :meth:`Process.memory_maps` is not implemented. The kernel provides the
+  necessary pieces but I haven't done this yet (hopefully later).
+* :meth:`Process.num_ctx_switches`'s :field:`involuntary` field is always 0.
+  `kinfo_proc <https://github.com/giampaolo/psutil/blob/fc1e59d08c968898c2ede425a621b62ccf44681c/psutil/_psutil_bsd.c#L335>`__
+  provides this info but it is always set to 0.
+* :meth:`Process.cpu_affinity` (get and set) is not supported.
+* :meth:`Process.exe` is determined by inspecting the command line, so it may
+  not always be available (returns ``None``).
+* :func:`psutil.swap_memory` :field:`sin` and :field:`sout`
+  (:term:`swap in <swap-in>` and :term:`swap out <swap-out>`) values are not
+  available, and are therefore always set to 0.
+* :func:`psutil.cpu_count` ``(logical=False)`` always returns ``None``.
+
+As with FreeBSD, :meth:`Process.open_files` can't return file paths (FreeBSD
+can sometimes). Otherwise everything is there and I'm satisfied with the
+result.
+
+Considerations about BSD platforms
+----------------------------------
+
+psutil has supported FreeBSD since the beginning (year 2009). At the time, it
+made sense to prefer it as the preferred BSD variant as it's the most
+`most popular <https://en.wikipedia.org/wiki/Comparison_of_BSD_operating_systems#Popularity>`__.
+
+Compared to FreeBSD, OpenBSD appears to be more "minimal", both in terms of
+kernel facilities and the number of CLI tools available. One thing I
+particularly appreciate about FreeBSD is that the source code for all CLI tools
+is available under ``/usr/src``, which was a big help when implementing psutil
+APIs.
+
+OpenBSD source code is `also available <https://github.com/openbsd/src>`__, but
+it uses CVS and I am not sure it includes the source code for all CLI tools.
+
+There are still two more BSD variants worth supporting: NetBSD and DragonFlyBSD
+(in this order). About a year ago, someone provided a patch (:gh:`429`) adding
+basic NetBSD support, so that will likely happen sooner or later.
+
+Other enhancements available in this release
+--------------------------------------------
+
+The only other enhancement is :gh:`558`, which allows specifying a different
+location for the /proc filesystem on Linux.
+
+Discussion
+----------
+
+* `Reddit <https://www.reddit.com/r/Python/comments/3u8wm3/openbsd_support_for_psutil_330/>`__
+* `Hacker News <https://news.ycombinator.com/item?id=10628726>`__
diff --git a/docs/blog/2015/reimplementing-ifconfig-in-python.rst b/docs/blog/2015/reimplementing-ifconfig-in-python.rst
new file mode 100644
index 0000000000..85a7940646
--- /dev/null
+++ b/docs/blog/2015/reimplementing-ifconfig-in-python.rst
@@ -0,0 +1,126 @@
+.. post:: 2015-06-13
+   :tags: personal, new-api, compatibility, featured, release
+   :author: Giampaolo Rodola
+   :exclude:
+
+   psutil 3.0 introduces :func:`~psutil.net_if_addrs` and :func:`~psutil.net_if_stats`
+
+Reimplementing ifconfig in Python
+=================================
+
+Here we are. It's been a long time since my last blog post and my last psutil
+release. The reason? I've been travelling! I mean... a lot. I've spent 3 months
+in Berlin, 3 weeks in Japan and 2 months in New York City. While I was there I
+finally had the chance to meet my friend
+`Jay Loden <http://jayloden.com/software.htm>`__ in person. We originally
+started working on psutil together
+`7 years ago <https://groups.google.com/forum/#!topic/psutil-dev/fj8DQ3lGFH4>`__.
+
+.. image:: https://gmpy.dev/images/me-with-jay.jpg
+   :alt: Jay and I
+   :width: 750px
+   :target: https://gmpy.dev/images/me-with-jay.jpg
+
+Back then I didn't know any C (and I'm still a terrible C developer), so he was
+crucial in developing the initial psutil skeleton, including macOS and Windows
+support. Needless to say that this release builds on that work.
+
+net_if_addrs()
+--------------
+
+We're now able to list network interface addresses similarly to the
+``ifconfig`` command on UNIX:
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> from pprint import pprint
+    >>> pprint(psutil.net_if_addrs())
+    {'ethernet0': [snic(family=<AddressFamily.AF_INET: 2>,
+                        address='10.0.0.4',
+                        netmask='255.0.0.0',
+                        broadcast='10.255.255.255'),
+                   snic(family=<AddressFamily.AF_PACKET: 17>,
+                        address='9c:eb:e8:0b:05:1f',
+                        netmask=None,
+                        broadcast='ff:ff:ff:ff:ff:ff')],
+     'localhost': [snic(family=<AddressFamily.AF_INET: 2>,
+                        address='127.0.0.1',
+                        netmask='255.0.0.0',
+                        broadcast='127.0.0.1'),
+                   snic(family=<AddressFamily.AF_PACKET: 17>,
+                        address='00:00:00:00:00:00',
+                        netmask=None,
+                        broadcast='00:00:00:00:00:00')]}
+
+This is limited to ``AF_INET`` (IPv4), ``AF_INET6`` (IPv6) and ``AF_LINK``
+(Ethernet) address families. If you want something more powerful (e.g.
+``AF_BLUETOOTH``) you can take a look at the
+`netifaces <https://pypi.python.org/pypi/netifaces/>`__ extension. If you want
+to see how this is implemented, here's the code for POSIX and Windows:
+
+* `POSIX <https://github.com/giampaolo/psutil/blob/39161251010503d6b087807c473f4fb648dfcbce/psutil/_psutil_posix.c#L151>`__
+* `Windows <https://github.com/giampaolo/psutil/blob/39161251010503d6b087807c473f4fb648dfcbce/psutil/_psutil_windows.c#L2907>`__
+
+net_if_stats()
+--------------
+
+This new function returns information about network interface cards:
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> from pprint import pprint
+    >>> pprint(psutil.net_if_stats())
+    {'ethernet0': snicstats(isup=True,
+                            duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>,
+                            speed=100,
+                            mtu=1500),
+     'localhost': snicstats(isup=True,
+                            duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN: 0>,
+                            speed=0,
+                            mtu=65536)}
+
+The implementation on each platform:
+
+* `Windows <https://github.com/giampaolo/psutil/blob/39161251010503d6b087807c473f4fb648dfcbce/psutil/_psutil_windows.c#L3057>`__
+* `Linux <https://github.com/giampaolo/psutil/blob/39161251010503d6b087807c473f4fb648dfcbce/psutil/_psutil_linux.c#L474>`__
+* `macOS & FreeBSD <https://github.com/giampaolo/psutil/blob/39161251010503d6b087807c473f4fb648dfcbce/psutil/_psutil_posix.c#L229>`__
+* `SunOS <https://github.com/giampaolo/psutil/blob/39161251010503d6b087807c473f4fb648dfcbce/psutil/_psutil_sunos.c#L1153>`__
+
+Also in 3.0
+-----------
+
+Beyond the network-interface APIs, psutil 3.0 ships a few other notable
+changes.
+
+Several integer/string constants (``IOPRIO_CLASS_*``, ``NIC_DUPLEX_*``,
+``*_PRIORITY_CLASS``) now return :mod:`enum` values on Python 3.4+.
+
+Support for :term:`zombie processes <zombie process>` on UNIX was broken.
+Covered in a :doc:`separate post </blog/2015/zombie-processes>`.
+
+All aliases deprecated in the
+:doc:`psutil 2.0 porting guide </blog/2014/porting-to-20>` (January 2014) are
+gone.
+
+For a full list of changes see the :ref:`changelog <300>`.
+
+Final words
+-----------
+
+I must say I'm pretty satisfied with how psutil is evolving and with the
+enjoyment I still get every time I work on it. It now gets almost
+`800,000 downloads a month <https://pypi.org/project/psutil/>`__, which is
+quite remarkable for a Python library.
+
+At this point, I consider psutil almost "complete" feature-wise, meaning I'm
+starting to run out of ideas for what to add next (see
+`TODO <https://github.com/giampaolo/psutil/blob/v3.0.0/TODO>`__). Going
+forward, development will likely focus on supporting more exotic platforms
+(OpenBSD :gh:`562`, NetBSD :pr:`557`, Android :gh:`355`).
+
+There have also been discussions on the python-ideas mailing list about
+`including psutil in the Python stdlib <https://mail.python.org/pipermail//python-ideas/2014-October/029835.html>`__,
+but even if that happens, it's still a long way off, as it would require a
+significant time investment that I currently don't have.
diff --git a/docs/blog/2015/zombie-processes.rst b/docs/blog/2015/zombie-processes.rst
new file mode 100644
index 0000000000..64c12ca6df
--- /dev/null
+++ b/docs/blog/2015/zombie-processes.rst
@@ -0,0 +1,88 @@
+.. post:: 2015-06-13
+   :tags: api-design, compatibility
+   :author: Giampaolo Rodola
+   :exclude:
+
+   Proper handling of zombies via new :exc:`ZombieProcess` exception
+
+Proper zombie process handling
+==============================
+
+This is part of the psutil 3.0 release (see the full
+:doc:`release notes </blog/2015/reimplementing-ifconfig-in-python>`).
+
+Except on Linux and Windows (which does not have them), support for
+:term:`zombie processes <zombie process>` was broken. The full story is in
+:gh:`428`.
+
+The problem
+-----------
+
+Say you create a :term:`zombie process` and instantiate a
+:class:`~psutil.Process` for it:
+
+.. code-block:: python
+
+    import os, time
+
+    def create_zombie():
+        pid = os.fork()  # the zombie
+        if pid == 0:
+            os._exit(0)  # child exits immediately
+        else:
+            time.sleep(1000)  # parent does NOT call wait()
+
+    pid = create_zombie()
+    p = psutil.Process(pid)
+
+Up until psutil 2.X, every time you tried to query it you'd get a
+:exc:`NoSuchProcess` exception:
+
+.. code-block:: pycon
+
+    >>> p.name()
+      File "psutil/__init__.py", line 374, in _init
+        raise NoSuchProcess(pid, None, msg)
+    psutil.NoSuchProcess: no process found with pid 123
+
+This was misleading, because the PID technically still existed:
+
+.. code-block:: pycon
+
+    >>> psutil.pid_exists(p.pid)
+    True
+
+Depending on the platform, some process information could still be retrieved:
+
+.. code-block:: pycon
+
+    >>> p.cmdline()
+    ['python']
+
+Worst of all, :func:`psutil.process_iter` didn't return zombies at all. That
+was a real problem, because identifying them is a legitimate use case: a zombie
+usually indicates a bug where a parent process spawns a child, kills it, but
+never calls ``wait()`` to reap it.
+
+What changed
+------------
+
+* A new :exc:`ZombieProcess` exception is raised whenever a process cannot be
+  queried because it is a zombie.
+* It replaces :exc:`NoSuchProcess`, which was incorrect and misleading.
+* :exc:`ZombieProcess` inherits from :exc:`NoSuchProcess`, so existing code
+  keeps working.
+* :func:`psutil.process_iter` now correctly includes zombie processes, so you
+  can reliably identify them:
+
+.. code-block:: python
+
+    import psutil
+
+    zombies = []
+    for p in psutil.process_iter():
+        try:
+            if p.status() == psutil.STATUS_ZOMBIE:
+                zombies.append(p)
+        except psutil.NoSuchProcess:
+            pass
diff --git a/docs/blog/2016/500-is-twice-as-fast.rst b/docs/blog/2016/500-is-twice-as-fast.rst
new file mode 100644
index 0000000000..32e49a362b
--- /dev/null
+++ b/docs/blog/2016/500-is-twice-as-fast.rst
@@ -0,0 +1,204 @@
+.. post:: 2016-11-06
+   :tags: performance, new-api, featured, release
+   :author: Giampaolo Rodola
+   :category: featured
+   :exclude:
+
+   New :meth:`Process.oneshot`, caching shared syscalls and halving the cost of multi-field queries
+
+Making psutil twice as fast
+===========================
+
+Starting from psutil 5.0.0 you can query multiple :class:`Process` fields
+around twice as fast as before (see :gh:`799` and :meth:`Process.oneshot`). It
+took 7 months, 108 commits, and a massive refactoring of psutil internals
+(:pr:`937`), and I think it's one of the best improvements ever shipped in a
+psutil release.
+
+The problem
+-----------
+
+How process information is retrieved varies by OS. Sometimes it means reading a
+file in /proc (Linux), other times calling C (Windows, BSD, macOS, SunOS), but
+it's always done differently. Psutil abstracts this away: you call
+:meth:`Process.name` without worrying about what happens under the hood or
+which OS you're on.
+
+Internally, multiple pieces of process info (e.g. :meth:`Process.name`,
+:meth:`Process.ppid`, :meth:`Process.uids`, :meth:`Process.create_time`) are
+fetched by the same syscall. On Linux we read :proc:`/proc/pid/stat` to get the
+process name, terminal, CPU times, creation time, status and parent PID, but
+only one value is returned: the others are discarded. On Linux this code reads
+:proc:`/proc/pid/stat` 6 times:
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> p = psutil.Process()
+    >>> p.name()
+    >>> p.cpu_times()
+    >>> p.create_time()
+    >>> p.ppid()
+    >>> p.status()
+    >>> p.terminal()
+
+On BSD most process metrics can be fetched with a single ``sysctl()``, yet
+psutil was invoking it for each process method (e.g. see
+`here <https://github.com/giampaolo/psutil/blob/2fe3f456321ca1605aaa2b71a7193de59d93075c/psutil/_psutil_bsd.c#L242-L258>`__
+and
+`here <https://github.com/giampaolo/psutil/blob/2fe3f456321ca1605aaa2b71a7193de59d93075c/psutil/_psutil_bsd.c#L261-L277>`__).
+
+Do it in one shot
+-----------------
+
+It's clear that this approach is inefficient, especially in tools like top or
+htop, where process info is continuously fetched in a loop. psutil 5.0.0
+introduces a new :meth:`Process.oneshot` context manager. Inside it, the
+internal routine runs once (in the example, on the first :meth:`Process.name`
+call) and the other values are cached. Subsequent calls sharing the same
+internal routine (read :proc:`/proc/pid/stat`, call ``sysctl()`` or whatever)
+return the cached value. The code above can now be rewritten like this, and on
+Linux it runs 2.4 times faster:
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> p = psutil.Process()
+    >>> with p.oneshot():
+    ...     p.name()
+    ...     p.cpu_times()
+    ...     p.create_time()
+    ...     p.ppid()
+    ...     p.status()
+    ...     p.terminal()
+
+Implementation
+--------------
+
+One great thing about psutil's design is its abstraction. It is divided into 3
+"layers". Layer 1 is represented by the main
+`Process class <https://github.com/giampaolo/psutil/blob/88ea5e0b2cc15c37fdeb3e38857f6dab6fd87d12/psutil/__init__.py#L340>`__
+(Python), which exposes the high-level API. Layer 2 is the
+`OS-specific Python module <https://github.com/giampaolo/psutil/blob/88ea5e0b2cc15c37fdeb3e38857f6dab6fd87d12/psutil/_pslinux.py#L1097>`__,
+which is a thin wrapper on top of the OS-specific
+`C extension module <https://github.com/giampaolo/psutil/blob/88ea5e0b2cc15c37fdeb3e38857f6dab6fd87d12/psutil/_psutil_linux.c>`__
+(layer 3).
+
+Because the code was organized this way (modular), the refactoring was
+reasonably smooth. I first refactored those C functions that collect multiple
+pieces of info and grouped them into a single function (e.g. see
+`BSD implementation <https://github.com/giampaolo/psutil/blob/88ea5e0b2cc15c37fdeb3e38857f6dab6fd87d12/psutil/_psutil_bsd.c#L198-L338>`__).
+Then I wrote a
+`decorator <https://github.com/giampaolo/psutil/blob/88ea5e0b2cc15c37fdeb3e38857f6dab6fd87d12/psutil/_common.py#L264-L314>`__
+that enables the cache only when requested (when entering the context manager),
+and decorated the
+`"grouped functions" <https://github.com/giampaolo/psutil/blob/88ea5e0b2cc15c37fdeb3e38857f6dab6fd87d12/psutil/_psbsd.py#L491>`__
+with it. The caching mechanism is controlled by the :meth:`Process.oneshot`
+context manager, which is the only thing exposed to the end user. Here's the
+decorator:
+
+.. code-block:: python
+
+    def memoize_when_activated(fun):
+        """A memoize decorator which is disabled by default. It can be
+        activated and deactivated on request.
+        """
+        @functools.wraps(fun)
+        def wrapper(self):
+            if not wrapper.cache_activated:
+                return fun(self)
+            else:
+                try:
+                    ret = cache[fun]
+                except KeyError:
+                    ret = cache[fun] = fun(self)
+                return ret
+
+        def cache_activate():
+            """Activate cache."""
+            wrapper.cache_activated = True
+
+        def cache_deactivate():
+            """Deactivate and clear cache."""
+            wrapper.cache_activated = False
+            cache.clear()
+
+        cache = {}
+        wrapper.cache_activated = False
+        wrapper.cache_activate = cache_activate
+        wrapper.cache_deactivate = cache_deactivate
+        return wrapper
+
+To measure the speedup I wrote a
+`benchmark script <https://github.com/giampaolo/psutil/blob/b5582380ac70ca8c180344d9b22aacdff73b1e0b/scripts/internal/bench_oneshot.py>`__
+(well,
+`two <https://github.com/giampaolo/psutil/blob/b5582380ac70ca8c180344d9b22aacdff73b1e0b/scripts/internal/bench_oneshot_2.py>`__
+actually), and kept tuning until I was sure the change actually made psutil
+faster. The scripts report the speedup for calling all the "grouped" methods
+together (best-case scenario).
+
+Linux: +2.56x speedup
+---------------------
+
+The Linux implementation is mostly Python, reading files in ``/proc``. These
+files typically expose multiple pieces of info per process;
+:proc:`/proc/pid/stat` and :proc:`/proc/pid/status` are the perfect example. We
+aggregate them into three groups. See the relevant code
+`here <https://github.com/giampaolo/psutil/blob/b5582380ac70ca8c180344d9b22aacdff73b1e0b/psutil/_pslinux.py#L1108-L1153>`__.
+
+Windows: from +1.9x to +6.5x speedup
+------------------------------------
+
+Windows is an interesting one. For a process owned by our user, we group only
+:meth:`Process.num_threads`, :meth:`Process.num_ctx_switches` and
+:meth:`Process.num_handles`, for a +1.9x speedup if we access those methods in
+one shot.
+
+Windows is special though, because certain methods have a dual implementation
+(:gh:`304`): a "fast method" is tried first, but if the process is owned by
+another user it fails with :exc:`AccessDenied`. psutil then falls back to a
+second, "slower" method (see `here
+<https://github.com/giampaolo/psutil/blob/0ccd1373c6e7a189e095df5c436568fb1e8b4d14/psutil/_pswindows.py#L681>`__
+for example).
+
+It's slower because it
+`iterates over all PIDs <https://github.com/giampaolo/psutil/blob/0ccd1373c6e7a189e095df5c436568fb1e8b4d14/psutil/arch/windows/process_info.c#L790>`__,
+but unlike the "plain" Windows APIs it can still
+`retrieve multiple pieces of information in one shot <https://github.com/giampaolo/psutil/blob/0ccd1373c6e7a189e095df5c436568fb1e8b4d14/psutil/_psutil_windows.c#L2789>`__:
+number of threads, :term:`context switches <context switch>`, handles, CPU
+times, create time, and I/O counters.
+
+That's why querying processes owned by other users results in an impressive
++6.5x speedup.
+
+macOS: +1.92x speedup
+---------------------
+
+On macOS we can get 2 groups of information. With
+`sysctl() <https://github.com/giampaolo/psutil/blob/0ccd1373c6e7a189e095df5c436568fb1e8b4d14/psutil/_psutil_osx.c#L129>`__
+we get process parent PID, uids, gids, terminal, create time, name. With
+`proc_info() <https://github.com/giampaolo/psutil/blob/0ccd1373c6e7a189e095df5c436568fb1e8b4d14/psutil/_psutil_osx.c#L183>`__
+we get CPU times (for PIDs owned by another user), memory metrics and ctx
+switches. Not bad.
+
+BSD: +2.18x speedup
+-------------------
+
+On BSD we gather tons of process info just by calling ``sysctl()`` (see
+`implementation <https://github.com/giampaolo/psutil/blob/0ccd1373c6e7a189e095df5c436568fb1e8b4d14/psutil/_psutil_bsd.c#L199>`__):
+process name, ppid, status, uids, gids, IO counters, CPU and create times,
+terminal and ctx switches.
+
+SunOS: +1.37x speedup
+---------------------
+
+SunOS is like Linux (it reads files in ``/proc``), but the code is in C. Here
+too, we group different metrics together (see
+`here <https://github.com/giampaolo/psutil/blob/b5582380ac70ca8c180344d9b22aacdff73b1e0b/psutil/_psutil_sunos.c#L83-L142>`__
+and
+`here <https://github.com/giampaolo/psutil/blob/b5582380ac70ca8c180344d9b22aacdff73b1e0b/psutil/_psutil_sunos.c#L171-L189>`__).
+
+Discussion
+----------
+
+* `Reddit <https://www.reddit.com/r/Python/comments/5bhn4q/psutil_500_is_around_twice_as_fast/>`__
diff --git a/docs/blog/2016/netbsd-support.rst b/docs/blog/2016/netbsd-support.rst
new file mode 100644
index 0000000000..be8178d50c
--- /dev/null
+++ b/docs/blog/2016/netbsd-support.rst
@@ -0,0 +1,50 @@
+.. post:: 2016-02-25
+   :tags: bsd, new-platform, community, release
+   :author: Giampaolo Rodola
+   :exclude:
+
+   Completing the BSD trio alongside FreeBSD and OpenBSD
+
+NetBSD support
+==============
+
+Roughly two months have passed since I last
+:doc:`announced </blog/2015/openbsd-support>` that psutil added support for
+OpenBSD. Today I'm happy to announce that it's the turn of NetBSD! This was
+contributed by `Thomas Klausner <https://github.com/0-wiz-0>`_,
+`Ryo Onodera <https://github.com/ryoon>`_ and myself in :pr:`557`.
+
+Differences with FreeBSD (and OpenBSD)
+--------------------------------------
+
+The NetBSD implementation has limitations similar to the ones I encountered
+with OpenBSD. Again, FreeBSD remains the BSD variant with the best support in
+terms of kernel functionality.
+
+* :meth:`Process.memory_maps` is not implemented. The kernel provides the
+  necessary pieces, but I haven't done this yet (hopefully later).
+* :meth:`Process.num_ctx_switches`'s :field:`involuntary` field is always 0.
+  The ``kinfo_proc()`` syscall provides this info, but it's always set to 0.
+* :meth:`Process.cpu_affinity` (get and set) is not supported.
+* :func:`psutil.cpu_count` ``(logical=False)`` always returns ``None``.
+
+As for the rest: it is all there. All memory, disk, network and process APIs
+are fully supported and functioning.
+
+Other enhancements available in this psutil release
+---------------------------------------------------
+
+Besides NetBSD support, this release has a couple of interesting enhancements:
+
+* :gh:`708`: [Linux] :func:`psutil.net_connections` and
+  :meth:`Process.connections` can be up to 3x faster when there are many
+  connections.
+* :gh:`718`: :func:`psutil.process_iter` is now thread safe.
+
+You can read the rest in the :ref:`changelog <341>`, as usual.
+
+Discussion
+----------
+
+* `Reddit <https://www.reddit.com/r/Python/comments/4131q2/netbsd_support_for_psutil/>`_
+* `Hacker News <https://news.ycombinator.com/item?id=10909101>`_
diff --git a/docs/blog/2016/real-process-memory-in-python.rst b/docs/blog/2016/real-process-memory-in-python.rst
new file mode 100644
index 0000000000..1ec8ac37b4
--- /dev/null
+++ b/docs/blog/2016/real-process-memory-in-python.rst
@@ -0,0 +1,210 @@
+.. post:: 2016-02-17
+   :tags: memory, new-api, compatibility, release, community, linux
+   :author: Giampaolo Rodola
+   :exclude:
+
+   psutil 4.0.0 exposes :term:`USS`, the memory that would
+   actually be freed on process exit + :meth:`Process.environ`
+
+Real process memory and environ in Python
+=========================================
+
+psutil 4.0.0 is out, with some interesting news about process memory metrics.
+I'll get straight to the point and describe what's new.
+
+"Real" process memory info
+--------------------------
+
+Determining how much memory a process **really** uses is not an easy matter
+(see `this <https://lwn.net/Articles/230975/>`__ and
+`this <http://bmaurer.blogspot.it/2006/03/memory-usage-with-smaps.html>`__).
+:term:`RSS` (Resident Set Size), which most people rely on, is misleading
+because it includes both memory unique to the process and memory shared with
+others. What's more interesting for profiling is the memory that would be freed
+if the process were terminated **right now**. In the Linux world this is called
+:term:`USS` (Unique Set Size), the major feature introduced in psutil 4.0.0
+(not only for Linux but also for Windows and macOS).
+
+USS memory
+----------
+
+The :term:`USS` (Unique Set Size) is the memory unique to a process, that would
+be freed if the process were terminated right now. On Linux it can be
+determined by parsing the "private" blocks in :proc:`/proc/pid/smaps`. The
+Firefox team pushed this further and got it working on
+`macOS and Windows <https://searchfox.org/mozilla-central/source/xpcom/base/nsMemoryReporterManager.cpp>`__
+too.
+
+.. code-block:: pycon
+
+    >>> psutil.Process().memory_full_info()
+    pfullmem(rss=101990, vms=521888, shared=38804, text=28200, lib=0, data=59672, dirty=0, uss=81623, pss=91788, swap=0)
+
+PSS and swap
+------------
+
+On Linux there are two additional metrics that can also be determined via
+:proc:`/proc/pid/smaps`: :term:`PSS` and :term:`swap <swap memory>`.
+
+:field:`pss`, aka "Proportional Set Size", represents the amount of memory
+shared with other processes, accounted so that the amount is divided evenly
+between the processes that share it. I.e. if a process has 10 MBs all to itself
+(:term:`USS`) and 10 MBs shared with another process, its :term:`PSS` will be
+15 MBs.
+
+:field:`swap` is simply the amount of memory that has been
+:term:`swapped out <swap-out>` to disk. With :meth:`Process.memory_full_info`
+it is possible to implement a tool like :src:`scripts/procsmem.py`, similar to
+`smem <https://www.selenic.com/smem/>`__ on Linux, which provides a list of
+processes sorted by :field:`uss`. It's interesting to see how :field:`rss`
+differs from :field:`uss`:
+
+.. code-block:: none
+
+    ~/svn/psutil$ ./scripts/procsmem.py
+    PID     User    Cmdline                            USS     PSS    Swap     RSS
+    ==============================================================================
+    ...
+    3986    giampao /usr/bin/python3 /usr/bin/indi   15.3M   16.6M      0B   25.6M
+    3906    giampao /usr/lib/ibus/ibus-ui-gtk3       17.6M   18.1M      0B   26.7M
+    3991    giampao python /usr/bin/hp-systray -x    19.0M   23.3M      0B   40.7M
+    3830    giampao /usr/bin/ibus-daemon --daemoni   19.0M   19.0M      0B   21.4M
+    20529   giampao /opt/sublime_text/plugin_host    19.9M   20.1M      0B   22.0M
+    3990    giampao nautilus -n                      20.6M   29.9M      0B   50.2M
+    3898    giampao /usr/lib/unity/unity-panel-ser   27.1M   27.9M      0B   37.7M
+    4176    giampao /usr/lib/evolution/evolution-c   35.7M   36.2M      0B   41.5M
+    20712   giampao /usr/bin/python -B /home/giamp   45.6M   45.9M      0B   49.4M
+    3880    giampao /usr/lib/x86_64-linux-gnu/hud/   51.6M   52.7M      0B   61.3M
+    20513   giampao /opt/sublime_text/sublime_text   65.8M   73.0M      0B   87.9M
+    3976    giampao compiz                          115.0M  117.0M      0B  130.9M
+    32486   giampao skype                           145.1M  147.5M      0B  149.6M
+
+Implementation
+--------------
+
+To get these values (:field:`uss`, :field:`pss` and :field:`swap`) we need to
+walk the whole process address space. This usually requires higher privileges
+and is considerably slower than :meth:`Process.memory_info`, which is probably
+why tools like ``ps`` and ``top`` show :term:`RSS`/:term:`VMS` instead of
+:term:`USS`. A big thanks goes to the Mozilla team for figuring this out on
+Windows and macOS, and to `Eric Rahm <https://github.com/EricRahm>`_ who put
+the psutil PRs together (see :pr:`744`, :pr:`745` and :pr:`746`). If you don't
+use Python and want to port the code to another language, here are the
+interesting parts:
+
+* `Linux <https://github.com/giampaolo/psutil/blob/42b34049cf96e845b6423db91f991849a2f87578/psutil/_pslinux.py#L1026>`__
+* `macOS <https://github.com/giampaolo/psutil/blob/50fd31a4eaca3e24905b96d587fd08bcf313fc6b/psutil/_psutil_osx.c#L568>`__
+* `Windows <https://github.com/giampaolo/psutil/blob/50fd31a4eaca3e24905b96d587fd08bcf313fc6b/psutil/_psutil_windows.c#L811>`__
+
+Memory type percent
+-------------------
+
+After reorganizing the process memory APIs (:pr:`744`), I added a new
+``memtype`` parameter to :meth:`Process.memory_percent`. You can now compare a
+specific memory type (not only :term:`RSS`) against the total physical memory.
+E.g.
+
+.. code-block:: pycon
+
+    >>> psutil.Process().memory_percent(memtype='pss')
+    0.06877466326787016
+
+Process environ
+---------------
+
+The second biggest improvement in psutil 4.0.0 is the ability to read a
+process's environment variables. This opens up interesting possibilities for
+process recognition and monitoring. For instance, you can start a process with
+a custom environment variable, then iterate over all processes to find the one
+of interest:
+
+.. code-block:: python
+
+    import psutil
+    for p in psutil.process_iter():
+        try:
+            env = p.environ()
+        except psutil.Error:
+            pass
+        else:
+            if 'MYAPP' in env:
+                ...
+
+Process environ was a long-standing issue (:gh:`52`, from 2009) that I gave up
+on because the Windows implementation only worked for the current process.
+`Frank Benkstein <https://github.com/fbenkstein>`_ solved that (:pr:`747`), and
+it now works on Linux, Windows and macOS for all processes (you may still hit
+:exc:`AccessDenied` for processes owned by another user):
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> from pprint import pprint as pp
+    >>> pp(psutil.Process().environ())
+    {...
+     'CLUTTER_IM_MODULE': 'xim',
+     'COLORTERM': 'gnome-terminal',
+     'COMPIZ_BIN_PATH': '/usr/bin/',
+     'HOME': '/home/giampaolo',
+     'PWD': '/home/giampaolo/svn/psutil',
+      }
+    >>>
+
+Note that the resulting dict usually doesn't reflect changes made after the
+process started (e.g. ``os.environ['MYAPP'] = '1'``). Again, for anyone porting
+this to other languages, here are the interesting parts:
+
+* `Linux <https://github.com/giampaolo/psutil/blob/50fd31a4eaca3e24905b96d587fd08bcf313fc6b/psutil/_pslinux.py#L928>`_
+* `macOS <https://github.com/giampaolo/psutil/blob/50fd31a4eaca3e24905b96d587fd08bcf313fc6b/psutil/arch/osx/process_info.c#L241>`_
+* Windows: :pr:`747`
+
+Extended disk IO stats
+----------------------
+
+:func:`psutil.disk_io_counters` now reports additional metrics on Linux and
+FreeBSD:
+
+* :field:`busy_time`: the time spent doing actual I/Os (in milliseconds).
+* :field:`read_merged_count` and :field:`write_merged_count` (Linux only): the
+  number of merged reads and writes (see the
+  `iostats <https://www.kernel.org/doc/Documentation/iostats.txt>`_ doc).
+
+These give a better picture of actual disk utilization (:gh:`756`), similar to
+the ``iostat`` command on Linux.
+
+OS constants
+------------
+
+Given the growing number of platform-specific metrics, I added a set of
+constants to tell which platform you're on: :data:`psutil.LINUX`,
+:data:`psutil.WINDOWS`, etc.
+
+Other fixes
+-----------
+
+The complete list of changes is available in the :ref:`changelog <400>`.
+
+Porting code
+------------
+
+Since 4.0.0 is a major version, I took the chance to (lightly) change / break
+some APIs.
+
+* :meth:`Process.memory_info` no longer returns just an (:field:`rss`,
+  :field:`vms`) namedtuple. It returns a variable-length namedtuple that varies
+  by platform (:field:`rss` and :field:`vms` are always present, even on
+  Windows). Essentially the same result as the old
+  ``Process.memory_info_ex()``. This shouldn't break your code unless you were
+  doing ``rss, vms = p.memory_info()``.
+* ``Process.memory_info_ex()`` is deprecated. It still works as an alias for
+  :meth:`Process.memory_info`, issuing a :exc:`DeprecationWarning`.
+* :func:`psutil.disk_io_counters` on NetBSD and OpenBSD no longer returns
+  :field:`write_count` and :field:`read_count` because the kernel doesn't
+  provide them (we were returning the busy time instead). Should be a small
+  issue given NetBSD and OpenBSD support is very recent.
+
+Discussion
+----------
+
+* `Reddit <https://www.reddit.com/r/Python/comments/469p2c/psutil_400_real_process_memory_info_and_process/>`_
+* `Hacker News <https://news.ycombinator.com/item?id=11119298>`_
diff --git a/docs/blog/2016/windows-services.rst b/docs/blog/2016/windows-services.rst
new file mode 100644
index 0000000000..1770378ea6
--- /dev/null
+++ b/docs/blog/2016/windows-services.rst
@@ -0,0 +1,107 @@
+.. post:: 2016-05-15
+   :tags: windows, new-api, release
+   :author: Giampaolo Rodola
+   :exclude:
+
+   psutil 4.2.0 introduces :func:`win_service_iter` and :func:`win_service_get`
+
+Windows services support
+========================
+
+New psutil 4.2.0 is out. The highlight of this release is the support for
+Windows services (executables that run at system startup, similar to UNIX init
+scripts):
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> list(psutil.win_service_iter())
+    [<WindowsService(name='AeLookupSvc', display_name='Application Experience') at 38850096>,
+     <WindowsService(name='ALG', display_name='Application Layer Gateway Service') at 38850128>,
+     <WindowsService(name='APNMCP', display_name='Ask Update Service') at 38850160>,
+     <WindowsService(name='AppIDSvc', display_name='Application Identity') at 38850192>,
+     ...]
+    >>> s = psutil.win_service_get('alg')
+    >>> s.as_dict()
+    {'binpath': 'C:\\Windows\\System32\\alg.exe',
+     'description': 'Provides support for 3rd party protocol plug-ins for Internet Connection Sharing',
+     'display_name': 'Application Layer Gateway Service',
+     'name': 'alg',
+     'pid': None,
+     'start_type': 'manual',
+     'status': 'stopped',
+     'username': 'NT AUTHORITY\\LocalService'}
+
+I decided to do this mainly because I find pywin32 APIs too low levelish.
+Having something like this in psutil can be useful to discover and monitor
+services more easily. The code was implemented in :pr:`803`. The API for
+querying a service is similar to :class:`psutil.Process`. You can get a
+reference to a service object by using its name (which is unique for every
+service) and then use methods like :meth:`WindowsService.name` and
+:meth:`WindowsService.status`:
+
+.. code-block:: pycon
+
+    >>> s = psutil.win_service_get('alg')
+    >>> s.name()
+    'alg'
+    >>> s.status()
+    'stopped'
+
+Initially I thought about providing a full set of APIs to handle all aspects of
+service management, including ``start()``, ``stop()``, ``restart()``,
+``install()``, ``uninstall()`` and ``modify()``. However, I soon realized I
+would have ended up reimplementing what pywin32 already provides, at the cost
+of overcrowding the psutil API (see my reasoning
+`here <https://github.com/giampaolo/psutil/blob/d28de253a2e6d7f368e5260d7a4ab14b285c5083/psutil/_pswindows.py#L426>`__).
+I think psutil really focuses on monitoring, not on installing and modifying
+system components, especially something as critical as a Windows service.
+
+Considerations about Windows services
+-------------------------------------
+
+Typically, a Windows service is an executable (.exe) that runs at system
+startup and continues running in the background. It is roughly the equivalent
+of a UNIX init script. All services are controlled by a "manager", which keeps
+track of their status and metadata (e.g. description, startup type). It is
+interesting to note that since (most) services are bound to an executable (and
+hence a process) you can reference them via their process PID:
+
+.. code-block:: pycon
+
+    >>> s = psutil.win_service_get('sshd')
+    >>> s
+    <WindowsService(name='sshd', display_name='Open SSH server') at 38853046>
+    >>> s.pid()
+    1865
+    >>> p = psutil.Process(1865)
+    >>> p
+    <psutil.Process(pid=19547, name='sshd.exe') at 140461487781328>
+    >>> p.exe()
+    'C:\CygWin\bin\sshd'
+
+Other improvements
+------------------
+
+psutil 4.2.0 comes with 2 other enhancements for Linux:
+
+* :func:`psutil.virtual_memory` returns a new :field:`shared` memory field.
+  This is the same value reported by ``free`` cmdline utility.
+* I changed how ``/proc`` was parsed. Instead of reading
+  :proc:`/proc/pid/status` line by line I used a regular expression. Here's the
+  speedups:
+
+  * :meth:`Process.ppid` ~20% faster.
+
+  * :meth:`Process.status` ~28% faster.
+
+  * :meth:`Process.name` ~25% faster.
+
+  * :meth:`Process.num_threads` ~20% faster (on Python 3 only; on Python 2 it's
+    a bit slower; I suppose :mod:`re` module received some improvements).
+
+Discussion
+----------
+
+* `Reddit <https://www.reddit.com/r/Python/comments/4jf8tz/psutil_420_windows_services_and_python/>`__
+* `Hacker News <https://news.ycombinator.com/item?id=11700002>`__
diff --git a/docs/blog/2017/aix-support.rst b/docs/blog/2017/aix-support.rst
new file mode 100644
index 0000000000..a7ac4646aa
--- /dev/null
+++ b/docs/blog/2017/aix-support.rst
@@ -0,0 +1,57 @@
+.. post:: 2017-10-12
+   :tags: new-platform, community, personal, release
+   :author: Giampaolo Rodola
+   :exclude:
+
+   psutil 5.4.0 gets an IBM port, contributed by Arnon Yaari
+
+AIX support
+===========
+
+After a long wait psutil finally supports a new exotic platform: AIX!
+
+Honestly I'm not sure how many AIX Python users are out there (probably not
+many), but here it is.
+
+For this we have to thank `Arnon Yaari <https://github.com/wiggin15>`__, who
+started working on the port a couple of years ago (:gh:`605`). I was skeptical
+at first, because AIX is the only platform I can't virtualize and test on my
+laptop, so that made me a bit nervous. Arnon did a great job. The final
+:pr:`1123` is huge: it required a considerable amount of work on his part, and
+a review of more than 140 messages exchanged between us over about a month,
+during which I was travelling through China.
+
+The end result is very good: almost all original unit tests pass, and code
+quality is awesome, which (I must say) is fairly unusual for an external
+contribution like this. Kudos to you, Arnon! ;-)
+
+Other changes
+-------------
+
+Besides AIX support, release 5.4.0 also includes a couple of important bug
+fixes for :func:`psutil.sensors_temperatures` and :func:`psutil.sensors_fans`
+on Linux, and a fix for a bug on macOS that could cause a segmentation fault
+when using :meth:`Process.open_files`. The complete list of bug fixes is in the
+:ref:`changelog <540>`.
+
+The future
+----------
+
+Looking ahead at other exotic, still-unsupported platforms, two contributions
+are worth mentioning: a (still incomplete) PR for Cygwin which looks promising
+(:pr:`998`), and Mingw32 compiler support on Windows (:pr:`845`).
+
+psutil is gradually reaching a point where adding new features is becoming
+rarer, so it's a good moment to welcome new platforms while the API is mature
+and stable.
+
+Future work along these lines could also include Android and (hopefully) iOS
+support. Now *that* would be really awesome to have.
+
+Stay tuned.
+
+Discussion
+----------
+
+* `Reddit <https://www.reddit.com/r/Python/comments/75wsfu/psutil_540_with_aix_support_is_out/>`__
+* `Blogspot <http://grodola.blogspot.com/2017/10/psutil-540-with-aix-support-is-out.html>`__
diff --git a/docs/blog/2017/process-iter-attrs.rst b/docs/blog/2017/process-iter-attrs.rst
new file mode 100644
index 0000000000..65e85034ae
--- /dev/null
+++ b/docs/blog/2017/process-iter-attrs.rst
@@ -0,0 +1,90 @@
+.. post:: 2017-09-03
+   :tags: api-design, release, performance, new-api
+   :author: Giampaolo Rodola
+   :exclude:
+
+   5.3.0 adds ``attrs`` and ``ad_value`` parameters to
+   :func:`~psutil.process_iter`, letting you pre-fetch attributes in one shot
+
+Improved process_iter()
+=======================
+
+This is part of the psutil 5.3.0 release (see the :ref:`changelog <530>` for
+the full list of changes).
+
+The old pattern
+---------------
+
+Iterating over processes and collecting attributes requires more boilerplate
+than it should. A process returned by :func:`process_iter` may disappear before
+you access it, or require elevated privileges, so every lookup has to be
+guarded with a ``try / except``:
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> for proc in psutil.process_iter():
+    ...     try:
+    ...         pinfo = proc.as_dict(attrs=['pid', 'name'])
+    ...     except (psutil.NoSuchProcess, psutil.AccessDenied):
+    ...         pass
+    ...     else:
+    ...         print(pinfo)
+    ...
+    {'pid': 1, 'name': 'systemd'}
+    {'pid': 2, 'name': 'kthreadd'}
+    {'pid': 3, 'name': 'ksoftirqd/0'}
+
+This is not decorative. It's necessary to avoid the race condition.
+
+The new pattern
+---------------
+
+5.3.0 adds ``attrs`` and ``ad_value`` parameters to
+:func:`psutil.process_iter`. With these, the loop body becomes:
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> for proc in psutil.process_iter(attrs=['pid', 'name']):
+    ...     print(proc.info)
+    ...
+    {'pid': 1, 'name': 'systemd'}
+    {'pid': 2, 'name': 'kthreadd'}
+    {'pid': 3, 'name': 'ksoftirqd/0'}
+
+Internally, :func:`process_iter` attach an ``info`` dict to the
+:class:`Process` instance. The attributes are pre-fetched in one shot.
+Processes that disappear during iteration are silently skipped, and attributes
+that would raise :exc:`AccessDenied` gets assigned ``ad_value`` , which
+defaults to ``None``:
+
+.. code-block:: python
+
+    for p in psutil.process_iter(['name', 'username'], ad_value="N/A"):
+        print(p.name(), p.username())
+
+Performance
+-----------
+
+Beyond the syntactic win, the new syntax is also faster than calling individual
+methods in a loop. ``process_iter(attrs=[...])`` is equivalent to using
+:meth:`Process.oneshot` on each process (see
+:doc:`One shot, twice as fast </blog/2016/500-is-twice-as-fast>` for how that
+works): attributes that share a syscall or a ``/proc`` file are fetched
+together instead of re-read on every method call, which is a lot faster.
+
+Comprehensions
+--------------
+
+With the exception boilerplate out of the way, comprehensions finally work
+cleanly. E.g. getting processes owned by the current user can be written as:
+
+.. code-block:: pycon
+
+    >>> import getpass
+    >>> from pprint import pprint as pp
+    >>> pp([(p.pid, p.info['name']) for p in psutil.process_iter(attrs=['name', 'username']) if p.info['username'] == getpass.getuser()])
+    [(16832, 'bash'),
+     (19772, 'ssh'),
+     (20492, 'python')]
diff --git a/docs/blog/2017/sensors-support.rst b/docs/blog/2017/sensors-support.rst
new file mode 100644
index 0000000000..34b071e0b7
--- /dev/null
+++ b/docs/blog/2017/sensors-support.rst
@@ -0,0 +1,105 @@
+.. post:: 2017-02-01
+   :tags: new-api, release, linux
+   :author: Giampaolo Rodola
+   :exclude:
+
+   psutil 5.1.0 introduces :func:`sensors_temperatures`,
+   :func:`sensors_battery` and :func:`cpu_freq`
+
+Sensors: temperatures, battery, CPU frequency
+=============================================
+
+psutil 5.1.0 is out. This release introduces new APIs to retrieve hardware
+temperatures, battery status, and CPU frequency information.
+
+Temperatures
+------------
+
+You can now retrieve hardware temperatures (:pr:`962`). This is currently
+available on Linux only.
+
+* On Windows it's hard to do in a hardware-agnostic way. I ran into 3 WMI-based
+  approaches, none of which worked with my hardware, so I gave up.
+* On macOS it seems relatively easy, but my virtualized macOS box doesn't
+  support sensors, so I gave up for lack of hardware. If someone wants to give
+  it a try, be my guest (:gh:`371`).
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> psutil.sensors_temperatures()
+    {'acpitz': [shwtemp(label='', current=47.0, high=103.0, critical=103.0)],
+     'asus': [shwtemp(label='', current=47.0, high=None, critical=None)],
+     'coretemp': [shwtemp(label='Physical id 0', current=52.0, high=100.0, critical=100.0),
+                  shwtemp(label='Core 0', current=45.0, high=100.0, critical=100.0),
+                  shwtemp(label='Core 1', current=52.0, high=100.0, critical=100.0),
+                  shwtemp(label='Core 2', current=45.0, high=100.0, critical=100.0),
+                  shwtemp(label='Core 3', current=47.0, high=100.0, critical=100.0)]}
+
+Battery status
+--------------
+
+Battery status information is now available on Linux, Windows and FreeBSD
+(:pr:`963`).
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>>
+    >>> def secs2hours(secs):
+    ...     mm, ss = divmod(secs, 60)
+    ...     hh, mm = divmod(mm, 60)
+    ...     return "%d:%02d:%02d" % (hh, mm, ss)
+    ...
+    >>> battery = psutil.sensors_battery()
+    >>> battery
+    sbattery(percent=93, secsleft=16628, power_plugged=False)
+    >>> print("charge = %s%%, time left = %s" % (battery.percent, secs2hours(battery.secsleft)))
+    charge = 93%, time left = 4:37:08
+
+CPU frequency
+-------------
+
+Available on Linux, Windows and macOS (:pr:`952`). Only Linux reports the
+real-time value (always changing); other platforms return the nominal "fixed"
+value.
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> psutil.cpu_freq()
+    scpufreq(current=931.42925, min=800.0, max=3500.0)
+    >>> psutil.cpu_freq(percpu=True)
+    [scpufreq(current=2394.945, min=800.0, max=3500.0),
+     scpufreq(current=2236.812, min=800.0, max=3500.0),
+     scpufreq(current=1703.609, min=800.0, max=3500.0),
+     scpufreq(current=1754.289, min=800.0, max=3500.0)]
+
+What CPU a process is on
+------------------------
+
+Tells you which CPU a process is currently running on, somewhat related to
+:meth:`Process.cpu_affinity` (:pr:`954`). It's interesting for visualizing how
+the OS scheduler keeps evenly reassigning processes across CPUs (see the
+:src:`scripts/cpu_distribution.py` script).
+
+CPU affinity
+------------
+
+A new shorthand is available to set affinity against all eligible CPUs:
+
+.. code-block:: python
+
+    Process().cpu_affinity([])
+
+This was added because on Linux (:gh:`956`) it is not always possible to set
+affinity against all CPUs directly. It is equivalent to:
+
+.. code-block:: python
+
+    psutil.Process().cpu_affinity(list(range(psutil.cpu_count())))
+
+Other bug fixes
+---------------
+
+See the full list in the :ref:`changelog <510>`.
diff --git a/docs/blog/2017/unicode-internals.rst b/docs/blog/2017/unicode-internals.rst
new file mode 100644
index 0000000000..15dd92ec17
--- /dev/null
+++ b/docs/blog/2017/unicode-internals.rst
@@ -0,0 +1,107 @@
+.. post:: 2017-09-03
+   :tags: api-design, compatibility, python-core
+   :author: Giampaolo Rodola
+   :exclude:
+
+   How psutil 5.3.0 got non-ASCII strings right on both Python 2 and
+   Python 3.
+
+Fixing Unicode across Python 2 and 3
+====================================
+
+This one took a while. Adding proper Unicode support to psutil took four months
+of auditing, design decisions, and rewriting nearly every API that returned a
+string. The full journey is documented in :gh:`1040`, and what follows is a
+summary.
+
+This can serve as a case study for any Python library with a C extension that
+needs to support both Python 2 *and* Python 3, as it will encounter the exact
+same set of problems.
+
+What was broken
+---------------
+
+psutil has different APIs returning a string, many of which misbehaved when it
+came to unicode. There were three distinctive problems (:gh:`1040`). Each API
+could:
+
+* **A**: raise a decoding error for non-ASCII strings (Python 3).
+* **B**: return ``unicode`` instead of ``str`` (Python 2).
+* **C**: return incorrect / invalid encoded data for non-ASCII strings (both).
+
+:meth:`Process.memory_maps` hit all three on various OSes.
+:func:`disk_partitions` raised decoding errors on every UNIX except Linux.
+Windows service methods leaked ``unicode`` into Python 2 return values. The C
+extension had accumulated years of ad-hoc encode/decode decisions, with no
+single rule covering all of them.
+
+It was a mess.
+
+Filesystem or locale encoding?
+------------------------------
+
+First problem was that the C extension was using 2 approaches when it came to
+decoding and returning a string: :c:func:`PyUnicode_DecodeFSDefault`
+(filesystem encoding) for path-like APIs, and :c:func:`PyUnicode_DecodeLocale`
+(user locale) for non-path strings like :meth:`Process.username`.
+
+It appeared clear that I had to use :c:func:`PyUnicode_DecodeFSDefault` for all
+filesystem-related APIs like :meth:`Process.exe` and
+:meth:`Process.open_files`.
+
+It was less clear, though, when to use :c:func:`PyUnicode_DecodeLocale`.
+
+After some back and forth, I decided to use a single encoding for all APIs: the
+**filesystem encoding** (:c:func:`PyUnicode_DecodeFSDefault`). This makes the
+encoding choice an implementation detail of psutil, not something the user has
+to care about.
+
+Error handling
+--------------
+
+Second question was what to do in case the string cannot be correctly decoded
+(because invalid, corrupted or whatever). On Python 3 + UNIX the natural choice
+was ``'surrogateescape'``, which is also the default for
+:c:func:`PyUnicode_DecodeFSDefault`. On Windows the default is
+``'surrogatepass'`` (Python 3.6) or ``'replace'`` as per
+`PEP 529 <https://www.python.org/dev/peps/pep-0529/>`__.
+
+And here come the troubles: Python 2 is different. To correctly handle all
+kinds of strings on Python 2 we should return ``unicode`` instead of ``str``,
+but I didn't want to do that, nor have APIs which return two different types
+depending on the circumstance.
+
+Since unicode support is already broken in Python 2 and its stdlib (see
+:bpo:`18695`), I was happy to always return ``str``, use ``'replace'`` as the
+error handler, and simply consider unicode support in psutil + Python 2 broken.
+
+Final behavior
+--------------
+
+Starting from 5.3.0, psutil behaves consistently across all APIs that return a
+string. The rules are intentionally simple, even if the underlying
+implementation is not.
+
+The notes below apply to *any* method returning a string such as
+:meth:`Process.exe` or :meth:`Process.cwd`, including non-filesystem-related
+methods such as :meth:`Process.username`:
+
+* all strings are encoded using the OS filesystem encoding
+  (:c:func:`PyUnicode_DecodeFSDefault`), which varies depending on the platform
+  you're on (e.g. ``'UTF-8'`` on Linux, ``'mbcs'`` on Windows).
+* no API call is supposed to crash with :exc:`UnicodeDecodeError`.
+* in case of badly encoded data returned by the OS, the following error
+  handlers are used to replace the bad characters in the string:
+
+  - Python 2: ``'replace'``.
+  - Python 3: ``'surrogateescape'`` on POSIX, ``'replace'`` on Windows.
+
+* on Python 2 all APIs return bytes (``str`` type), never ``unicode``.
+* on Python 2 you can go back to unicode by doing:
+
+  .. code-block:: pycon
+
+      >>> unicode(proc.exe(), sys.getdefaultencoding(), errors="replace")
+
+The full journey was implemented in :pr:`1052`, and shipped in 5.3.0 (see the
+:ref:`changelog <530>`).
diff --git a/docs/blog/2019/announcing-560.rst b/docs/blog/2019/announcing-560.rst
new file mode 100644
index 0000000000..57fcb2afa3
--- /dev/null
+++ b/docs/blog/2019/announcing-560.rst
@@ -0,0 +1,74 @@
+.. post:: 2019-03-05
+   :tags: windows, macos, new-api, compatibility, release
+   :author: Giampaolo Rodola
+   :exclude:
+
+   5.6.0 adds :meth:`~psutil.Process.parents`, brings several Windows improvements, and removes :meth:`~psutil.Process.memory_maps` on macOS
+
+Announcing psutil 5.6.0
+=======================
+
+psutil 5.6.0 is out. Highlights: a new :meth:`Process.parents` method, several
+important Windows improvements, and the removal of :meth:`Process.memory_maps`
+on macOS.
+
+Process parents()
+-----------------
+
+The new method returns the parents of a process as a list of :class:`Process`
+instances. If no parents are known, an empty list is returned.
+
+.. code-block:: pycon
+
+    >>> import psutil
+    >>> p = psutil.Process(5312)
+    >>> p.parents()
+    [psutil.Process(pid=4699, name='bash', started='09:06:44'),
+     psutil.Process(pid=4689, name='gnome-terminal-server', started='09:06:44'),
+     psutil.Process(pid=1, name='systemd', started='05:56:55')]
+
+Nothing fundamentally new here, since this is a convenience wrapper around
+:meth:`Process.parent`, but it's still nice to have it built in. It pairs well
+with :meth:`Process.children` when working with process trees. The idea was
+proposed by Ghislain Le Meur.
+
+Windows
+-------
+
+Certain Windows APIs that need to be dynamically loaded from DLLs are now
+loaded only once at startup, instead of on every function call. This makes some
+operations **50% to 100% faster**; see benchmarks in :pr:`1422`.
+
+:meth:`Process.suspend` and :meth:`Process.resume` previously iterated over all
+process threads via ``CreateToolhelp32Snapshot()``, which was unorthodox and
+broke when the process had been suspended by Process Hacker. They now call the
+undocumented ``NtSuspendProcess()`` / ``NtResumeProcess()`` NT APIs, same as
+Process Hacker and Sysinternals tools. Discussed in :gh:`1379`, implemented in
+:pr:`1435`.
+
+``SE DEBUG`` is a privilege bit set on the Python process at startup so psutil
+can query processes owned by other users (Administrator, Local System), meaning
+fewer :exc:`AccessDenied` exceptions for low-PID processes. The code setting it
+had presumably been broken for years and is now finally fixed in :pr:`1429`.
+
+Removal of Process.memory_maps() on macOS
+-----------------------------------------
+
+:meth:`Process.memory_maps` is gone on macOS (:gh:`1291`). The underlying Apple
+API would randomly raise ``EINVAL`` or segfault the host process, and no amount
+of reverse-engineering produced a safe fix. So I removed it. This is covered in
+a :doc:`separate post </blog/2019/macos-memory-maps>`.
+
+Improved exceptions
+-------------------
+
+One problem that affected psutil maintenance over the years was receiving bug
+reports whose tracebacks did not indicate which syscall had actually failed.
+This was especially painful on Windows, where a single routine may invoke
+multiple Windows APIs. Now the :exc:`OSError` (or ``WindowsError``) exception
+includes the syscall from which the error originated. See :pr:`1428`.
+
+Other changes
+-------------
+
+See the :ref:`changelog <560>`.
diff --git a/docs/blog/2019/macos-memory-maps.rst b/docs/blog/2019/macos-memory-maps.rst
new file mode 100644
index 0000000000..a7f50489d7
--- /dev/null
+++ b/docs/blog/2019/macos-memory-maps.rst
@@ -0,0 +1,58 @@
+.. post:: 2019-03-05
+   :tags: macos, api-design, compatibility, release
+   :author: Giampaolo Rodola
+   :exclude:
+
+   A segfault I couldn't fix, and the API removal that followed
+
+Removing Process.memory_maps() on macOS
+=======================================
+
+This is part of the psutil 5.6.0 release (see the full
+:doc:`release notes </blog/2019/announcing-560>`).
+
+As of 5.6.0, :meth:`Process.memory_maps` is no longer defined on macOS.
+
+The bug
+-------
+
+:gh:`1291`: on macOS, :meth:`Process.memory_maps` would either raise
+``OSError: [Errno 22] Invalid argument`` or segfault the whole Python process!
+Both triggered from code as simple as ``psutil.Process().as_dict()``, since
+:meth:`~Process.as_dict` iterates every attribute, and
+:meth:`~Process.memory_maps` is one of them.
+
+The root cause was inside Apple's undocumented ``proc_regionfilename()``
+syscall. On some memory regions it returns ``EINVAL``. On others it takes the
+process down. Which regions? Nobody figured out. Arnon Yaari
+(:user:`wiggin15`) did most of the
+investigation: he wrote a `standalone C reproducer
+<https://gist.github.com/wiggin15/0a4c51b5bc6c52e6e31e2234f88558ab>`__
+and walked me through what he'd tried.
+
+In :pr:`1436` I attempted a fix by reverse-engineering ``vmmap(1)`` but it
+didn't work. The fundamental problem is that ``vmmap`` is closed source and
+``proc_regionfilename`` is undocumented. Neither my virtualized macOS (10.11.6)
+nor Travis CI (10.12.1) could reproduce the bug, which reproduced reliably only
+on 10.14.3.
+
+Why remove outright
+-------------------
+
+While removing the C code I noticed that the macOS unit test had been disabled
+long ago, presumably by me after recurring flaky Travis runs. Meaning that the
+method had been broken on some macOS versions far longer than the 2018 bug
+report suggested.
+
+Deprecating for a cycle didn't help either: raising :exc:`AccessDenied` breaks
+code that relied on a successful return, returning an empty list does the same
+silently, and leaving the method in place doesn't stop the segfault. Basically
+there was no sane solution, so since 5.6 is a major version I decided to just
+remove :meth:`Process.memory_maps` for good.
+
+On macOS it never supported other processes anyway. Calling it on any PID other
+than the current one (or its children) raised :exc:`AccessDenied`, even as
+root.
+
+If someone finds a Mach API path that works, the method can return. Nobody has
+found one so far.
diff --git a/docs/blog/2025/drop-py27.rst b/docs/blog/2025/drop-py27.rst
new file mode 100644
index 0000000000..225549910c
--- /dev/null
+++ b/docs/blog/2025/drop-py27.rst
@@ -0,0 +1,114 @@
+.. post:: 2025-02-13
+   :tags: compatibility, release, featured
+   :author: Giampaolo Rodola
+   :exclude:
+
+   Downloads fell from ~8% to 0.36% in three years; psutil
+   7.0.0 ends support
+
+Letting go of Python 2.7
+========================
+
+About dropping Python 2.7 support in psutil, 3 years ago I stated (:gh:`2014`):
+
+   Not a chance, for many years to come. [Python 2.7] currently
+   represents 7-10% of total downloads, meaning around 70k / 100k
+   downloads per day.
+
+Only 3 years later, and to my surprise,
+**downloads for Python 2.7 dropped to 0.36%**! As such, as of psutil 7.0.0, I
+finally decided to drop support for Python 2.7!
+
+The numbers
+-----------
+
+These are downloads per month:
+
+.. code-block:: none
+
+   $ pypinfo --percent psutil pyversion
+   Served from cache: False
+   Data processed: 4.65 GiB
+   Data billed: 4.65 GiB
+   Estimated cost: $0.03
+
+   | python_version | percent | download_count |
+   | -------------- | ------- | -------------- |
+   | 3.10           |  23.84% |     26,354,506 |
+   | 3.8            |  18.87% |     20,862,015 |
+   | 3.7            |  17.38% |     19,217,960 |
+   | 3.9            |  17.00% |     18,798,843 |
+   | 3.11           |  13.63% |     15,066,706 |
+   | 3.12           |   7.01% |      7,754,751 |
+   | 3.13           |   1.15% |      1,267,008 |
+   | 3.6            |   0.73% |        803,189 |
+   | 2.7            |   0.36% |        402,111 |
+   | 3.5            |   0.03% |         28,656 |
+   | Total          |         |    110,555,745 |
+
+According to `pypistats.org <https://archive.is/wip/knzql>`__ Python 2.7
+downloads represent 0.28% of the total, around 15,000 downloads per day.
+
+The pain
+--------
+
+Keeping 2.7 alive had become increasingly difficult, but still possible: tests
+ran via
+`old PyPI backports <https://github.com/giampaolo/psutil/blob/fbb6d9ce98f930d3d101b7df5a4f4d0f1d2b35a3/setup.py#L76-L85>`__
+and a
+`tweaked GitHub Actions workflow <https://github.com/giampaolo/psutil/blob/fbb6d9ce98f930d3d101b7df5a4f4d0f1d2b35a3/.github/workflows/build.yml#L77-L112>`__
+on Linux and macOS, plus a separate third-party service (Appveyor) for Windows.
+But the workarounds in the source kept piling up:
+
+-  A Python compatibility layer
+   (`psutil/\_compat.py <https://github.com/giampaolo/psutil/blob/fbb6d9ce98f930d3d101b7df5a4f4d0f1d2b35a3/psutil/_compat.py>`__)
+   plus ``#if PY_MAJOR_VERSION <= 3`` branches in C, with constant
+   str-vs-unicode juggling on both sides.
+-  No f-strings, and no free use of :mod:`enum` for constants (which ended up
+   with a different API shape than on Python 3).
+-  An outdated ``pip`` and
+   `outdated deps <https://github.com/giampaolo/psutil/blob/fbb6d9ce98f930d3d101b7df5a4f4d0f1d2b35a3/setup.py#L76-L85>`__.
+-  4 extra CI jobs per commit (Linux, macOS, Windows 32-bit and 64-bit), making
+   the pipeline slower and flakier.
+-  7 wheels specific to Python 2.7 to ship on every release:
+
+.. code-block:: none
+
+   psutil-6.1.1-cp27-cp27m-macosx_10_9_x86_64.whl
+   psutil-6.1.1-cp27-none-win32.whl
+   psutil-6.1.1-cp27-none-win_amd64.whl
+   psutil-6.1.1-cp27-cp27m-manylinux2010_i686.whl
+   psutil-6.1.1-cp27-cp27m-manylinux2010_x86_64.whl
+   psutil-6.1.1-cp27-cp27mu-manylinux2010_i686.whl
+   psutil-6.1.1-cp27-cp27mu-manylinux2010_x86_64.whl
+
+The removal
+-----------
+
+The removal was done in :pr:`2481`, which dropped around 1500 lines of code
+(nice!). **It felt liberating**. In doing so, in the doc I still made the
+promise that the 6.1.\* series will keep supporting Python 2.7 and will receive
+**critical bug-fixes only** (no new features). It will be maintained in a
+specific
+`python2 branch <https://github.com/giampaolo/psutil/tree/release-6.1.1>`__. I
+explicitly kept the
+`setup.py <https://github.com/giampaolo/psutil/blob/fbb6d9ce98f930d3d101b7df5a4f4d0f1d2b35a3/setup.py>`__
+script compatible with Python 2.7 in terms of syntax, so that, when the tarball
+is fetched from PyPI, it will emit an informative error message on
+``pip install psutil``. The user trying to install psutil on Python 2.7 will
+see:
+
+.. code-block:: none
+
+   $ pip2 install psutil
+   As of version 7.0.0 psutil no longer supports Python 2.7.
+   Latest version supporting Python 2.7 is psutil 6.1.X.
+   Install it with: "pip2 install psutil==6.1.*".
+
+Related
+-------
+
+-  2017-06: :gh:`1053` (2.7 ticket)
+-  2022-04: :pr:`2099` (Drop 2.6)
+-  2023-04: :pr:`2246` (Drop 3.4 & 3.5)
+-  2024-12: :pr:`2481` (Drop 2.7)
diff --git a/docs/blog/2025/heap-introspection-apis.rst b/docs/blog/2025/heap-introspection-apis.rst
new file mode 100644
index 0000000000..9a9736cc86
--- /dev/null
+++ b/docs/blog/2025/heap-introspection-apis.rst
@@ -0,0 +1,212 @@
+.. post:: 2025-12-23
+   :tags: memory, c, new-api, featured
+   :author: Giampaolo Rodola
+   :exclude:
+
+   psutil 7.2.0 peeks into the native allocator, spotting leaks :term:`RSS` can't see
+
+Detecting memory leaks in C extensions with psutil and psleak
+=============================================================
+
+Memory leaks in Python are usually straightforward to diagnose. Just look at
+:term:`RSS`, track Python object counts, follow reference graphs, etc. But
+leaks inside C extension modules are another story. Traditional memory metrics
+such as :term:`RSS` and :term:`VMS` fail to reveal them because Python's memory
+allocator
+(`pymalloc <https://docs.python.org/3/c-api/memory.html#the-pymalloc-allocator>`__)
+sits above the platform's native :term:`heap`. If something in an extension
+calls :manpage:`malloc(3)` without a corresponding :manpage:`free(3)`, that
+memory often won't show up in :term:`RSS` / :term:`VMS`. You have a leak, and
+you don't know.
+
+psutil 7.2.0 introduces two new APIs for **C :term:`heap` introspection**,
+designed specifically to catch these kinds of native leaks. They give you a
+window directly into the underlying platform allocator (e.g. glibc's malloc),
+letting you track how much memory the C layer actually allocates. If your
+:term:`RSS` is flat but your C :term:`heap` usage climbs, you now have a way to
+see it.
+
+Why native heap introspection matters
+-------------------------------------
+
+Many Python projects rely on C extensions: psutil, NumPy, pandas, PIL, lxml,
+psycopg, PyTorch, custom in-house modules, etc. And even CPython itself, which
+implements many of its standard library modules in C. If any of these
+components mishandle memory at the C level, you get a leak that doesn't show up
+in:
+
+-  Python reference counts (:func:`sys.getrefcount`).
+-  :mod:`tracemalloc` module.
+-  Python's :mod:`gc` stats.
+-  :term:`RSS`, :term:`VMS` or :term:`USS` due to allocator caching, especially
+   for small objects. This can happen, for example, when you forget to
+   ``Py_DECREF`` a Python object.
+
+psutil's new functions let you query the allocator (e.g. glibc) directly,
+returning low-level metrics from the platform's native heap.
+
+heap_info(): direct allocator statistics
+----------------------------------------
+
+:func:`psutil.heap_info` exposes the following metrics:
+
+-  :field:`heap_used`: total number of bytes currently allocated via
+   ``malloc()`` (small allocations).
+-  :field:`mmap_used`: total number of bytes currently allocated via
+   :manpage:`mmap(2)` or via large ``malloc()`` allocations.
+-  :field:`heap_count`: (Windows only) number of private heaps created via
+   ``HeapCreate()``.
+
+Example:
+
+.. code-block:: pycon
+
+   >>> import psutil
+   >>> psutil.heap_info()
+   pheap(heap_used=5177792, mmap_used=819200)
+
+Reference for what contributes to each field:
+
+.. list-table::
+   :header-rows: 1
+
+   * - Platform
+     - Allocation type
+     - Field affected
+   * - UNIX / Windows
+     - small ``malloc()`` ≤128 KB without ``free()``
+     - :field:`heap_used`
+   * - UNIX / Windows
+     - large ``malloc()`` >128 KB without ``free()``, or ``mmap()``
+       without :manpage:`munmap(2)` (UNIX)
+     - :field:`mmap_used`
+   * - Windows
+     - ``HeapAlloc()`` without ``HeapFree()``
+     - :field:`heap_used`
+   * - Windows
+     - ``VirtualAlloc()`` without ``VirtualFree()``
+     - :field:`mmap_used`
+   * - Windows
+     - ``HeapCreate()`` without ``HeapDestroy()``
+     - :field:`heap_count`
+
+heap_trim(): returning unused heap memory
+-----------------------------------------
+
+:func:`psutil.heap_trim` provides a cross-platform way to request that the
+underlying allocator free any unused memory it's holding in the heap (typically
+small ``malloc()`` allocations).
+
+In practice, modern allocators rarely comply, so this is not a general-purpose
+memory-reduction tool and won't meaningfully shrink :term:`RSS` in real
+programs. Its primary value is in leak detection tools. Calling
+:func:`psutil.heap_trim` before taking measurements helps reduce allocator
+noise, giving you a cleaner baseline so that changes in :field:`heap_used` come
+from the code you're testing, not from internal allocator caching or
+fragmentation.
+
+Real-world use: finding a C extension leak
+------------------------------------------
+
+The workflow is simple:
+
+1. Take a baseline snapshot of the heap.
+2. Call the C extension hundreds of times.
+3. Take another snapshot.
+4. Compare.
+
+.. code-block:: python
+
+   import psutil
+
+   psutil.heap_trim()  # reduce noise
+
+   before = psutil.heap_info()
+   for _ in range(200):
+       my_cext_function()
+   after = psutil.heap_info()
+
+   print("delta heap_used =", after.heap_used - before.heap_used)
+   print("delta mmap_used =", after.mmap_used - before.mmap_used)
+
+If :field:`heap_used` or :field:`mmap_used` values increase consistently,
+you've found a native leak.
+
+To reduce false positives, repeat the test multiple times, increasing the
+number of calls on each retry. This approach helps distinguish real leaks from
+random noise or transient allocations.
+
+A new tool: psleak
+------------------
+
+The strategy described above is exactly what I implemented in a new PyPI
+package, which I called `psleak <https://github.com/giampaolo/psleak>`__. It
+runs the target function repeatedly, trims the allocator before each run, and
+tracks differences across retries. Memory that grows consistently after several
+runs is flagged as a leak.
+
+A minimal test suite looks like this:
+
+.. code-block:: python
+
+     from psleak import MemoryLeakTestCase
+
+     class TestLeaks(MemoryLeakTestCase):
+         def test_fun(self):
+             self.execute(some_c_function)
+
+If the function leaks memory, the test will fail with a descriptive exception:
+
+.. code-block:: none
+
+   psleak.MemoryLeakError: memory kept increasing after 10 runs
+   Run # 1: heap=+388160  | uss=+356352  | rss=+327680  | (calls= 200, avg/call=+1940)
+   Run # 2: heap=+584848  | uss=+614400  | rss=+491520  | (calls= 300, avg/call=+1949)
+   Run # 3: heap=+778320  | uss=+782336  | rss=+819200  | (calls= 400, avg/call=+1945)
+   Run # 4: heap=+970512  | uss=+1032192 | rss=+1146880 | (calls= 500, avg/call=+1941)
+   Run # 5: heap=+1169024 | uss=+1171456 | rss=+1146880 | (calls= 600, avg/call=+1948)
+   Run # 6: heap=+1357360 | uss=+1413120 | rss=+1310720 | (calls= 700, avg/call=+1939)
+   Run # 7: heap=+1552336 | uss=+1634304 | rss=+1638400 | (calls= 800, avg/call=+1940)
+   Run # 8: heap=+1752032 | uss=+1781760 | rss=+1802240 | (calls= 900, avg/call=+1946)
+   Run # 9: heap=+1945056 | uss=+2031616 | rss=+2129920 | (calls=1000, avg/call=+1945)
+   Run #10: heap=+2140624 | uss=+2179072 | rss=+2293760 | (calls=1100, avg/call=+1946)
+
+Psleak is now part of the psutil test suite. All psutil APIs are tested (see
+`test_memleaks.py <https://github.com/giampaolo/psutil/blob/1a946cfe738045cecf031222cd5078da21946af4/tests/test_memleaks.py>`__),
+making it a de facto **regression-testing tool**.
+
+It's worth noting that without inspecting heap metrics, missing calls in the C
+code such as ``Py_CLEAR`` and ``Py_DECREF`` often go unnoticed, because they
+don't affect :term:`RSS`, :term:`VMS`, and :term:`USS`. I confirmed this by
+commenting them out. Monitoring the :term:`heap` is therefore essential to
+reliably detect memory leaks in Python C extensions.
+
+Under the hood
+--------------
+
+For those interested in seeing how I did this in terms of code:
+
+-  `Linux <https://github.com/giampaolo/psutil/blob/d40164f1/psutil/arch/linux/heap.c>`__:
+   uses glibc's :manpage:`mallinfo2(3)` to report ``uordblks`` (heap
+   allocations) and ``hblkhd`` (mmap-backed blocks).
+-  `Windows <https://github.com/giampaolo/psutil/blob/d40164f1/psutil/arch/windows/heap.c>`__:
+   enumerates heaps and aggregates ``HeapAlloc`` / ``VirtualAlloc`` usage.
+-  `macOS <https://github.com/giampaolo/psutil/blob/d40164f1/psutil/arch/osx/heap.c>`__:
+   uses malloc zone statistics.
+-  `BSD <https://github.com/giampaolo/psutil/blob/d40164f1/psutil/arch/bsd/heap.c>`__:
+   uses jemalloc's arena and stats interfaces.
+
+References
+----------
+
+-  `psleak <https://github.com/giampaolo/psleak>`__, the new memory leak
+   testing framework.
+-  :pr:`2692`, the implementation.
+-  :gh:`1275`, the original proposal from 8 years earlier.
+
+Discussion
+----------
+
+-  `Reddit <https://www.reddit.com/r/Python/comments/1puqgfg/detect_memory_leaks_of_c_extensions_with_psutil/>`__
+-  `Hacker News <https://news.ycombinator.com/item?id=46376608>`__
+-  `Medium <https://medium.com/@g.rodola/detect-memory-leaks-of-c-extensions-with-psutil-and-psleak-a0521ba6315f>`__
diff --git a/docs/blog/2025/speedup-pytest-startup.rst b/docs/blog/2025/speedup-pytest-startup.rst
new file mode 100644
index 0000000000..1b6b639dfe
--- /dev/null
+++ b/docs/blog/2025/speedup-pytest-startup.rst
@@ -0,0 +1,211 @@
+.. post:: 2025-04-04
+   :tags: tests, performance
+   :author: Giampaolo Rodola
+   :exclude:
+
+   Trimming heavy imports and plugins: 0.42s → 0.30s (~28%)
+
+Speeding up pytest startup
+==========================
+
+Preface: the migration to pytest
+--------------------------------
+
+Last year, after 17 years of :mod:`unittest`, I started adopting pytest in
+psutil (see :gh:`2446`). The two advantages I cared about most were plain
+``assert`` statements and
+`pytest-xdist <https://pypi.org/project/pytest-xdist/>`__'s free parallelism.
+Tests still inherit from :class:`unittest.TestCase` and there's no
+``conftest.py`` or fixture use (rationale in :pr:`2456`).
+
+What I want to focus on here is one of pytest's most frustrating aspects: slow
+startup.
+
+pytest invocation is slow
+-------------------------
+
+To measure pytest's startup time, let's run a very `simple
+test <https://github.com/giampaolo/psutil/blob/265fcf94a5da4260beb514653a2124915bf2a4f2/psutil/tests/test_misc.py#L232-L236>`__
+where execution time itself is negligible:
+
+.. code-block:: text
+
+   $ time python3 -m pytest psutil/tests/test_misc.py::TestMisc::test_version
+   1 passed in 0.05s
+   real    0m0,427s
+
+Almost half a second, which is excessive for something I run repeatedly during
+development. For comparison, the same test under :mod:`unittest`:
+
+.. code-block:: text
+
+   $ time python3 -m unittest psutil.tests.test_misc.TestMisc.test_version
+   Ran 1 test in 0.000s
+   real    0m0,204s
+
+Roughly twice as fast. Why?
+
+Where is time being spent?
+--------------------------
+
+A significant portion of pytest's overhead comes from import time, and there's
+not much one can do about it:
+
+.. code-block:: text
+
+   $ time python3 -c "import pytest"
+   real    0m0,151s
+
+   $ time python3 -c "import unittest"
+   real    0m0,065s
+
+   $ time python3 -c "import psutil"
+   real    0m0,056s
+
+Disable plugin auto loading
+---------------------------
+
+After some research, I discovered that pytest automatically loads all plugins
+installed on the system, even if they aren't used. Here's how to list them
+(output is cut):
+
+.. code-block:: text
+
+   $ pytest --trace-config --collect-only
+   ...
+   active plugins:
+       ...
+       setupplan           : ~/.local/lib/python3.12/site-packages/_pytest/setupplan.py
+       stepwise            : ~/.local/lib/python3.12/site-packages/_pytest/stepwise.py
+       warnings            : ~/.local/lib/python3.12/site-packages/_pytest/warnings.py
+       logging             : ~/.local/lib/python3.12/site-packages/_pytest/logging.py
+       reports             : ~/.local/lib/python3.12/site-packages/_pytest/reports.py
+       python_path         : ~/.local/lib/python3.12/site-packages/_pytest/python_path.py
+       unraisableexception : ~/.local/lib/python3.12/site-packages/_pytest/unraisableexception.py
+       threadexception     : ~/.local/lib/python3.12/site-packages/_pytest/threadexception.py
+       faulthandler        : ~/.local/lib/python3.12/site-packages/_pytest/faulthandler.py
+       instafail           : ~/.local/lib/python3.12/site-packages/pytest_instafail.py
+       anyio               : ~/.local/lib/python3.12/site-packages/anyio/pytest_plugin.py
+       pytest_cov          : ~/.local/lib/python3.12/site-packages/pytest_cov/plugin.py
+       subtests            : ~/.local/lib/python3.12/site-packages/pytest_subtests/plugin.py
+       xdist               : ~/.local/lib/python3.12/site-packages/xdist/plugin.py
+       xdist.looponfail    : ~/.local/lib/python3.12/site-packages/xdist/looponfail.py
+       ...
+
+It turns out ``PYTEST_DISABLE_PLUGIN_AUTOLOAD`` environment variable can be
+used to disable them. By running
+``PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 pytest --trace-config --collect-only`` again
+I can see that the following plugins disappeared:
+
+.. code-block:: text
+
+   anyio
+   pytest_cov
+   pytest_instafail
+   pytest_subtests
+   xdist
+   xdist.looponfail
+
+Now let's run the test again with ``PYTEST_DISABLE_PLUGIN_AUTOLOAD``:
+
+.. code-block:: text
+
+   $ time PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3 -m pytest psutil/tests/test_misc.py::TestMisc::test_version
+   1 passed in 0.05s
+   real    0m0,285s
+
+We went from 0.427s to 0.285s, a ~40% improvement. Not bad. We now need to
+selectively enable only the plugins we actually use, via ``-p``. psutil uses
+``pytest-instafail`` and ``pytest-subtests`` (we'll deal with ``pytest-xdist``
+later):
+
+.. code-block:: text
+
+   $ time PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3 -m pytest -p instafail -p subtests ...
+   real    0m0,320s
+
+Time went back up to 0.320s. Quite a slowdown, but still better than the
+original 0.427s. Adding ``pytest-xdist``:
+
+.. code-block:: text
+
+   $ time PYTEST_DISABLE_PLUGIN_AUTOLOAD=1 python3 -m pytest -p instafail -p subtests -p xdist ...
+   real    0m0,369s
+
+0.369s. Not much, but still a pity to pay the price when NOT running tests in
+parallel.
+
+Handling pytest-xdist
+---------------------
+
+If we disable ``pytest-xdist`` psutil tests still run, but we get a warning:
+
+.. code-block:: text
+
+   psutil/tests/test_testutils.py:367
+     ~/svn/psutil/psutil/tests/test_testutils.py:367: PytestUnknownMarkWarning: Unknown pytest.mark.xdist_group - is this a typo?  You can register custom marks to avoid this warning - for details, see https://docs.pytest.org/en/stable/how-to/mark.html
+       @pytest.mark.xdist_group(name="serial")
+
+This warning appears for methods that are intended to run serially, those
+decorated with ``@pytest.mark.xdist_group(name="serial")``. However, since
+``pytest-xdist`` is now disabled, the decorator no longer exists. To address
+this, I implemented the following solution in ``psutil/tests/__init__.py``:
+
+.. code-block:: python
+
+   import pytest, functools
+
+   PYTEST_PARALLEL = "PYTEST_XDIST_WORKER" in os.environ  # True if running parallel tests
+
+   if not PYTEST_PARALLEL:
+       def fake_xdist_group(*_args, **_kwargs):
+           """Mimics `@pytest.mark.xdist_group` decorator. No-op: it just
+           calls the test method or return the decorated class."""
+           def wrapper(obj):
+               @functools.wraps(obj)
+               def inner(*args, **kwargs):
+                   return obj(*args, **kwargs)
+
+               return obj if isinstance(obj, type) else inner
+
+           return wrapper
+
+       pytest.mark.xdist_group = fake_xdist_group  # monkey patch
+
+With this in place the warning disappears when running tests serially. To run
+tests in parallel, we'll manually enable ``xdist``:
+
+.. code-block:: text
+
+   $ python3 -m pytest -p xdist -n auto --dist loadgroup
+
+Optimizing test collection time
+-------------------------------
+
+By default, pytest searches the entire directory for tests, adding unnecessary
+overhead. In ``pyproject.toml`` you can tell pytest where test files are
+located, and only to consider ``test_*.py`` files:
+
+.. code-block:: toml
+
+   [tool.pytest.ini_options]
+   testpaths = ["psutil/tests/"]
+   python_files = ["test_*.py"]
+
+Collection time dropped from 0.20s to 0.17s, another ~0.03s shaved off.
+
+Putting it all together
+-----------------------
+
+With these small optimizations, I managed to reduce ``pytest`` startup time by
+~0.12 seconds, bringing it down from 0.42 seconds. While this improvement is
+insignificant for full test runs, it makes a noticeable difference (~28%
+faster) when repeatedly running individual tests from the command line, which
+is something I do frequently during development. Final result is visible in
+:pr:`2538`.
+
+Other links which may be useful
+-------------------------------
+
+-  https://github.com/zupo/awesome-pytest-speedup
+-  https://projects.gentoo.org/python/guide/pytest.html
diff --git a/docs/blog/2025/wheels-for-free-threaded-python.rst b/docs/blog/2025/wheels-for-free-threaded-python.rst
new file mode 100644
index 0000000000..17800c16ad
--- /dev/null
+++ b/docs/blog/2025/wheels-for-free-threaded-python.rst
@@ -0,0 +1,102 @@
+.. post:: 2025-10-25
+   :tags: wheels, community, python-core
+   :author: Giampaolo Rodola
+   :exclude:
+
+   Unlocking ``pip install psutil`` for no-GIL Python
+
+Wheels for free-threaded Python now available
+=============================================
+
+With the release of psutil 7.1.2, wheels for free-threaded Python are now
+available. This milestone was achieved largely through a community effort, as
+several internal refactorings to the C code were required to make it possible
+(see :gh:`2565`). Many of these changes were contributed by
+`Lysandros Nikolaou <https://github.com/lysnikolaou>`__. Thanks to him for the
+effort and for bearing with me in code reviews! ;-)
+
+What is free-threaded Python?
+-----------------------------
+
+Free-threaded Python (available since Python 3.13) refers to Python builds that
+are compiled with the **GIL (Global Interpreter Lock) disabled**, allowing true
+parallel execution of Python bytecodes across multiple threads. This is
+particularly beneficial for CPU-bound applications, as it enables better
+utilization of multi-core processors.
+
+The state of free-threaded wheels
+---------------------------------
+
+According to Hugo van Kemenade's `free-threaded wheels
+tracker <https://hugovk.github.io/free-threaded-wheels/>`__, the
+adoption of free-threaded wheels among the top 360 most-downloaded
+PyPI packages with C extensions is still limited. Only 128 out of
+these 360 packages provide wheels compiled for free-threaded Python,
+meaning they can run on Python builds with the GIL disabled. This shows
+that, while progress has been made, most popular packages with C
+extensions still do not offer ready-made wheels for free-threaded
+Python.
+
+What it means for users
+-----------------------
+
+When a library author provides a wheel, users can install a pre-compiled binary
+package without having to build it from source. This is especially important
+for packages with C extensions, like psutil, which is largely written in C.
+Such packages often have complex build requirements and require installing a C
+compiler. On Windows, that means installing Visual Studio or the Build Tools,
+which can take several gigabytes and a *significant* setup effort. Providing
+wheels spares users from this hassle, makes installation far simpler, and is
+effectively essential for the users of that package. You basically
+``pip install psutil`` and you're done.
+
+What it means for library authors
+---------------------------------
+
+Currently, **universal wheels for free-threaded Python do not exist**. Each
+wheel must be built specifically for a Python version. Right now authors must
+create separate wheels for Python 3.13 and 3.14. Which means distributing
+*a lot* of files already:
+
+.. code-block:: none
+
+   psutil-7.1.2-cp313-cp313t-macosx_10_13_x86_64.whl
+   psutil-7.1.2-cp313-cp313t-macosx_11_0_arm64.whl
+   psutil-7.1.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl
+   psutil-7.1.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl
+   psutil-7.1.2-cp313-cp313t-win_amd64.whl
+   psutil-7.1.2-cp313-cp313t-win_arm64.whl
+   psutil-7.1.2-cp314-cp314t-macosx_10_15_x86_64.whl
+   psutil-7.1.2-cp314-cp314t-macosx_11_0_arm64.whl
+   psutil-7.1.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl
+   psutil-7.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl
+   psutil-7.1.2-cp314-cp314t-win_amd64.whl
+   psutil-7.1.2-cp314-cp314t-win_arm64.whl
+
+This also multiplies CI jobs and slows down the test matrix (see
+`build.yml <https://github.com/giampaolo/psutil/blob/7dfd0ed34fe70ffd879ae62d21aabd4a8ed06d6f/.github/workflows/build.yml>`__).
+A true universal wheel would greatly reduce this overhead, allowing a single
+wheel to support multiple Python versions and platforms. Hopefully, Python 3.15
+will simplify this process. Two competing proposals,
+`PEP 803 <https://www.python.org/dev/peps/pep-0803/>`__ and
+`PEP 809 <https://www.python.org/dev/peps/pep-0809/>`__, aim to standardize
+wheel naming and metadata to allow producing a single wheel that covers
+multiple Python versions. That would drastically reduce distribution complexity
+for library authors, and it's fair to say it's essential for free-threaded
+CPython to truly succeed.
+
+How to install free-threaded psutil
+-----------------------------------
+
+You can now install psutil for free-threaded Python directly via ``pip``:
+
+.. code-block:: bash
+
+   pip install psutil --only-binary=:all:
+
+This ensures you get the pre-compiled wheels without triggering a source build.
+
+Discussion
+----------
+
+-  `Reddit <https://www.reddit.com/r/Python/comments/1ofrx8v/comment/nllztz6/>`__
diff --git a/docs/blog/2026/event-driven-process-waiting.rst b/docs/blog/2026/event-driven-process-waiting.rst
new file mode 100644
index 0000000000..d1d242c024
--- /dev/null
+++ b/docs/blog/2026/event-driven-process-waiting.rst
@@ -0,0 +1,261 @@
+.. post:: 2026-01-28
+   :tags: python-core, performance, featured
+   :author: Giampaolo Rodola
+   :exclude:
+
+   Replacing :meth:`subprocess.Popen.wait`'s busy-loop with an event-driven model, in psutil then upstream CPython
+
+From Python 3.3 to today: ending 15 years of subprocess polling
+===============================================================
+
+One of the less fun aspects of process management on POSIX systems is waiting
+for a process to terminate. The standard library's :mod:`subprocess` module has
+relied on a busy-loop polling approach since the *timeout* parameter was added
+to :meth:`subprocess.Popen.wait` in Python 3.3, around 15 years ago (see
+`source <https://github.com/python/cpython/blob/8def603d853c7f5e4ff57f95de289f99e1943669/Lib/subprocess.py#L2056-L2077>`__).
+And psutil's :meth:`Process.wait` method uses exactly the same technique (see
+`source <https://github.com/giampaolo/psutil/blob/700b7e6a/psutil/_psposix.py#L95-L160>`__).
+
+The logic is straightforward: check whether the process has exited using
+non-blocking ``waitpid(WNOHANG)``, sleep briefly, check again, sleep a bit
+longer, and so on.
+
+.. code-block:: python
+
+   import os, time
+
+   def wait_busy(pid, timeout):
+       end = time.monotonic() + timeout
+       interval = 0.0001
+       while time.monotonic() < end:
+           pid_done, _ = os.waitpid(pid, os.WNOHANG)
+           if pid_done:
+               return
+           time.sleep(interval)
+           interval = min(interval * 2, 0.04)
+       raise TimeoutExpired
+
+In this blog post I'll show how I finally addressed this long-standing
+inefficiency, first in psutil, and most excitingly, directly in CPython's
+standard library :mod:`subprocess` module.
+
+The problem with busy-polling
+-----------------------------
+
+- CPU wake-ups: even with exponential backoff (starting at 0.1ms, capping at
+  40ms), the system constantly wakes up to check process status, wasting CPU
+  cycles and draining batteries.
+- Latency: there's always a gap between when a process actually terminates and
+  when you detect it.
+- Scalability: monitoring many processes simultaneously magnifies all of the
+  above.
+
+Event-driven waiting
+--------------------
+
+All POSIX systems provide at least one mechanism to be notified when a file
+descriptor becomes ready. These are :manpage:`select(2)`, :manpage:`poll(2)`,
+:manpage:`epoll(7)` (Linux) and
+`kqueue() <https://man.freebsd.org/cgi/man.cgi?query=kqueue>`__ (BSD / macOS)
+system calls. Until recently, I believed they could only be used with file
+descriptors referencing sockets, pipes, etc., but it turns out they can also be
+used to wait for events on process PIDs!
+
+Linux
+-----
+
+In 2019, Linux 5.3 introduced a new syscall, :func:`os.pidfd_open`, which was
+added in Python 3.9. It returns a :term:`file descriptor` referencing a process
+PID. The interesting thing is that :manpage:`pidfd_open(2)` can be used in
+conjunction with :manpage:`select(2)`, :manpage:`poll(2)` or
+:manpage:`epoll(7)` to effectively wait until the process exits. E.g. by using
+``poll()``:
+
+.. code-block:: python
+
+   import os, select
+
+   def wait_pidfd(pid, timeout):
+       pidfd = os.pidfd_open(pid)
+       poller = select.poll()
+       poller.register(pidfd, select.POLLIN)
+       # block until process exits or timeout occurs
+       events = poller.poll(timeout * 1000)
+       if events:
+           return
+       raise TimeoutError
+
+This approach has zero busy-looping. The kernel wakes us up exactly when the
+process terminates or when the timeout expires if the PID is still alive.
+
+I chose ``poll()`` over ``select()`` because ``select()`` has a historical file
+descriptor limit (``FD_SETSIZE``), which typically caps it at 1024
+:term:`file descriptors <file descriptor>` per-process (reminded me of
+:bpo:`1685000`).
+
+I chose ``poll()`` over ``epoll()`` because it does not require creating an
+additional :term:`file descriptor`. It also needs only a single syscall, which
+should make it a bit more efficient when monitoring a single FD rather than
+many.
+
+macOS and BSD
+-------------
+
+BSD-derived systems (including macOS) provide the ``kqueue()`` syscall. It's
+conceptually similar to ``select()``, ``poll()`` and ``epoll()``, but more
+powerful (e.g. it can also handle regular files). ``kqueue()`` can be passed a
+PID directly, and it will return once the PID disappears or the timeout
+expires:
+
+.. code-block:: python
+
+   import select
+
+   def wait_kqueue(pid, timeout):
+       kq = select.kqueue()
+       kev = select.kevent(
+           pid,
+           filter=select.KQ_FILTER_PROC,
+           flags=select.KQ_EV_ADD | select.KQ_EV_ONESHOT,
+           fflags=select.KQ_NOTE_EXIT,
+       )
+       # block until process exits or timeout occurs
+       events = kq.control([kev], 1, timeout)
+       if events:
+           return
+       raise TimeoutError
+
+Windows
+-------
+
+Windows does not busy-loop, both in psutil and :mod:`subprocess` module, thanks
+to ``WaitForSingleObject``. This means Windows has effectively had event-driven
+process waiting from the start. So nothing to do on that front.
+
+Graceful fallbacks
+------------------
+
+Both ``pidfd_open()`` and ``kqueue()`` can fail for different reasons. For
+example, with ``EMFILE`` if the process runs out of
+:term:`file descriptors <file descriptor>` (usually 1024), or with ``EACCES`` /
+``EPERM`` if the syscall was explicitly blocked at the system level by the
+sysadmin (e.g. via SECCOMP). In all cases, psutil silently falls back to the
+traditional busy-loop polling approach rather than raising an exception.
+
+This fast-path-with-fallback approach is similar in spirit to :bpo:`33671`,
+where I sped up :func:`shutil.copyfile` by using zero-copy system calls back in
+2018. In there, more efficient :func:`os.sendfile` is attempted first, and if
+it fails (e.g. on network filesystems) we fall back to the traditional
+:manpage:`read(2)` / :manpage:`write(2)` approach to copy regular files.
+
+Measurement
+-----------
+
+As a simple experiment, here's a simple program which waits on itself for 10
+seconds without terminating:
+
+.. code-block:: python
+
+   # test.py
+   import psutil, os
+   try:
+       psutil.Process(os.getpid()).wait(timeout=10)
+   except psutil.TimeoutExpired:
+       pass
+
+We can measure the CPU context switching using ``/usr/bin/time -v``. Before the
+patch (the busy-loop):
+
+::
+
+   $ /usr/bin/time -v python3 test.py 2>&1 | grep context
+       Voluntary context switches: 258
+       Involuntary context switches: 4
+
+After the patch (the event-driven approach):
+
+::
+
+   $ /usr/bin/time -v python3 test.py 2>&1 | grep context
+       Voluntary context switches: 2
+       Involuntary context switches: 1
+
+This shows that instead of spinning in userspace, the process blocks in
+``poll()`` / ``kqueue()``, and is woken up only when the kernel notifies it,
+resulting in just a few CPU :term:`context switches <context switch>`.
+
+Sleeping state
+--------------
+
+It's also interesting to note that waiting via ``poll()`` (or ``kqueue()``)
+puts the process into the exact same sleeping state as a plain
+:func:`time.sleep` call. From the kernel's perspective, both are interruptible
+sleeps: the process is de-scheduled, consumes zero CPU, and sits quietly in
+kernel space.
+
+The ``"S+"`` state shown below by ``ps`` means that the process “sleeps in
+foreground�.
+
+-  :func:`time.sleep`:
+
+::
+
+   $ (python3 -c 'import time; time.sleep(10)' & pid=$!; sleep 0.3; ps -o pid,stat,comm -p $pid) && fg &>/dev/null
+       PID STAT COMMAND
+    491573 S+   python3
+
+-  :func:`select.poll`:
+
+::
+
+   $ (python3 -c 'import os,select; fd = os.pidfd_open(os.getpid(),0); p = select.poll(); p.register(fd,select.POLLIN); p.poll(10_000)' & pid=$!; sleep 0.3; ps -o pid,stat,comm -p $pid) && fg &>/dev/null
+       PID STAT COMMAND
+    491748 S+   python3
+
+CPython contribution
+--------------------
+
+After landing the psutil implementation (:pr:`2706`), I took the extra step and
+submitted a matching pull request for CPython :mod:`subprocess` module:
+:cpy-pr:`144047`.
+
+I'm especially proud of this one: this is the **third time** in psutil's 17+
+year history that a feature developed in psutil made its way upstream into the
+Python standard library.
+
+-  The first was back in 2010, when :meth:`Process.nice` inspired
+   :func:`os.getpriority` and :func:`os.setpriority`, see :bpo:`10784`. Landed
+   in Python 3.3.
+
+-  The second was back in 2011, when :func:`psutil.disk_usage` inspired
+   :func:`shutil.disk_usage`, see `python-ideas ML
+   proposal <https://mail.python.org/archives/list/python-ideas@python.org/thread/67A7ML2TJ7MBS3WOL6IZKLD2C3B3VCQG>`__.
+   Landed in Python 3.3.
+
+*Funny thing:* 15 years ago, Python 3.3 added the *timeout* parameter to
+:meth:`subprocess.Popen.wait` (see
+`commit <https://github.com/python/cpython/commit/31aa7dd1419>`__). That's
+probably where I took inspiration when I first added the *timeout* parameter to
+psutil's :meth:`Process.wait` around the same time (see :commit:`886710daf`).
+Now, 15 years later, I'm contributing back a similar improvement for that very
+same *timeout* parameter. **The circle is complete**.
+
+Links
+-----
+
+Topics related to this:
+
+-  :gh:`2712`: proposal to extend this to multiple PIDs
+   (:func:`psutil.wait_procs`).
+-  :gh:`2703`: proposal for asynchronous :meth:`Process.wait` integration with
+   :mod:`asyncio`.
+-  :cpy:`144211`: proposal to extend the :mod:`selectors` module to enable
+   :mod:`asyncio` optimization on BSD / macOS via ``kqueue()``.
+
+Discussion
+----------
+
+-  `Reddit <https://www.reddit.com/r/Python/comments/1qpp42k/from_python_33_to_today_ending_15_years_of/>`__
+-  `Hacker News <https://news.ycombinator.com/item?id=46802061>`__
+-  `Medium <https://medium.com/@g.rodola/from-python-3-3-to-today-ending-15-years-of-subprocess-polling-e8a83ba17c86>`__
+-  `Linkedin <https://www.linkedin.com/feed/update/urn:li:share:7422396026449391616/>`__
diff --git a/docs/changelog.rst b/docs/changelog.rst
new file mode 100644
index 0000000000..6a2f0a7dbb
--- /dev/null
+++ b/docs/changelog.rst
@@ -0,0 +1,3625 @@
+..
+   Sections a release can use, in this order. In brackets is the GitHub
+   label each maps to.
+
+   - New APIs [new-api]: a new function, argument or field, or an existing
+     one now working where it didn't.
+   - New platforms [new-platform]: an OS, architecture or interpreter.
+   - API changes [api-change]: an API changed, was deprecated or removed.
+   - Performance [performance]: something got faster.
+   - Build and packaging [packaging]: wheels, sdist, what gets installed.
+   - Documentation [doc]: docs/ only.
+   - Internals [internals, ci, tests, scripts]: psutil's own machinery,
+     debug output included. Nothing user-facing.
+   - Dropped support [dropped-support]: a platform, OS or Python version.
+   - Bug fixes [bug]: crashes, wrong results, leaks, build failures.
+
+   Format: ``- :gh:`N`, [Platform], :label:`name`: text.`` Labels are
+   ``breaking``, ``critical``, ``build-fail`` and ``memleak``, from the
+   compatibility, critical, build-fail and memleak labels on the tracker.
+   Platform tags come from the platform labels.
+
+   8.0.0 splits Bug fixes per platform, and has its own Other API changes
+   and Type hints and enums sections.
+
+Changelog
+=========
+
+8.0.0 (IN DEVELOPMENT)
+^^^^^^^^^^^^^^^^^^^^^^
+
+.. note::
+   psutil 8.0 introduces breaking API changes. See the
+   :ref:`migration guide <migration-8.0>` if upgrading from 7.x.
+
+**New APIs**
+
+- :gh:`2798`, :label:`breaking`: new :attr:`Process.attrs` class attribute, a
+  :class:`frozenset` of the attribute names accepted by :meth:`Process.as_dict`
+  and :func:`process_iter`. Passing ``attrs=[]`` to :func:`process_iter` to
+  mean "retrieve all attributes" is deprecated. See
+  :ref:`migration guide <migration-8.0-attrs>`.
+- :gh:`2776`, [Windows], :label:`breaking`: :func:`virtual_memory` now includes
+  :field:`cached` and :field:`wired` fields.
+- :gh:`1541`: New :meth:`Process.page_faults` method, returning a
+  ``(minor, major)`` named tuple.
+- :gh:`2780`, [Windows]: :func:`disk_usage` now can accept a file path (not
+  only a directory path).
+- :gh:`2816`, [OpenBSD]: :func:`swap_memory` :field:`sin` and :field:`sout` are
+  no longer set to ``0``.
+- :gh:`2977`: new :func:`bytes2human` utility function, converting a number of
+  bytes to a human-readable string (e.g. ``9.8K``).
+
+Reorganization of process memory APIs (:gh:`2731`, :gh:`2736`, :gh:`2723`,
+:gh:`2733`, :gh:`2988`).
+
+- New :meth:`Process.memory_extras` method, returning extra platform-specific
+  memory metrics on Linux, macOS and Windows. See
+  :ref:`migration guide <migration-8.0-memory-extras>`.
+
+- New :meth:`Process.memory_footprint` method, which returns :field:`uss`,
+  :field:`pss` and :field:`swap` metrics (what :meth:`Process.memory_full_info`
+  used to return).
+
+- :label:`breaking`: :meth:`Process.memory_full_info` is deprecated. Use the
+  new :meth:`Process.memory_footprint` instead. See
+  :ref:`migration guide <migration-8.0-memory-full-info>`.
+
+- :label:`breaking`: :meth:`Process.memory_info` named tuple changed on all
+  platforms: fields were added, removed and renamed. Most old names still work
+  but raise :exc:`DeprecationWarning`; on macOS :field:`pfaults` and
+  :field:`pageins` were removed with **no backward-compatible aliases**, use
+  :meth:`Process.page_faults` instead. See
+  :ref:`migration guide <migration-8.0-namedtuples>`.
+
+**Type hints and enums**
+
+- :gh:`2753`, :label:`breaking`: Introduce enum classes
+  (:class:`ProcessStatus`, :class:`ConnectionStatus`,
+  :class:`ProcessIOPriority`, :class:`ProcessPriority`, :class:`ProcessRlimit`)
+  grouping related constants. The top-level constants (e.g.
+  :data:`STATUS_RUNNING`) remain the primary API, and are now aliases for the
+  corresponding enum members. See :ref:`migration guide <migration-8.0-enums>`.
+- :gh:`1946`: Add inline type hints to all public APIs in
+  ``psutil/__init__.py``. Editors and checkers that read inline annotations
+  (pyright, Pylance) pick them up automatically. mypy ignores them until we
+  ship a ``py.typed`` marker, so it still relies on the third-party
+  ``types-psutil`` stubs. No runtime behavior is changed.
+- :gh:`2751`: Convert all named tuples from :func:`collections.namedtuple` to
+  :class:`typing.NamedTuple` classes with **type annotations**. This makes the
+  classes self-documenting, effectively turning this module into a readable API
+  reference.
+
+**Other API changes**
+
+- :gh:`2747`, :label:`breaking`: the field order of the named tuple returned by
+  :func:`cpu_times` has been normalized on all platforms, and the first 3
+  fields are now always :field:`user`, :field:`system`, :field:`idle`. See
+  :ref:`migration guide <migration-8.0-namedtuples>`.
+- :gh:`2772`, [Windows], :label:`breaking`: :func:`cpu_times`
+  :field:`interrupt` field renamed to :field:`irq` to match the field name used
+  on Linux and BSD. :field:`interrupt` still works but raises
+  :exc:`DeprecationWarning`.
+- :gh:`2784`, :label:`breaking`: :func:`process_iter`: when *attrs* is
+  specified, the pre-fetched values are now cached on the :class:`Process`
+  instance, so subsequent method calls return them without new system calls.
+  The ``p.info`` dict is deprecated. See
+  :ref:`migration guide <migration-8.0-process-iter>`.
+- :gh:`2889`, [Windows], :label:`breaking`: 32-bit psutil can no longer inspect
+  64-bit processes. This relied on the undocumented ``NtWow64*`` APIs and
+  stopped being tested when 32-bit wheels were dropped in 7.1.2 (:gh:`2657`).
+  :meth:`Process.cwd` now raises :exc:`AccessDenied` in that case;
+  :meth:`Process.cmdline` and :meth:`Process.environ` are unaffected. The
+  opposite direction (64-bit psutil inspecting 32-bit processes) still works.
+- :gh:`2754`: standardize :func:`sensors_battery`'s :field:`percent` so that it
+  returns a ``float`` instead of ``int`` on all systems, not only Linux.
+- :gh:`2799`: :meth:`Process.as_dict` now returns a dict with keys sorted
+  alphabetically when *attrs* is not specified.
+- :gh:`2805`, [BSD]: remove ``procfs`` dependency on NetBSD for
+  :func:`cpu_stats` and :func:`virtual_memory`; values are now retrieved via
+  the ``sysctl(9)`` and ``uvm(9)`` kernel APIs instead. (patch by
+  :user:`Santhosh Raju <fraggerfox>`)
+- :gh:`2947`: psutil now emits a ``RuntimeWarning`` when it returns incomplete
+  or approximated results due to an unexpected condition (e.g. a sanity check
+  on kernel data which failed). Before, these events were only visible by
+  enabling debug mode via the :envvar:`PSUTIL_DEBUG` environment variable, so
+  in practice they went unnoticed.
+
+**Performance**
+
+- :gh:`2695`, [Windows]: :func:`net_io_counters` is **~5x faster**.
+  ``GetAdaptersAddresses()`` is now invoked once instead of twice, and it skips
+  collecting unicast / anycast / multicast / DNS details, which were retrieved
+  but never used. :func:`net_if_stats` and :func:`net_if_addrs` also got
+  faster. (patch by :user:`Arman Luthra <Arman-Luthra>`)
+- :gh:`2919`, :gh:`2920`, [Windows]: :meth:`Process.threads` is around
+  **25x faster**, :meth:`Process.ppid` and :meth:`Process.children` around
+  3.5x. They no longer snapshot every thread / process on the system with
+  ``CreateToolhelp32Snapshot``, and read
+  ``NtQuerySystemInformation(SystemProcessInformation)`` in one shot instead.
+  As a side effect :meth:`Process.threads` no longer silently misses the
+  threads which could not be opened due to :exc:`AccessDenied`.
+- :gh:`2922`, [Windows]: :meth:`Process.ppid` is around **58x faster** (**99x**
+  on ARM64). Instead of fetching the whole process table to read one field, the
+  parent PID is now read from
+  ``NtQueryInformationProcess(ProcessBasicInformation)``.
+- :gh:`2923`, [Windows]: :meth:`Process.status` is now part of the
+  :meth:`Process.oneshot` group, so within that context (also used by
+  :meth:`Process.as_dict`) it no longer costs an extra system-wide query.
+  Reading 4 methods of that group in one :meth:`Process.oneshot` block is now
+  around **3.9x faster** than reading them without it, up from 2x.
+- :gh:`2932`, [Windows]: :meth:`Process.open_files` is **140x to 400x faster**
+  (from 235 ms to 0.39 ms per call). It no longer enumerates every handle in
+  the system with
+  ``NtQuerySystemInformation(SystemExtendedHandleInformation)``, but
+  per-process, via ``NtQueryInformationProcess(ProcessHandleInformation)``, and
+  the ones which are not files are skipped by object type index, before being
+  duplicated. Also, the internal thread used to query handle names is now
+  created once per call instead of once per handle.
+- :gh:`2939`: syscalls which can potentially block (disk devices, mount points,
+  NIC drivers, etc) now release the GIL. Before, a slow psutil call would
+  freeze all the other threads of the application for its whole duration.
+
+**Build and packaging**
+
+- :gh:`2976`, [Linux]: publish ppc64le and s390x wheels.
+- :gh:`2788`, :label:`breaking`: git tags renamed from ``release-X.Y.Z`` to
+  ``vX.Y.Z``. Old tags are kept for backward compatibility. See
+  :ref:`migration guide <migration-8.0-git-tags>`.
+- :gh:`2914`, [macOS], :label:`breaking`: Intel wheels now require macOS 10.15
+  (Catalina) or higher, up from 10.9. Older versions account for 0.01% of macOS
+  downloads, and they must now build from source. ``arm64`` wheels are
+  unaffected: they already required macOS 11.
+- :gh:`2915`, :label:`breaking`: stop publishing wheels for free-threaded
+  CPython 3.13 (``cp313t``). Free-threading was experimental in 3.13 and is
+  officially not recommended. Publish only ``cp314t`` wheels.
+- :gh:`2576`: the C extension modules now use PEP 489 multi-phase
+  initialization instead of single-phase, which is the preferred mechanism for
+  extension modules. Runtime behavior is unchanged.
+- :gh:`2765`: add a PR bot that uses Claude to summarize PR changes and update
+  ``changelog.rst`` and ``credits.rst`` when commenting with /changelog.
+- :gh:`2766`: remove remaining Python 2.7 compatibility shims from
+  ``setup.py``, simplifying the build infrastructure.
+- :gh:`2844`: removed docs/ from tarball. Tarball before: 586K. Tarball now:
+  396K.
+- :gh:`2883`: the platform-specific C extension modules (``_psutil_linux``,
+  ``_psutil_windows``, etc.) are now built as a single private module named
+  ``_psutil`` on all platforms.
+- :gh:`2909`: ``setup.py`` no longer uses ``distutils``, which was removed from
+  the stdlib in Python 3.12, and only relies on ``setuptools``.
+- :gh:`2925`: the C sources are now compiled in parallel, making builds
+  **2x to 3.6x faster**. This mostly benefits the platforms getting no wheels
+  from PyPI (\*BSD, Solaris, AIX), where ``pip install psutil`` always
+  compiles. Use :envvar:`PSUTIL_BUILD_JOBS` to cap the number of jobs.
+- :gh:`2927`: python dependencies (``make install-pydeps-*``) are now installed
+  with ``uv`` when available, saving around 10 secs for each CI run.
+
+**Documentation**
+
+- :gh:`2757`, :gh:`2760`: split docs from a single HTML file into multiple new
+  sections: :doc:`/about <about>`, :doc:`/adoption <adoption>` (:gh:`2763`),
+  :doc:`/alternatives <alternatives>` (:gh:`2775`),
+  :doc:`/api-overview <api-overview>`, :doc:`/credits <credits>` (:gh:`2764`),
+  :doc:`/faq <faq>` (:gh:`2769`), :doc:`/funding <funding>` (:gh:`2797`),
+  :ref:`/genindex <genindex>` (:gh:`2808`), :doc:`/glossary <glossary>`
+  (:gh:`2774`), :doc:`/install <install>`, :doc:`/migration <migration>`
+  (:gh:`2771`), :doc:`/performance <performance>` (:gh:`2787`),
+  :doc:`/platform <platform>`, :doc:`/recipes <recipes>` (:gh:`2761`),
+  :doc:`/shell-equivalents <shell-equivalents>` (:gh:`2768`),
+  :doc:`/stdlib-equivalents <stdlib-equivalents>` (:gh:`2781`). The old
+  ``INSTALL.rst`` and ``CREDITS`` files, which lived in the root dir, moved
+  there as well.
+
+- Blog: new blog at :doc:`/blog <blog>` (:gh:`2825`), built via the
+  `ablog <https://ablog.readthedocs.io/>`__ Sphinx extension, with 20 posts
+  imported from https://gmpy.dev, covering psutil topics from 2014 to 2026.
+  Posts are searchable, have an Atom feed, use OpenGraph for a nice preview
+  when shared on social media, and have a comments section backed by
+  `giscus <https://giscus.app/>`__ and GitHub Discussions (:gh:`2879`).
+
+- Theming: renewed, modern, custom theme, with a top bar (:gh:`2819`), a
+  toggable dark theme (:gh:`2803`, ``Shift+D``), Monokai code snippets, a "last
+  updated" stamp in the footer and an icon marking external URLs.
+
+- Usability: right TOC sidebar (:gh:`2828`), a COPY button on code snippets
+  (:gh:`2761`), a "copy page" button copying the page's RsT source
+  (:gh:`2981`), a "back to top" button, the ``psutil.`` prefix shown for all
+  APIs, and search results styled as cards. Identifiers in code blocks (e.g.
+  ``psutil.Process()``, ``p.cpu_percent()``) are now clickable and link to
+  their API reference entry, via
+  `sphinx-codeautolink <https://sphinx-codeautolink.readthedocs.io/>`__
+  (:gh:`2826`). Doc clarity was improved and long sentences shortened
+  (:gh:`2745`, :gh:`2801`). New keyboard shortcuts (:gh:`2820`): ``?`` shows
+  the helper, ``Shift+D`` toggles dark/light mode, ``Ctrl+K`` focuses the
+  search box, ``Up``/``Down`` navigate the search results and ``Enter`` opens
+  the selected one.
+
+- Testing: ``rstcheck`` was replaced by ``sphinx-lint``, plus a custom script
+  detecting dead reference links in ``.rst`` files (:gh:`2767`). Python code
+  snippets are syntax-checked at build time (:gh:`2761`). New
+  ``make test-docs`` with sanity checks for the built HTML docs.
+
+- Hosting: doc is no longer hosted on Read the Docs. It's now self-hosted on
+  GitHub Pages under a new domain, https://psutil.io, and URLs no longer carry
+  the ``/en`` language and version prefixes, e.g. https://psutil.io/faq/
+  (:gh:`2790`). It's rebuilt and deployed automatically on every push to
+  ``master`` (:gh:`2739`). Past releases are also served, e.g.
+  https://psutil.io/7.2/, with a version selector in the top bar (:gh:`2980`).
+
+- Misc: doc is built as part of CI (fails on error), all ``.rst`` files are
+  wrapped to 79 characters via https://github.com/giampaolo/rstwrap
+  (:gh:`2823`), and ``/sitemap.xml`` was added to help search engine discovery.
+  New custom 404 page (:gh:`2829`): hovering over the © copyright in the footer
+  reveals an easter egg which takes you there.
+
+**Dropped support**
+
+- :gh:`2872`, :label:`breaking`: Dropped support for Python 3.6 and 3.7.
+  Minimum version is now 3.8.
+- :gh:`2893`, [Windows], :label:`breaking`: Dropped support for Windows Vista,
+  7, 8, 8.1 and their server counterparts. Minimum version is now Windows 10 /
+  Server 2016. See :ref:`migration guide <migration-8.0-windows>`.
+- :gh:`2936`, [Windows], :label:`breaking`: dropped support for PyPy older than
+  7.3.14 (December 2023).
+- :gh:`2987`, [macOS], :label:`breaking`: dropped support for macOS 10.7 and
+  10.8. Minimum version is now 10.9.
+
+**Bug fixes: cross-platform**
+
+- :gh:`2793`: :func:`process_iter` was silently dropping zombie processes
+  because :exc:`ZombieProcess` (a subclass of :exc:`NoSuchProcess`) was caught
+  by the wrong ``except`` clause. Zombie processes are now yielded correctly.
+- :gh:`2895`: :class:`Process` methods could wrongly raise :exc:`NoSuchProcess`
+  ("PID has been reused") when the process creation time could not be
+  determined, e.g. for zombies on NetBSD / OpenBSD or on :exc:`AccessDenied` on
+  Windows. An unknown creation time is no longer treated as proof of PID reuse.
+- :gh:`2899`: two :class:`Process` instances for the same process could compare
+  unequal if the creation time of either one could not be determined. They now
+  compare equal, and ``hash(Process)`` is based on the PID alone.
+
+**Bug fixes: Linux**
+
+- :gh:`2860`, :gh:`2966`, [Linux], :label:`critical`:
+  :meth:`Process.cpu_affinity` could crash the interpreter with a segfault when
+  ``PyLong_FromLong()`` returned NULL under memory pressure (the NULL is now
+  checked and a proper :exc:`MemoryError` is raised instead), and on Python <=
+  3.11 it over-decref'ed the CPU numbers it returned, corrupting CPython's
+  small integer cache.
+- :gh:`2857`, [Linux], [SunOS], :label:`memleak`: fix refcount leak in
+  ``disk_partitions()`` (Linux) and ``proc_environ()`` (SunOS) when
+  ``PyArg_ParseTuple`` fails: parse arguments before allocating the result
+  container, matching the pattern used in the other 26 call sites. Also fix a
+  copy-paste typo in SunOS ``proc_environ()`` where the post-decode NULL check
+  examined the wrong variable (``py_envname`` instead of ``py_envval``), which
+  could let a NULL value reach ``PyDict_SetItem``.
+- :gh:`2628`, [Linux]: :func:`cpu_freq` no longer takes offline CPU cores into
+  account. They were reported with all-zero frequencies, which dragged down the
+  average ``current``, ``min`` and ``max`` values.
+- :gh:`2715`, [Linux]: ``wait_pid_pidfd_open()`` (from :meth:`Process.wait`)
+  crashes with ``EINVAL`` due to kernel race condition.
+- :gh:`2732`, [Linux]: :func:`net_if_stats`: handle ``EBUSY`` from
+  ``ioctl(SIOCETHTOOL)``.
+- :gh:`2770`, [Linux]: fix :func:`cpu_count` (``logical=False``) raising
+  :exc:`ValueError` on s390x architecture, where :proc:`/proc/cpuinfo` uses
+  spaces before the colon separator instead of a tab.
+- :gh:`2809`, [Linux]: :func:`swap_memory` and :func:`virtual_memory` raise
+  ``ValueError`` if :proc:`/proc/meminfo` contains a field with no space after
+  the colon, e.g. ``ShadowCallStack:10373888 kB``, which occurs on arm64 when
+  shadow call stacks exceed 10 GB.
+- :gh:`2830`, [Linux], [macOS], [BSD]: :meth:`Process.terminal` returned
+  ``None`` for terminals opened after the first call, e.g. a new ``/dev/pts/N``
+  in a long running daemon. The list of terminal devices was cached forever,
+  and is now refreshed when it doesn't know a device.
+- :gh:`2871`, [Linux]: :meth:`Process.rlimit` returned ``RLIM_INFINITY`` as the
+  unsigned ``2**64-1`` instead of ``-1`` on Python 3.15+, which changed
+  ``resource.prlimit()`` accordingly. psutil now maps it back to
+  :data:`psutil.RLIM_INFINITY` so the value stays consistent across Python
+  versions.
+- :gh:`2967`, [Linux]: :func:`cpu_freq` returned ``None`` on ppc machines
+  without cpufreq sysfs. On s390x it matched both ``cpu MHz dynamic`` and
+  ``cpu MHz static``, reporting twice as many CPUs as the machine has.
+- :gh:`2512`, [Linux]: :func:`cpu_freq` with ``percpu=True`` returned one entry
+  per cpufreq policy instead of one per CPU, so on hardware where a policy is
+  shared by several CPUs (POWER9, Apple M1, RISC-V) it reported fewer entries
+  than :func:`cpu_count`. Each policy is now asked which CPUs it affects.
+  (patch by Julien Stephan)
+- :gh:`2611`: re-enable support for Android, which got broken on Python 3.13.
+  Also include a working :func:`disk_partitions` which no longer raises
+  ``PermissionError``.
+
+**Bug fixes: Windows**
+
+- :gh:`1967`, [Windows], :label:`critical`: :meth:`Process.open_files` could
+  deadlock the calling process. On timeout, the internal thread querying a
+  handle name was killed with ``TerminateThread()``, which cannot terminate a
+  thread blocked in the kernel (e.g. on a pipe with a pending read) and left
+  locks and memory in an inconsistent state. The thread is now abandoned and
+  cleans up after itself.
+- :gh:`2859`, [Windows], :label:`critical`: :func:`net_connections` /
+  :meth:`Process.net_connections` could crash with an invalid
+  ``Py_DECREF(NULL)`` when argument parsing failed before the result list was
+  allocated. The error path now uses ``Py_XDECREF`` (including the temporary
+  address-family / socket-type objects).
+- :gh:`2847`, [Windows], :label:`critical`: :func:`cpu_stats` read the context
+  switches and syscalls counts from a buffer it had just freed.
+- :gh:`2934`, [Windows], :label:`critical`: :meth:`Process.memory_maps` could
+  crash the calling process with a stack buffer overflow if the inspected
+  process had a mapped file whose path is longer than 260 characters. The
+  buffer size was passed to ``GetMappedFileNameW()`` in bytes instead of
+  characters. Also, such paths are now returned in full instead of truncated.
+- :gh:`2937`, [Windows], :label:`critical`: :func:`disk_io_counters` could let
+  a disk driver write past the end of the ``DISK_PERFORMANCE`` buffer. When the
+  driver asked for more space we retried passing a bigger size, but the buffer
+  was a fixed size struct on the stack. It is now allocated (and grown) on the
+  heap.
+- :gh:`2943`, [Windows], :label:`critical`: :func:`win_service_iter` could
+  crash the interpreter instead of raising an exception if the service
+  enumeration failed.
+- :gh:`2946`, [Windows], :label:`critical`: if the number of process heaps
+  changed while :func:`heap_info` was running, it could read uninitialized
+  memory and return bogus :field:`mmap_used` and :field:`heap_count` values.
+- :gh:`2972`, [Windows], :label:`critical`: on systems with more than 64 CPUs
+  :func:`cpu_times` with ``percpu=True`` and :func:`cpu_stats` read
+  uninitialized memory: the kernel only returns entries for the calling
+  thread's processor group, but the entries for the remaining CPUs were used as
+  well.
+- :gh:`2932`, [Windows], :label:`memleak`: :meth:`Process.open_files` leaked a
+  thread and a handle for every name query which timed out (e.g. a pipe with a
+  pending read), and could hang for around 1 minute if the process had a file
+  open on an unreachable network share, where the :func:`os.stat` used to
+  filter out directories went over the wire with no timeout.
+- :gh:`2935`, [Windows], :label:`memleak`: :meth:`Process.kill` and
+  :meth:`Process.terminate` leaked a process handle when ``TerminateProcess()``
+  failed with an error other than ``ERROR_ACCESS_DENIED``.
+- :gh:`1007`, [Windows]: :func:`boot_time` no longer fluctuates by ~1 second
+  across calls or across processes. It is now read atomically from the kernel
+  via ``NtQuerySystemInformation(SystemTimeOfDayInformation)``, replacing the
+  old ``time.time() - uptime()`` computation that sampled two counters from
+  Python and produced sub-second differences.
+- :gh:`1959`, [Windows]: :func:`disk_partitions` could raise
+  ``UnicodeDecodeError`` on systems whose ANSI code page is not UTF-8 (e.g.
+  cp1251). It now uses the wide-char Windows APIs throughout.
+- :gh:`2383`, [Windows]: :meth:`WindowsService.description` may fail with
+  ``ERROR_FILE_NOT_FOUND`` when the description points at a missing resource
+  (e.g. ``WaaSMedicSvc``), which also broke :meth:`WindowsService.as_dict`. Now
+  it returns an empty string instead.
+- :gh:`2655`, [Windows]: :func:`net_if_stats` returned ``4294967295`` (32-bit
+  overflow) as the speed for network interfaces faster than ~4.29 Gbps (e.g. 5
+  Gbps NICs). Fixed by switching from the legacy ``GetIfTable()`` /
+  ``MIB_IFROW`` API to ``GetIfEntry2()`` / ``MIB_IF_ROW2``, which uses a 64-bit
+  ``TransmitLinkSpeed`` field.
+- :gh:`2711`, :gh:`2940`, [Windows]: :func:`net_if_addrs` was returning
+  ``None`` for the ``broadcast`` field of network interfaces instead of the
+  correct broadcast address, and could report an IPv4 :field:`netmask` for an
+  IPv6 address of the same NIC (the netmask was reset once per interface
+  instead of once per address).
+- :gh:`2875`, [Windows]: :func:`sensors_battery` never returned
+  :data:`POWER_TIME_UNKNOWN` when the remaining battery time was unknown; it
+  returned ``4294967295`` instead of ``-1`` due to ``BatteryLifeTime`` being
+  passed as an unsigned integer.
+- :gh:`2938`, [Windows]: :func:`disk_partitions` returned a different
+  :field:`opts` string for volume mount points than for the drive they live on:
+  the drive type (``fixed``, ``cdrom``, ...) was missing.
+- :gh:`2941`, [Windows]: :func:`net_io_counters` raised :exc:`RuntimeError`,
+  losing the counters of all the other NICs, if a NIC was disabled or unplugged
+  mid-call. Now it's skipped.
+
+**Bug fixes: macOS**
+
+- :gh:`2885`, [macOS], :label:`critical`: :meth:`Process.memory_full_info`,
+  :meth:`Process.memory_footprint` and :meth:`Process.threads` no longer use
+  ``task_for_pid()`` syscall, which can hang forever on headless VMs (e.g. CI
+  runners). They now use ``proc_pidinfo()``, which is more permissive and so
+  raises :exc:`AccessDenied` less often.
+- :gh:`2382`, [macOS]: :func:`cpu_freq` is now always defined on ARM64 and
+  returns ``None`` when CPU frequency can't be determined. Previously it was
+  left undefined (or raised :exc:`RuntimeError`) when the ``pmgr`` IORegistry
+  entry or its frequency data was unavailable, e.g. on virtualized ARM64 like
+  CI runners.
+- :gh:`2411`, [macOS]: :meth:`Process.cpu_times` and
+  :meth:`Process.cpu_percent` calculation on macOS x86_64 (arm64 is fine) was
+  highly inaccurate (41.67x lower).
+- :gh:`2642`, [macOS]: fix :func:`cpu_freq` on Apple Silicon. On M4+ it
+  returned values ~1000x too small because the ``voltage-statesN-sram``
+  IORegistry tables switched from Hz to kHz; on M5-family chips it failed
+  because the hardcoded table indexes were renumbered. The implementation now
+  enumerates CPU ``voltage-states*-sram`` tables dynamically, detects the unit
+  per-value by magnitude, and filters CPU clusters from GPU/NPU tables via a
+  per-table fmax threshold. Works uniformly from M1 through M5 Max. (patch by
+  Bert Pluymers)
+- :gh:`2726`, [macOS]: :meth:`Process.num_ctx_switches` return an unusual high
+  number due to a C type precision issue.
+- :gh:`2841`, [macOS]: :func:`cpu_freq` could raise :exc:`SystemError` when CPU
+  frequency data is missing or invalid in the IORegistry (e.g. on Apple M5
+  chips). It now returns ``None`` instead (see :gh:`2382`).
+- :gh:`2853`, [macOS]: :func:`virtual_memory` and :func:`swap_memory` could
+  raise :exc:`RuntimeError` (``(ipc/mig) array not large enough``) on newer
+  macOS versions.
+- :gh:`2854`, [macOS]: :meth:`Process.cmdline` and :meth:`Process.environ`
+  could raise :exc:`SystemError` after ``sysctl(KERN_PROCARGS2)`` failed with
+  ``errno == 0``. They now raise :exc:`AccessDenied` instead.
+
+**Bug fixes: BSD**
+
+- :gh:`2744`, [NetBSD], :label:`critical`: fix possible double ``free()`` in
+  :func:`swap_memory`.
+- :gh:`2848`, [BSD], :label:`critical`: fix a stack buffer overflow in
+  :func:`net_io_counters` when the kernel reports an unusually long interface
+  name.
+- :gh:`1534`, [NetBSD]: :meth:`Process.exe` is now fetched natively via
+  ``sysctl(KERN_PROC_PATHNAME)`` instead of reading the ``/proc/pid/exe``
+  symlink (a virtualization layer on NetBSD). (patch by Kamil Rytarowski)
+- :gh:`1801`, [FreeBSD]: :func:`cpu_freq` could raise :exc:`UnicodeDecodeError`
+  when the ``dev.cpu.N.freq_levels`` sysctl returned bytes which are not valid
+  UTF-8.
+- :gh:`2746`, [FreeBSD]: :meth:`Process.memory_maps`, :field:`rss` and
+  :field:`private` fields are erroneously reported in memory pages instead of
+  bytes. Other platforms (Linux, macOS, Windows) return bytes.
+- :gh:`2782`, [FreeBSD]: :func:`cpu_count` ``logical=False`` return None on
+  systems without hyper threading.
+- :gh:`2791`, [FreeBSD]: relax ``psutil_sysctl()`` / ``psutil_sysctlbyname()``
+  to allow the kernel to return fewer bytes than the buffer (normal for
+  variable-length ``sysctl`` data).
+- :gh:`2795`, [FreeBSD]: fix :func:`cpu_freq` failing with
+  ``RuntimeError: sysctlbyname('dev.cpu.0.freq_levels') size mismatch`` on some
+  systems.
+- :gh:`2811`, :gh:`2813`, [OpenBSD]: :func:`virtual_memory` :field:`shared`
+  returned pages instead of bytes, plus it was overvalued (summed shared
+  ``virtual`` + ``real``, now we only return ``real``). :field:`buffers` was
+  always 0, and now returns the same value as :field:`cached`, since OpenBSD
+  does not distinguish between the 2.
+- :gh:`2814`, :gh:`2815`, [NetBSD]: :func:`virtual_memory` :field:`cached` is
+  overvalued, since it includes anonymous pages, and :field:`shared` was
+  overvalued (summed shared ``virtual`` + ``real``, now we only return
+  ``real``).
+- :gh:`2822`, [BSD]: :meth:`Process.cmdline` on NetBSD could raise
+  ``OSError: [Errno 14] Bad address`` if the process about to exit. It now
+  raises :exc:`NoSuchProcess` instead.
+- :gh:`2888`, [FreeBSD], [OpenBSD]: :class:`Process` methods could wrongly
+  raise :exc:`NoSuchProcess` ("PID has been reused") for a process still alive,
+  after a system clock update (e.g. NTP). Fixed by disabling the PID reuse
+  check (also on SunOS and AIX).
+- :gh:`2902`, [NetBSD], [OpenBSD]: :meth:`Process.cmdline` could fail with
+  ``OSError(EINVAL)`` for a process which died mid-call (OpenBSD), or raise a
+  broken :exc:`NoSuchProcess` whose ``str()`` in turn raised :exc:`TypeError`
+  (NetBSD).
+- :gh:`2903`, [BSD]: :meth:`Process.nice` could raise :exc:`NoSuchProcess` for
+  processes in ``SIDL`` state (not yet fully initialized). It now retrieves the
+  nice value via ``sysctl()`` instead of ``getpriority()``.
+- :gh:`2905`, [FreeBSD], [OpenBSD], [NetBSD]: the ``saved`` field of
+  :meth:`Process.gids` mistakenly reported the process saved *user* ID instead
+  of the saved group ID. Bug existed since 2011.
+- :gh:`2907`, [NetBSD]: a process which is exiting, but is not a zombie yet,
+  was not recognized as such. :class:`Process` methods raised
+  :exc:`NoSuchProcess` instead of :exc:`ZombieProcess`, and
+  :meth:`Process.status` returned ``"sleeping"`` or ``"?"``. Also,
+  :data:`STATUS_SUSPENDED` was never returned by :meth:`Process.status`,
+  despite being documented as NetBSD only, and :meth:`Process.environ` raised
+  ``OSError`` with ``EINVAL`` / ``EFAULT`` / ``EBUSY`` for a process which is
+  exiting or is a zombie (it now returns an empty dict, or raises
+  :exc:`NoSuchProcess` if the process is gone).
+- :gh:`2929`, [NetBSD], [OpenBSD]: :meth:`Process.num_fds` returned a wrong,
+  system-wide number which didn't change when the process opened a file, and
+  :meth:`Process.open_files` always returned an empty list.
+- :gh:`2951`, [OpenBSD]: :func:`cpu_times` returned times averaged across CPUs
+  instead of summed, like on all the other platforms. Now it sums the per-CPU
+  counters.
+- :gh:`2952`, [OpenBSD]: :meth:`Process.environ` raised ``OSError(EINVAL)`` for
+  a process which started exiting, e.g. mid-way to becoming a zombie. Also, for
+  consistency, :meth:`Process.environ` for a zombie now raises
+  :exc:`ZombieProcess` on all BSDs (NetBSD used to return an empty dict, see
+  :gh:`2911`).
+
+**Bug fixes: UNIX**
+
+- :gh:`2877`, [UNIX], :label:`critical`: fix a one-byte stack buffer overflow
+  in :func:`users`. When ``ut_host`` fills the whole field it has no null
+  terminator, and the terminator was written one byte past the end of the local
+  buffer.
+- :gh:`2789`, [AIX], :label:`build-fail`: fix compilation error caused by a
+  typo (accidental space) in ``psutil_net_io_counters()``, introduced during a
+  previous code reformatting.
+- :gh:`2858`, [SunOS], :label:`memleak`: :func:`disk_io_counters` leaked the
+  result dictionary when ``kstat_read()`` failed mid-iteration; the error path
+  now goes through the existing cleanup block.
+- :gh:`2687`, [SunOS]: :func:`users` failed with ``ValueError`` on illumos.
+- :gh:`2778`, [UNIX]: :func:`net_if_addrs` skips interfaces with no addresses,
+  which are typically virtual IPv4/IPv6 tunnel interfaces. Now they are
+  included in the returned dict with :field:`family` ==
+  :data:`socket.AF_UNSPEC` and an empty list of addresses. Main reason: it
+  creates an inconsistency with :func:`net_io_counters` and
+  :func:`net_if_stats` which do return these interface names.
+- :gh:`2964`, [POSIX]: :func:`net_if_addrs` returned the interface's own
+  address as :field:`broadcast` for ``/32`` IPv4 addresses. A single-host
+  network has no broadcast address, so ``None`` is returned now.
+- :gh:`2953`, [SunOS]: :meth:`Process.gids` returned a ``puids`` namedtuple
+  instead of ``pgids``. :meth:`Process.nice` was offset by +20 compared to
+  ``getpriority(3)``. :meth:`Process.net_connections` returned UNIX sockets
+  with ``type=-1`` and ``fd=-1``. Also, :meth:`Process.net_connections` now
+  raises :exc:`ZombieProcess` instead of ``RuntimeError`` for zombie processes.
+
+7.2.2 — 2026-01-28
+^^^^^^^^^^^^^^^^^^
+
+**Performance**
+
+- :gh:`2705`, [Linux], [macOS], [BSD]: :meth:`Process.wait` no longer uses a
+  busy loop. It now uses ``pidfd_open()`` + ``poll()`` on Linux (requires Linux
+  >= 5.3 and Python >= 3.9), and ``kqueue()`` on macOS and BSD.
+
+**Bug fixes**
+
+- :gh:`2701`, [macOS], :label:`build-fail`: fix compilation error on macOS <
+  10.7. (patch by :user:`Sergey Fedorov <barracuda156>`)
+- :gh:`2707`, [macOS], :label:`memleak`: fix potential memory leaks in error
+  paths of :meth:`Process.memory_full_info` and :meth:`Process.threads`.
+- :gh:`2708`, [macOS]: :meth:`Process.cmdline` and :meth:`Process.environ` may
+  fail with ``OSError: [Errno 0] Undefined error`` (from
+  ``sysctl(KERN_PROCARGS2)``). They now raise :exc:`AccessDenied` instead.
+
+7.2.1 — 2025-12-29
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`2699`, [FreeBSD], [NetBSD]: :func:`heap_info` does not detect small
+  allocations (<= 1K). In order to fix that, we now flush internal jemalloc
+  cache before fetching the metrics.
+
+7.2.0 — 2025-12-23
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`1275`: new :func:`heap_info` and :func:`heap_trim` functions, providing
+  direct access to the platform's native C :term:`heap` allocator (glibc,
+  mimalloc, libmalloc). Useful to create tools to detect memory leaks.
+
+**Build and packaging**
+
+- :gh:`2680`, :label:`breaking`: unit tests are no longer installed / part of
+  the distribution. They now live under ``tests/`` instead of ``psutil/tests``,
+  so ``import psutil.tests`` no longer works (it was never documented to begin
+  with).
+- :gh:`2403`, [Linux]: publish wheels for Linux musl.
+
+**Bug fixes**
+
+- :gh:`2684`, [FreeBSD], :label:`build-fail`: compilation fails on FreeBSD 14
+  due to missing include.
+- :gh:`2691`, [Windows], :label:`memleak`: fix memory leak in
+  :func:`net_if_stats` due to missing ``Py_CLEAR``.
+
+7.1.3 — 2025-11-02
+^^^^^^^^^^^^^^^^^^
+
+**Internals**
+
+- :gh:`2667`: enforce ``clang-format`` on all C and header files. It is now the
+  mandatory formatting style for all C sources.
+- :gh:`2676`, :gh:`2678`: replace unsafe ``sprintf`` / ``snprintf`` /
+  ``sprintf_s`` with ``str_format``, and ``strlcat`` / ``strlcpy`` with
+  ``str_copy`` / ``str_append``. Unifies string handling across platforms.
+
+**Bug fixes**
+
+- :gh:`2677`, [Windows], :label:`critical`: fix MAC address string construction
+  in :func:`net_if_addrs` (buffer overflow / misformat risk).
+- :gh:`2679`, [OpenBSD], [NetBSD], :label:`build-fail`: can't build due to C
+  syntax error.
+- :gh:`2672`, [macOS], [BSD]: increase the chances to recognize zombie
+  processes and raise the appropriate exception (:exc:`ZombieProcess`).
+- :gh:`2674`, [Windows]: :func:`disk_usage` could truncate values on 32-bit
+  platforms, potentially reporting incorrect :field:`total`, :field:`free`,
+  :field:`used` space for drives larger than 4GB.
+- :gh:`2675`, [macOS]: :meth:`Process.status` incorrectly returns
+  :data:`STATUS_RUNNING` for 99% of the processes.
+
+7.1.2 — 2025-10-25
+^^^^^^^^^^^^^^^^^^
+
+**Build and packaging**
+
+- :gh:`2657`, :label:`breaking`: stop publishing prebuilt Linux and Windows
+  wheels for 32-bit Python. 32-bit CPython is still supported, but psutil must
+  now be built from source.
+- :gh:`2565`: produce wheels for free-thread cPython 3.13 and 3.14. (patch by
+  :user:`Lysandros Nikolaou <lysnikolaou>`)
+
+**Bug fixes**
+
+- :gh:`2658`, [macOS], :label:`critical`: double ``free()`` in
+  :meth:`Process.environ` when it fails internally. This posed a risk of
+  segfault.
+- :gh:`2662`, [macOS], :label:`critical`: massive C code cleanup to guard
+  against possible segfaults which were (not so) sporadically spotted on CI.
+- :gh:`2650`, [macOS]: :meth:`Process.cmdline` and :meth:`Process.environ` may
+  incorrectly raise :exc:`NoSuchProcess` instead of :exc:`ZombieProcess`.
+
+7.1.1 — 2025-10-19
+^^^^^^^^^^^^^^^^^^
+
+**Internals**
+
+- :gh:`2646`, [SunOS]: add CI test runner for SunOS.
+
+**Dropped support**
+
+- :gh:`2645`, [SunOS], :label:`breaking`: dropped support for SunOS 10.
+
+**Bug fixes**
+
+- :gh:`2641`, [SunOS], :label:`build-fail`: cannot compile psutil from sources
+  due to missing C include.
+- :gh:`2357`, [SunOS]: :meth:`Process.cmdline` does not handle spaces properly.
+  (patch by :user:`Ben Raz <ben9923>`)
+
+7.1.0 — 2025-09-17
+^^^^^^^^^^^^^^^^^^
+
+**Build and packaging**
+
+- :gh:`2581`, [Windows]: publish ARM64 wheels. (patch by
+  :user:`Matthieu Darbois <mayeut>`)
+
+**Internals**
+
+- :gh:`2575`: introduced ``dprint`` CLI tool to format .yml and .md files.
+
+**Dropped support**
+
+- :gh:`2571`, [FreeBSD], :label:`breaking`: Dropped support for FreeBSD 8 and
+  earlier. FreeBSD 8 was maintained from 2009 to 2013.
+
+**Bug fixes**
+
+- :gh:`2545`, [SunOS], :label:`critical`: Fix handling of ``MIB2_UDP_ENTRY`` in
+  :func:`net_connections`.
+- :gh:`2586`, [macOS], :label:`critical`: fixed different places in C code
+  which can trigger a segfault.
+- :gh:`2610`, [macOS], :label:`critical`: fix :func:`cpu_freq` segfault on ARM
+  architectures.
+- :gh:`2473`, [macOS], :label:`build-fail`: Fix build issue on macOS 11 and
+  lower.
+- :gh:`2494`, [Windows]: :meth:`Process.memory_maps`, :meth:`Process.exe` and
+  :meth:`Process.open_files` now properly handle UNC paths (e.g.
+  ``\\??\\C:\\Windows\\Temp`` → ``C:\\Windows\\Temp``). (patch by
+  :user:`Ben Peddell <klightspeed>`)
+- :gh:`2506`, [Windows]: Windows service APIs had issues with unicode services
+  using special characters in their name.
+- :gh:`2514`, [Linux]: :meth:`Process.cwd` sometimes fail with
+  :exc:`FileNotFoundError` due to a race condition.
+- :gh:`2526`, [Linux]: :meth:`Process.create_time` now uses a monotonic clock,
+  preventing :meth:`Process.is_running` from returning wrong results after
+  system clock updates. (patch by :user:`Jonathan Kohler <kohlerjl>`)
+- :gh:`2528`, [Linux]: :meth:`Process.children` may raise
+  :exc:`PermissionError`. It will now raise :exc:`AccessDenied` instead.
+- :gh:`2540`, [macOS]: :func:`boot_time` is off by 45 seconds (C precision
+  issue).
+- :gh:`2541`, :gh:`2570`, :gh:`2578`, [Linux], [macOS], [NetBSD]:
+  :meth:`Process.create_time` does not reflect system clock updates.
+- :gh:`2542`: if system clock is updated :meth:`Process.children` and
+  :meth:`Process.parent` may not be able to return the right information.
+- :gh:`2552`, [Windows]: :func:`boot_time` didn't take into account the time
+  spent during suspend / hibernation.
+- :gh:`2560`, [Linux]: :meth:`Process.memory_maps` may crash with
+  :exc:`IndexError` on RISCV64 due to a malformed :proc:`/proc/pid/smaps` file.
+  (patch by :user:`Julien Stephan <justeph>`)
+- :gh:`2604`, [Linux]: :func:`virtual_memory` :field:`used` field does not
+  match recent versions of ``free`` CLI utility. (patch by
+  :user:`Isaac K. Ko <1saac-k>`)
+- :gh:`2605`, [Linux]: :func:`sensors_battery` reports a negative amount for
+  seconds left.
+- :gh:`2607`, [Windows]: :meth:`WindowsService.description` method may fail
+  with ``ERROR_NOT_FOUND``. Now it returns an empty string instead.
+
+7.0.0 — 2025-02-13
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`669`, [Windows]: :func:`net_if_addrs` also returns the
+  :field:`broadcast` address instead of ``None``.
+
+**API changes**
+
+- :gh:`2490`, :label:`breaking`: remove long deprecated
+  ``Process.memory_info_ex()`` (deprecated since 4.0.0). Use
+  :meth:`Process.memory_full_info` instead.
+
+**Dropped support**
+
+- :gh:`2480`, :label:`breaking`: drop Python 2.7 support. Latest version
+  supporting it is psutil 6.1.X (``pip2 install psutil==6.1.*``).
+
+**Bug fixes**
+
+- :gh:`2496`, [Linux], :label:`critical`: Avoid segfault (a cPython bug) on
+  :meth:`Process.memory_maps` for processes that use hundreds of GBs of memory.
+- :gh:`2502`, [macOS]: :func:`virtual_memory` now uses ``host_statistics64``
+  (same as ``vm_stat``), more accurate.
+
+6.1.1 — 2024-12-19
+^^^^^^^^^^^^^^^^^^
+
+**Internals**
+
+- :gh:`2471`: use Vulture CLI tool to detect dead code.
+
+**Bug fixes**
+
+- :gh:`2418`, [Linux]: fix race condition in case :proc:`/proc/pid/stat` does
+  not exist, but :proc:`/proc/pid` does, resulting in :exc:`FileNotFoundError`.
+- :gh:`2470`, [Linux]: :func:`users` may return "localhost" instead of the
+  actual IP address of the user logged in.
+
+6.1.0 — 2024-10-17
+^^^^^^^^^^^^^^^^^^
+
+**Performance**
+
+- :gh:`2366`, [Windows]: drastically speedup :func:`process_iter` by using
+  process "fast" create time to determine process identity.
+- :gh:`2457`, [AIX]: significantly improve the speed of
+  :meth:`Process.open_files` for some edge cases.
+
+**Internals**
+
+- :gh:`2446`: use pytest instead of unittest.
+- :gh:`2448`: add ``make install-sysdeps`` target to install the necessary
+  system dependencies (python-dev, gcc, etc.) on all supported UNIX flavors.
+- :gh:`2449`: add ``make install-pydeps-test`` and ``make install-pydeps-dev``
+  targets. They can be used to install dependencies meant for running tests and
+  for local development. They can also be installed via ``pip install .[test]``
+  and ``pip install .[dev]``.
+- :gh:`2456`: allow running tests via ``python3 -m psutil.tests`` even if
+  ``pytest`` is not installed.
+
+**Bug fixes**
+
+- :gh:`2427`, :label:`critical`: psutil (segfault) on import in the
+  free-threaded (no GIL) version of Python 3.13. (patch by
+  :user:`Sam Gross <colesbury>`)
+- :gh:`2455`, [Linux]: :exc:`IndexError` may occur when reading
+  :proc:`/proc/pid/stat` and field 40 (``blkio_ticks``) is missing.
+- :gh:`2460`, [OpenBSD]: :meth:`Process.num_fds` and :meth:`Process.open_files`
+  may fail with :exc:`NoSuchProcess` for PID 0. Instead, we now return "null"
+  values (``0`` and ``[]`` respectively).
+
+6.0.0 — 2024-06-18
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`2396`: a new ``process_iter.cache_clear()`` API can be used to clear
+  :func:`process_iter` internal cache.
+
+**API changes**
+
+- :gh:`2109`, :label:`breaking`: the named tuple returned by
+  :func:`disk_partitions` no longer has the :field:`maxfile` and
+  :field:`maxpath` fields (they can be very slow to retrieve on NFS).
+- :gh:`2407`, :label:`breaking`: rename :meth:`Process.connections` to
+  :meth:`Process.net_connections`. Old name still works but is deprecated.
+
+**Performance**
+
+- :gh:`2396`, :label:`breaking`: :func:`process_iter` no longer preemptively
+  checks whether PIDs have been reused, making it around **20x faster**. Use
+  :meth:`Process.is_running` on yielded instances instead (it also removes
+  reused PIDs from the internal cache).
+
+**Build and packaging**
+
+- :gh:`2369`, [Windows], :label:`build-fail`: wheels failed to build. Fixed by
+  upgrading ``cibuildwheel``.
+- :gh:`2375`, [macOS]: provide arm64 wheels. (patch by
+  :user:`Matthieu Darbois <mayeut>`)
+- :gh:`2401`, Support building with free-threaded CPython 3.13. (patch by
+  :user:`Sam Gross <colesbury>`)
+- :gh:`2425`, [Linux]: provide aarch64 wheels. (patch by
+  :user:`Matthieu Darbois <mayeut>` / :user:`Ben Raz <ben9923>`)
+
+**Internals**
+
+- :gh:`2366`, [Windows]: log debug message when using slower process APIs.
+
+**Bug fixes**
+
+- :gh:`2360`, [macOS], :label:`build-fail`: can't compile on macOS < 10.13.
+  (patch by :user:`Ryan Schmidt <ryandesign>`)
+- :gh:`2362`, [macOS], :label:`build-fail`: can't compile on macOS 10.11.
+  (patch by :user:`Ryan Schmidt <ryandesign>`)
+- :gh:`2365`, [macOS], :label:`build-fail`: can't compile on macOS < 10.9.
+  (patch by :user:`Ryan Schmidt <ryandesign>`)
+- :gh:`2412`, [macOS], :label:`build-fail`: can't compile on macOS 10.4 PowerPC
+  due to missing ``MNT_`` constants.
+- :gh:`2250`, [NetBSD]: :meth:`Process.cmdline` sometimes fail with ``EBUSY``
+  for long cmdlines. Now retries up to 50 times, returning an empty list as
+  last resort.
+- :gh:`2254`, [Linux]: offline cpus raise :exc:`NotImplementedError` in
+  :func:`cpu_freq` (patch by :user:`Shade Gladden <shadeyg56>`)
+- :gh:`2272`: Add pickle support to psutil Exceptions.
+- :gh:`2359`, [Windows]: :func:`pid_exists` disagrees with :class:`Process` on
+  whether a pid exists when ``ERROR_ACCESS_DENIED``.
+- :gh:`2395`, [OpenBSD]: :func:`pid_exists` erroneously return True if the
+  argument is a thread ID (TID) instead of a PID (process ID).
+
+5.9.8 — 2024-01-19
+^^^^^^^^^^^^^^^^^^
+
+**Performance**
+
+- :gh:`2343`, [FreeBSD]: filter :func:`net_connections` in C instead of Python,
+  **~4x faster**. Only requested connection types are now retrieved.
+- :gh:`2342`, [NetBSD]: same as above (:gh:`2343`) but for NetBSD.
+
+**Internals**
+
+- :gh:`2349`: adopted black formatting style.
+
+**Bug fixes**
+
+- :gh:`930`, [NetBSD], :label:`critical`, :label:`memleak`:
+  :func:`net_connections` implementation was broken. It could either leak
+  memory or core dump.
+- :gh:`2345`, [Linux], :label:`build-fail`: fix compilation on older compiler
+  missing :data:`NIC_DUPLEX_UNKNOWN`.
+- :gh:`2340`, [NetBSD]: if process is terminated, :meth:`Process.cwd` will
+  return an empty string instead of raising :exc:`NoSuchProcess`.
+- :gh:`2222`, [macOS]: :func:`cpu_freq` now returns fixed values for
+  :field:`min` and :field:`max` frequencies in all Apple Silicon chips.
+
+5.9.7 — 2023-12-17
+^^^^^^^^^^^^^^^^^^
+
+**Internals**
+
+- :gh:`2324`: enforce Ruff rule ``raw-string-in-exception``, which helps
+  providing clearer tracebacks when exceptions are raised by psutil.
+
+**Bug fixes**
+
+- :gh:`2321`, [Linux], [SunOS], :label:`build-fail`: missing
+  ``#include <unistd.h>`` causes an implicit declaration of ``close()`` and
+  ``syscall()``.
+- :gh:`2325`, [PyPy], :label:`build-fail`: psutil did not compile on PyPy due
+  to missing ``PyErr_SetExcFromWindowsErrWithFilenameObject`` cPython API.
+
+5.9.6 — 2023-10-15
+^^^^^^^^^^^^^^^^^^
+
+**API changes**
+
+- :gh:`1703`: :func:`cpu_percent` and :func:`cpu_times_percent` are now thread
+  safe.
+- :gh:`2266`: if :class:`Process` class is passed a very high PID, raise
+  :exc:`NoSuchProcess` instead of :exc:`OverflowError`. (patch by
+  :user:`Xuehai Pan <XuehaiPan>`)
+- :gh:`2290`: PID reuse is now preemptively checked for :meth:`Process.ppid`
+  and :meth:`Process.parents`.
+
+**Internals**
+
+- :gh:`2312`: use ``ruff`` linter instead of ``flake8 + isort``.
+
+**Dropped support**
+
+- :gh:`2246`, :label:`breaking`: drop python 3.4 & 3.5 support. (patch by
+  :user:`Matthieu Darbois <mayeut>`)
+
+**Bug fixes**
+
+- :gh:`2241`, [NetBSD], :label:`build-fail`: can't compile On NetBSD
+  10.99.3/amd64. (patch by :user:`Thomas Klausner <0-wiz-0>`)
+- :gh:`2195`, [Linux]: no longer print exception at import time in case
+  :proc:`/proc/stat` can't be read due to permission error. Redirect it to
+  :envvar:`PSUTIL_DEBUG` instead.
+- :gh:`2245`, [Windows]: fix var unbound error on possibly in
+  :func:`swap_memory` (patch by :user:`student_2333 <lgc2333>`)
+- :gh:`2268`: ``bytes2human()`` utility function was unable to properly
+  represent negative values.
+- :gh:`2252`, [Windows]: :func:`disk_usage` fails on Python 3.12+. (patch by
+  Matthieu Darbois)
+- :gh:`2284`, [Linux]: :meth:`Process.memory_full_info` may incorrectly raise
+  :exc:`ZombieProcess` if it's determined via ``/proc/pid/smaps_rollup``.
+  Instead we now fallback on reading :proc:`/proc/pid/smaps`.
+- :gh:`2287`, [OpenBSD], [NetBSD]: :meth:`Process.is_running` erroneously
+  return ``False`` for zombie processes, because creation time cannot be
+  determined.
+- :gh:`2288`, [Linux]: correctly raise :exc:`ZombieProcess` on
+  :meth:`Process.exe`, :meth:`Process.cmdline` and :meth:`Process.memory_maps`
+  instead of returning a "null" value.
+- :gh:`2290`: differently from what stated in the doc, PID reuse is not
+  preemptively checked for :meth:`Process.nice` (set), :meth:`Process.ionice`,
+  (set), :meth:`Process.cpu_affinity` (set), :meth:`Process.rlimit` (set),
+  :meth:`Process.parent`.
+- :gh:`2308`, [OpenBSD]: :meth:`Process.threads` always fail with
+  :exc:`AccessDenied` (also as root).
+
+5.9.5 — 2023-04-17
+^^^^^^^^^^^^^^^^^^
+
+**API changes**
+
+- :gh:`2230`, [OpenBSD]: :func:`net_connections` rewritten from scratch: now
+  retrieves :data:`socket.AF_UNIX` socket paths, is faster, and no longer
+  produces duplicates.
+- :gh:`2238`: :meth:`Process.cwd` now consistently returns ``""`` on all
+  platforms when the directory can't be determined.
+- :gh:`2239`, [UNIX]: for zombie processes, return the truncated
+  :meth:`Process.name` (15 chars) instead of raising :exc:`ZombieProcess` when
+  the full name can't be determined from :meth:`Process.cmdline`.
+
+**Internals**
+
+- :gh:`2196`: in case of exception, display a cleaner error traceback by hiding
+  the :exc:`KeyError` bit deriving from a missed cache hit.
+- :gh:`2217`: print the full traceback when a :exc:`DeprecationWarning` or
+  :exc:`UserWarning` is raised.
+- :gh:`2240`, [NetBSD], [OpenBSD]: add CI testing on every commit for NetBSD
+  and OpenBSD platforms (python 3 only).
+
+**Bug fixes**
+
+- :gh:`2164`, [Linux], :label:`build-fail`: compilation fails on kernels <
+  2.6.27 (e.g. CentOS 5).
+- :gh:`2186`, [FreeBSD], :label:`build-fail`: compilation fails with Clang 15.
+  (patch by :user:`Po-Chuan Hsieh <sunpoet>`)
+- :gh:`1043`, [OpenBSD] :func:`net_connections` returns duplicate entries.
+- :gh:`1915`, [Linux]: on certain kernels, ``"MemAvailable"`` field from
+  :proc:`/proc/meminfo` returns ``0`` (possibly a kernel bug), in which case we
+  calculate an approximation for :field:`available` memory which matches "free"
+  CLI utility.
+- :gh:`2191`, [Linux]: :func:`disk_partitions`: do not unnecessarily read
+  :proc:`/proc/filesystems` and raise :exc:`AccessDenied` unless user specified
+  ``all=False`` argument.
+- :gh:`2216`, [Windows]: fix tests when running in a virtual environment (patch
+  by Matthieu Darbois)
+- :gh:`2225`, [POSIX]: :func:`users` loses precision for :field:`started` field
+  (off by 1 minute).
+- :gh:`2229`, [OpenBSD]: unable to properly recognize zombie processes.
+  :exc:`NoSuchProcess` may be raised instead of :exc:`ZombieProcess`.
+- :gh:`2231`, [NetBSD]: :field:`available` :func:`virtual_memory` is higher
+  than :field:`total`.
+- :gh:`2234`, [NetBSD]: :func:`virtual_memory` metrics are wrong:
+  :field:`available` and :field:`used` are too high. We now match values shown
+  by *htop* CLI utility.
+- :gh:`2236`, [NetBSD]: :meth:`Process.num_threads` and :meth:`Process.threads`
+  return threads that are already terminated.
+- :gh:`2237`, [OpenBSD], [NetBSD]: :meth:`Process.cwd` may raise
+  :exc:`FileNotFoundError` if cwd no longer exists. Return an empty string
+  instead.
+
+5.9.4 — 2022-11-07
+^^^^^^^^^^^^^^^^^^
+
+**Build and packaging**
+
+- :gh:`2102`: use Limited API when building wheels with CPython 3.6+ on Linux,
+  macOS and Windows. (patch by :user:`Matthieu Darbois <mayeut>`)
+
+**Bug fixes**
+
+- :gh:`2156`, [Linux], :label:`build-fail`: compilation may fail on very old
+  gcc compilers due to missing ``SPEED_UNKNOWN`` definition. (patch by
+  :user:`Amir Rossert <arossert>`)
+- :gh:`2010`, [macOS], :label:`build-fail`: on MacOS, arm64 ``IFM_1000_TX`` and
+  ``IFM_1000_T`` are the same value, causing a build failure. (patch by
+  :user:`Lawrence D'Anna <smoofra>`)
+- :gh:`2077`, [Windows]: Use system-level values for :func:`virtual_memory`.
+  (patch by :user:`Daniel Widdis <dbwiddis>`)
+- :gh:`2160`, [Windows]: get :func:`swap_memory` :field:`percent` usage from
+  performance counters. (patch by :user:`Daniel Widdis <dbwiddis>`)
+
+5.9.3 — 2022-10-18
+^^^^^^^^^^^^^^^^^^
+
+**Build and packaging**
+
+- :gh:`2040`, [macOS]: provide wheels for arm64 architecture. (patch by
+  Matthieu Darbois)
+
+**Internals**
+
+- :gh:`2153`, [macOS] Fix race condition in
+  ``test_posix.TestProcess.test_cmdline``. (patch by
+  :user:`Matthieu Darbois <mayeut>`)
+
+**Bug fixes**
+
+- :gh:`2135`, [macOS], :label:`critical`: :meth:`Process.environ` may contain
+  garbage data. Fix out-of-bounds read around ``sysctl_procargs``. (patch by
+  :user:`Bernhard Urban-Forster <lewurm>`)
+- :gh:`2138`, [Linux], :label:`build-fail`: can't compile psutil on Android due
+  to undefined ``ethtool_cmd_speed`` symbol.
+- :gh:`2116`, [macOS]: :func:`net_connections` fails with :exc:`RuntimeError`.
+- :gh:`2142`, [POSIX]: :func:`net_if_stats` 's :field:`flags` on Python 2
+  returned unicode instead of str. (patch by :user:`Matthieu Darbois <mayeut>`)
+- :gh:`2147`, [macOS] Fix disk usage report on macOS 12+. (patch by
+  :user:`Matthieu Darbois <mayeut>`)
+- :gh:`2150`, [Linux] :meth:`Process.threads` may raise :exc:`NoSuchProcess`.
+  Fix race condition. (patch by :user:`Daniel Li <li-dan>`)
+
+5.9.2 — 2022-09-04
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`2093`, [FreeBSD]: :func:`pids` may fail with ENOMEM. Dynamically
+  increase the ``malloc()`` buffer size until it's big enough.
+- :gh:`2095`, [Linux]: :func:`net_if_stats` returns incorrect interface speed
+  for 100GbE network cards.
+- :gh:`2113`, [FreeBSD]: :func:`virtual_memory` may raise ENOMEM due to missing
+  ``#include <sys/param.h>`` directive. (patch by
+  :user:`Peter Jeremy <peterjeremy>`)
+- :gh:`2128`, [NetBSD]: :func:`swap_memory` was miscalculated. (patch by
+  :user:`Thomas Klausner <0-wiz-0>`)
+
+5.9.1 — 2022-05-20
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`2037`: add :field:`flags` field to :func:`net_if_stats`.
+- :gh:`2057`, [OpenBSD]: add support for :func:`cpu_freq`.
+
+**Performance**
+
+- :gh:`2050`, [Linux]: increase :manpage:`read(2)` buffer size from 1k to 32k
+  when reading ``/proc`` pseudo files line by line.
+- :gh:`2107`, [Linux]: :meth:`Process.memory_full_info` now reads
+  ``/proc/pid/smaps_rollup`` instead of :proc:`/proc/pid/smaps`
+  (**5x faster**).
+
+**Dropped support**
+
+- :gh:`1053`, :label:`breaking`: drop Python 2.6 support. (patches by Matthieu
+  Darbois and Hugo van Kemenade)
+
+**Bug fixes**
+
+- :gh:`2048`: :exc:`AttributeError` is raised if :exc:`psutil.Error` class is
+  raised manually and passed through ``str``.
+- :gh:`2049`, [Linux]: :func:`cpu_freq` erroneously returns :field:`current`
+  value in GHz while :field:`min` and :field:`max` are in MHz.
+- :gh:`2050`, [Linux]: :func:`virtual_memory` may raise :exc:`ValueError` if
+  running in a LCX container.
+
+5.9.0 — 2021-12-29
+^^^^^^^^^^^^^^^^^^
+
+**New platforms**
+
+- :gh:`1996`, [BSD]: add support for MidnightBSD. (patch by
+  :user:`Saeed Rasooli <ilius>`)
+
+**API changes**
+
+- :gh:`1992`: :exc:`NoSuchProcess` message now specifies if the PID has been
+  reused. Error classes now have improved ``__repr__`` and ``__str__``.
+- :gh:`1999`, [Linux]: :func:`disk_partitions`: convert ``/dev/root`` device
+  (an alias used on some Linux distros) to real root device path.
+
+**Performance**
+
+- :gh:`1851`, [Linux]: :func:`cpu_freq` reads from :proc:`/proc/cpuinfo`
+  instead of many files in ``/sys`` fs, faster on systems with many CPUs.
+  (patch by marxin)
+
+**Documentation**
+
+- :gh:`2042`: rewrite HISTORY.rst to use hyperlinks pointing to psutil API doc.
+
+**Internals**
+
+- :gh:`2005`: :envvar:`PSUTIL_DEBUG` mode now prints file name and line number
+  of the debug messages coming from C extension modules.
+
+**Bug fixes**
+
+- :gh:`1953`, [Windows], :label:`critical`: :func:`disk_partitions` crashes due
+  to insufficient buffer len. (patch by :user:`MaWe2019 <MaWe2019>`)
+- :gh:`1965`, [Windows], :label:`critical`: fix "Fatal Python error:
+  deallocating None" when calling :func:`users` multiple times.
+- :gh:`1990`, [Windows], :label:`memleak`: starting a :class:`WindowsService`
+  leaked a service handle.
+- :gh:`1512`, [macOS]: sometimes :meth:`Process.connections` will crash with
+  ``EOPNOTSUPP`` for one connection; this is now ignored.
+- :gh:`1598`, [Windows]: :func:`disk_partitions` only returns mount points on
+  drives where it first finds one.
+- :gh:`1874`, [SunOS]: swap output error due to incorrect range.
+- :gh:`1892`, [macOS]: :func:`cpu_freq` broken on Apple M1. Also, :field:`min`
+  and :field:`max` are set to 0 if they can't be determined, instead of raising
+  an exception.
+- :gh:`1901`, [macOS]: :meth:`Process.open_files`, :meth:`Process.connections`
+  and others could randomly raise :exc:`AccessDenied` because the internal
+  buffer of ``proc_pidinfo(PROC_PIDLISTFDS)`` was too small. Now dynamically
+  increased until sufficient.
+- :gh:`1904`, [Windows]: ``OpenProcess`` fails with ``ERROR_SUCCESS`` due to
+  ``GetLastError()`` called after ``sprintf()``. (patch by :user:`alxchk`)
+- :gh:`1913`, [Linux]: :func:`wait_procs` should catch
+  :exc:`subprocess.TimeoutExpired` exception.
+- :gh:`1919`, [Linux]: :func:`sensors_battery` can raise :exc:`TypeError` on
+  PureOS.
+- :gh:`1921`, [Windows]: :func:`swap_memory` shows committed memory instead of
+  swap.
+- :gh:`1940`, [Linux]: psutil does not handle ``ENAMETOOLONG`` when accessing
+  process file descriptors in procfs. (patch by
+  :user:`Nikita Radchenko <nradchenko>`)
+- :gh:`1948`: ``memoize_when_activated`` decorator is not thread-safe. (patch
+  by :user:`Xuehai Pan <XuehaiPan>`)
+- :gh:`1980`, [Windows]: 32bit / WoW64 processes fails to read
+  :meth:`Process.name` longer than 128 characters. (patch by
+  :user:`PetrPospisil <PetrPospisil>`)
+- :gh:`1991`: :func:`process_iter` is not thread safe and can raise
+  :exc:`TypeError` if invoked from multiple threads.
+- :gh:`1956`, [macOS]: :meth:`Process.cpu_times` reports incorrect timings on
+  M1 machines. (patch by :user:`Olivier Dormond <odormond>`)
+- :gh:`2023`, [Linux]: :func:`cpu_freq` return order is wrong on systems with
+  more than 9 CPUs.
+
+5.8.0 — 2020-12-19
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`1863`: :func:`disk_partitions` exposes 2 extra fields: :field:`maxfile`
+  and :field:`maxpath`, which are the maximum file name and path name length.
+
+**New platforms**
+
+- :gh:`1872`, [Windows]: added support for PyPy 2.7.
+
+**Build and packaging**
+
+- :gh:`1879`: provide pre-compiled wheels for Linux and macOS (yey!).
+
+**Internals**
+
+- :gh:`1880`: switch CI from Travis/Cirrus to GitHub Actions (Linux, macOS,
+  FreeBSD). AppVeyor still used for Windows.
+
+**Bug fixes**
+
+- :gh:`1708`, [Linux]: get rid of :func:`sensors_temperatures` duplicates.
+  (patch by :user:`Tim Schlueter <modelrockettier>`).
+- :gh:`1839`, [Windows]: always raise :exc:`AccessDenied` instead of
+  :exc:`WindowsError` when failing to query 64 processes from 32 bit ones by
+  using ``NtWoW64`` APIs.
+- :gh:`1866`, [Windows]: :meth:`Process.exe`, :meth:`Process.cmdline`,
+  :meth:`Process.environ` may raise "[WinError 998] Invalid access to memory
+  location" on Python 3.9 / VS 2019.
+- :gh:`1874`, [SunOS]: wrong swap output given when encrypted column is
+  present.
+- :gh:`1875`, [Windows]: :meth:`Process.username` may raise
+  ``ERROR_NONE_MAPPED`` if the SID has no corresponding account name. In this
+  case :exc:`AccessDenied` is now raised.
+- :gh:`1886`, [macOS]: ``EIO`` error may be raised on :meth:`Process.cmdline`
+  and :meth:`Process.environ`. Now it gets translated into :exc:`AccessDenied`.
+- :gh:`1887`, [Windows]: ``OpenProcess`` may fail with "[WinError 0] The
+  operation completed successfully"." Turn it into :exc:`AccessDenied` or
+  :exc:`NoSuchProcess` depending on whether the PID is alive.
+- :gh:`1891`, [macOS]: get rid of deprecated ``getpagesize()``.
+
+5.7.3 — 2020-10-24
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`809`, [FreeBSD]: add support for :meth:`Process.rlimit`.
+- :gh:`893`, [BSD]: add support for :meth:`Process.environ` (patch by
+  :user:`Armin Gruner <ArminGruner>`)
+
+**API changes**
+
+- :gh:`1830`, [POSIX]: :func:`net_if_stats` :field:`isup` also checks whether
+  the :term:`NIC` is running (meaning Wi-Fi or ethernet cable is connected).
+  (patch by Chris Burger)
+- :gh:`1837`, [Linux]: improved battery detection and charge :field:`secsleft`
+  calculation (patch by :user:`aristocratos`)
+
+**Bug fixes**
+
+- :gh:`1823`, [Windows], :label:`critical`: :meth:`Process.open_files` may
+  cause a segfault due to a NULL pointer.
+- :gh:`1791`, [macOS], :label:`build-fail`: fix missing include for
+  ``getpagesize()``.
+- :gh:`1620`, [Linux]: :func:`cpu_count` with ``logical=False`` result is
+  incorrect on systems with more than one CPU socket. (patch by
+  :user:`Vincent A. Arcila <jandrovins>`)
+- :gh:`1738`, [macOS]: :meth:`Process.exe` may raise :exc:`FileNotFoundError`
+  if process is still alive but the exe file which launched it got deleted.
+- :gh:`1838`, [Linux]: :func:`sensors_battery`: if :field:`percent` can be
+  determined but not the remaining values, still return a result instead of
+  ``None``. (patch by :user:`aristocratos`)
+
+5.7.2 — 2020-07-15
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- wheels for 2.7 were inadvertently deleted.
+
+5.7.1 — 2020-07-15
+^^^^^^^^^^^^^^^^^^
+
+**New platforms**
+
+- :gh:`1768`, [Windows]: added support for Windows Nano Server. (contributed by
+  Julien Lebot)
+
+**API changes**
+
+- :gh:`1747`: :meth:`Process.wait` return value is cached so that the exit code
+  can be retrieved on then next call.
+- :gh:`1747`, [POSIX]: :meth:`Process.wait` on POSIX now returns an enum,
+  showing the negative signal which was used to terminate the process. It
+  returns something like ``<Negsignal.SIGTERM: -15>``.
+- :gh:`1747`: :class:`Process` class provides more info about the process on
+  ``str()`` and ``repr()`` (status and exit code).
+
+**Performance**
+
+- :gh:`1741`, [POSIX]: ``make build`` now runs in parallel on Python >= 3.6 and
+  it's about **15% faster**.
+
+**Internals**
+
+- :gh:`1709`: parallel tests on POSIX (``make test-parallel``). They're twice
+  as fast!
+- :gh:`1757`: memory leak tests are now stable.
+
+**Bug fixes**
+
+- :gh:`1781`, :label:`critical`: :func:`getloadavg` can crash the Python
+  interpreter. (patch by :user:`Ammar Askar <ammaraskar>`)
+- :gh:`1726`, [Linux]: :func:`cpu_freq` parsing should use spaces instead of
+  tabs on ia64. (patch by :user:`Michał Górny <mgorny>`)
+- :gh:`1760`, [Linux]: :meth:`Process.rlimit` does not handle long long type
+  properly.
+- :gh:`1766`, [macOS]: :exc:`NoSuchProcess` may be raised instead of
+  :exc:`ZombieProcess`.
+
+5.7.0 — 2020-02-18
+^^^^^^^^^^^^^^^^^^
+
+**New platforms**
+
+- :gh:`1637`, [SunOS]: add partial support for old SunOS 5.10 Update 0 to 3.
+- :gh:`1686`, [Windows]: added support for PyPy on Windows.
+
+**API changes**
+
+- :gh:`1648`, [Linux]: :func:`sensors_temperatures` looks into an additional
+  ``/sys/device/`` directory for additional data. (patch by
+  :user:`Javad Karabi <karabijavad>`)
+- :gh:`1677`, [Windows]: :meth:`Process.exe` will succeed for all process PIDs
+  (instead of raising :exc:`AccessDenied`).
+- :gh:`1693`, [Windows]: :func:`boot_time`, :meth:`Process.create_time` and
+  :func:`users`'s login time now have 1 micro second precision (before the
+  precision was of 1 second).
+
+**Performance**
+
+- :gh:`1679`, [Windows]: :func:`net_connections` and
+  :meth:`Process.connections` are **10% faster**.
+
+**Internals**
+
+- :gh:`1671`, [FreeBSD]: add CI testing/service for FreeBSD (Cirrus CI).
+- :gh:`1682`, [PyPy]: added CI / test integration for PyPy via Travis.
+
+**Dropped support**
+
+- :gh:`1652`, [Windows], :label:`breaking`: dropped support for Windows XP and
+  Windows Server
+  2003. Minimum supported Windows version now is Windows Vista.
+
+**Bug fixes**
+
+- :gh:`1646`, [FreeBSD], :label:`critical`: many :class:`Process` methods may
+  cause a segfault due to a backward incompatible change in a C type on FreeBSD
+  12.0.
+- :gh:`1695`, [Linux], :label:`build-fail`: could not compile on kernels <=
+  2.6.13 due to ``PSUTIL_HAS_IOPRIO`` not being defined. (patch by
+  :user:`Anselm Kruis <akruis>`)
+- :gh:`1538`, [NetBSD]: :meth:`Process.cwd` may return ``ENOENT`` instead of
+  :exc:`NoSuchProcess`.
+- :gh:`1627`, [Linux]: :meth:`Process.memory_maps` can raise :exc:`KeyError`.
+- :gh:`1642`, [SunOS]: querying basic info for PID 0 results in
+  :exc:`FileNotFoundError`.
+- :gh:`1656`, [Windows]: :meth:`Process.memory_full_info` raises
+  :exc:`AccessDenied` even for the current user and :func:`os.getpid`.
+- :gh:`1660`, [Windows]: :meth:`Process.open_files` rewritten with proper error
+  handling.
+- :gh:`1662`, [Windows]: :meth:`Process.exe` may raise "[WinError 0] The
+  operation completed successfully".
+- :gh:`1665`, [Linux]: :func:`disk_io_counters` does not take into account
+  extra fields added to recent kernels. (patch by
+  :user:`Mike Hommey <glandium>`)
+- :gh:`1672`: use the right C type when dealing with PIDs (int or long).
+- :gh:`1673`, [OpenBSD]: :meth:`Process.connections`, :meth:`Process.num_fds`
+  and :meth:`Process.threads` raised wrong exception if process is gone.
+- :gh:`1674`, [SunOS]: :func:`disk_partitions` may raise :exc:`OSError`.
+- :gh:`1684`, [Linux]: :func:`disk_io_counters` may raise :exc:`ValueError` on
+  systems not having :proc:`/proc/diskstats`.
+
+5.6.7 — 2019-11-26
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`1630`, [Windows], :label:`build-fail`: can't compile source distribution
+  due to C syntax error.
+
+5.6.6 — 2019-11-25
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`1616`, :label:`critical`: use of ``Py_DECREF`` instead of ``Py_CLEAR`` will
+  result in double ``free()`` and segfault (`CVE-2019-18874
+  <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-18874>`__). (patch
+  by Riccardo Schirone)
+- :gh:`1619`, [OpenBSD], :label:`build-fail`: compilation fails due to C syntax
+  error. (patch by :user:`Nathan Houghton <n1000>`)
+- :gh:`1179`, [Linux]: :meth:`Process.cmdline` now handles processes that use
+  inappropriate chars to separate args.
+
+5.6.5 — 2019-11-06
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`1615`, :label:`build-fail`: remove ``pyproject.toml`` as it was causing
+  installation issues.
+
+5.6.4 — 2019-11-04
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`1527`, [Linux]: added :meth:`Process.cpu_times` :field:`iowait` counter,
+  which is the time spent waiting for blocking I/O to complete.
+
+**Build and packaging**
+
+- :gh:`1565`: add PEP 517/8 build backend and requirements specification for
+  better pip integration. (patch by :user:`Bernát Gábor <gaborbernat>`)
+
+**Bug fixes**
+
+- :gh:`1126`, [Linux], :label:`critical`: :meth:`Process.cpu_affinity`
+  segfaults on CentOS 5 / manylinux. :meth:`Process.cpu_affinity` support for
+  CentOS 5 was removed.
+- :gh:`1528`, [AIX], :label:`build-fail`: compilation error on AIX 7.2 due to
+  32 vs 64 bit differences. (patch by :user:`Arnon Yaari <wiggin15>`)
+- :gh:`1606`, [SunOS], :label:`build-fail`: compilation fails on SunOS 5.10.
+  (patch by vser1)
+- :gh:`875`, [Windows]: :meth:`Process.cmdline`, :meth:`Process.environ` or
+  :meth:`Process.cwd` may occasionally fail with ``ERROR_PARTIAL_COPY`` which
+  now gets translated to :exc:`AccessDenied`.
+- :gh:`1535`: :field:`type` and :field:`family` fields returned by
+  :func:`net_connections` are not always turned into enums.
+- :gh:`1536`, [NetBSD]: :meth:`Process.cmdline` erroneously raise
+  :exc:`ZombieProcess` error if cmdline has non encodable chars.
+- :gh:`1546`: usage percent may be rounded to 0 on Python 2.
+- :gh:`1552`, [Windows]: :func:`getloadavg` math for calculating 5 and 15 mins
+  values is incorrect.
+- :gh:`1568`, [Linux]: use CC compiler env var if defined.
+- :gh:`1570`, [Windows]: ``NtWow64*`` syscalls fail to raise the proper error
+  code
+- :gh:`1585`, [macOS]: avoid calling ``close()`` (in C) on possible negative
+  integers. (patch by :user:`Athos Ribeiro <athos-ribeiro>`)
+
+5.6.3 — 2019-06-11
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`1494`, [AIX]: added support for :meth:`Process.environ`. (patch by
+  :user:`Arnon Yaari <wiggin15>`)
+
+**Bug fixes**
+
+- :gh:`1276`, [AIX]: can't get whole :meth:`Process.cmdline`. (patch by
+  :user:`Arnon Yaari <wiggin15>`)
+- :gh:`1501`, [Windows]: :meth:`Process.cmdline` and :meth:`Process.exe` raise
+  unhandled "WinError 1168 element not found" exceptions for "Registry" and
+  "Memory Compression" pseudo processes on Windows 10.
+- :gh:`1526`, [NetBSD]: :meth:`Process.cmdline` could raise :exc:`MemoryError`.
+  (patch by :user:`Kamil Rytarowski <krytarowski>`)
+
+5.6.2 — 2019-04-26
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`604`, [Windows]: add new :func:`getloadavg`, returning system load
+  average calculation, including on Windows (emulated). (patch by
+  :user:`Ammar Askar <ammaraskar>`)
+- :gh:`1476`, [Windows]: :meth:`Process.ionice` can now set high I/O priority.
+  New constants: :data:`IOPRIO_VERYLOW`, :data:`IOPRIO_LOW`,
+  :data:`IOPRIO_NORMAL`, :data:`IOPRIO_HIGH`.
+
+**API changes**
+
+- :gh:`1404`, [Linux]: :func:`cpu_count` with ``logical=False`` falls back to
+  reading ``/sys/devices/system/cpu/*/topology/core_id`` if
+  :proc:`/proc/cpuinfo` doesn't provide the info.
+
+**Documentation**
+
+- :gh:`1464`: various docfixes (always point to Python 3 doc, fix links, etc.).
+
+**Internals**
+
+- :gh:`1458`: provide coloured test output. Also show failures on
+  ``KeyboardInterrupt``.
+- :gh:`1478`: add make command to re-run tests failed on last run.
+- :gh:`1462`, [Linux]: (tests) make tests invariant to ``LANG`` setting (patch
+  by Benjamin Drung)
+- :gh:`1463`: :src:`scripts/cpu_distribution.py` was broken.
+
+**Bug fixes**
+
+- :gh:`1480`, [Windows], :label:`critical`: :func:`cpu_count` with
+  ``logical=False`` could cause a crash due to fixed read violation. (patch by
+  Samer Masterson)
+- :gh:`1491`, [SunOS], :label:`memleak`: :func:`net_if_addrs`: use ``free()``
+  against ``ifap`` struct on error. (patch by Agnewee)
+- :gh:`1223`, [Windows]: :func:`boot_time` may return incorrect value on
+  Windows XP.
+- :gh:`1456`, [Linux]: :func:`cpu_freq` returns ``None`` instead of 0.0 when
+  :field:`min` and :field:`max` fields can't be determined. (patch by
+  :user:`Alex Manuskin <amanusk>`)
+- :gh:`1470`, [Linux]: :func:`disk_partitions`: fix corner case when
+  ``/etc/mtab`` doesn't exist. (patch by
+  :user:`Cedric Lamoriniere <clamoriniere>`)
+- :gh:`1471`, [SunOS]: :meth:`Process.name` and :meth:`Process.cmdline` can
+  return :exc:`SystemError`. (patch by :user:`Daniel Beer <dbeer1>`)
+- :gh:`1472`, [Linux]: :func:`cpu_freq` does not return all CPUs on
+  Raspberry-pi 3.
+- :gh:`1474`: fix formatting of ``psutil.tests()`` which mimics ``ps aux``
+  output.
+- :gh:`1475`, [Windows]: :attr:`OSError.winerror` attribute wasn't properly
+  checked resulting in ``WindowsError(ERROR_ACCESS_DENIED)`` being raised
+  instead of :exc:`AccessDenied`.
+- :gh:`1477`, [Windows]: wrong or absent error handling for private
+  ``NTSTATUS`` Windows APIs. Different process methods were affected by this.
+- :gh:`1486`, [AIX], [SunOS]: :exc:`AttributeError` when interacting with
+  :class:`Process` methods involved into :meth:`Process.oneshot` context.
+- :gh:`1493`, [Linux]: :func:`cpu_freq`: handle the case where
+  ``/sys/devices/system/cpu/cpufreq/`` exists but it's empty.
+
+5.6.1 — 2019-03-11
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`1448`, [Windows], :label:`critical`: crash on import due to
+  ``rtlIpv6AddressToStringA`` not available on Wine.
+- :gh:`1451`, [Windows], :label:`critical`: :meth:`Process.memory_full_info`
+  segfaults. ``NtQueryVirtualMemory`` is now used instead of
+  ``QueryWorkingSet`` to calculate :term:`USS` memory.
+- :gh:`1329`, [AIX], :label:`build-fail`: psutil doesn't compile on AIX 6.1.
+  (patch by :user:`Arnon Yaari <wiggin15>`)
+
+5.6.0 — 2019-03-05
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`1433`: new :meth:`Process.parents` method.  (idea by Ghislain Le Meur)
+
+**API changes**
+
+- :gh:`1291`, [macOS], :label:`critical`, :label:`breaking`:
+  :meth:`Process.memory_maps` was removed because inherently broken (segfault)
+  for years.
+- :gh:`1420`, [Windows]: in case of exception :func:`disk_usage` now also shows
+  the path name.
+- :gh:`1437`: :func:`pids` are returned in sorted order.
+
+**Performance**
+
+- :gh:`1379`, [Windows]: :meth:`Process.suspend` and :meth:`Process.resume` now
+  use ``NtSuspendProcess`` / ``NtResumeProcess`` instead of stopping / resuming
+  all threads. Faster and more reliable.
+- :gh:`1422`, [Windows]: DLL-loaded Windows APIs are now loaded once on startup
+  instead of per function call, significantly faster.
+- :gh:`1426`, [Windows]: ``PAGESIZE`` and number of processors is now
+  calculated on startup.
+
+**Internals**
+
+- :gh:`1428`: in case of error, the traceback message now shows the underlying
+  C function called which failed.
+- :gh:`1442`: Python 3 is now the default interpreter used by Makefile.
+
+**Bug fixes**
+
+- :gh:`1411`, [BSD], :label:`critical`, :label:`memleak`: lack of ``Py_DECREF``
+  could cause segmentation fault on process instantiation.
+- :gh:`1353`: :func:`process_iter` is now thread safe (it rarely raised
+  :exc:`TypeError`).
+- :gh:`1394`, [Windows]: :meth:`Process.name` and :meth:`Process.exe` may
+  erroneously return "Registry" or fail with "[Error 0] The operation completed
+  successfully". ``QueryFullProcessImageNameW`` is now used instead of
+  ``GetProcessImageFileNameW`` in order to prevent that.
+- :gh:`1419`, [Windows]: :meth:`Process.environ` raises
+  :exc:`NotImplementedError` when querying a 64-bit process in 32-bit-WoW mode.
+  Now it raises :exc:`AccessDenied`.
+- :gh:`1427`, [macOS]: :meth:`Process.cmdline` and :meth:`Process.environ` may
+  erroneously raise :exc:`OSError` on failed ``malloc()``.
+- :gh:`1429`, [Windows]: ``SE DEBUG`` was not properly set for current process.
+  It is now, and it should result in less :exc:`AccessDenied` exceptions for
+  low PID processes.
+- :gh:`1432`, [Windows]: ``Process.memory_info_ex()``'s USS memory is
+  miscalculated because we're not using the actual system ``PAGESIZE``.
+- :gh:`1439`, [NetBSD]: :meth:`Process.connections` may return incomplete
+  results if using :meth:`Process.oneshot`.
+- :gh:`1447`: original exception wasn't turned into :exc:`NoSuchProcess` /
+  :exc:`AccessDenied` exceptions when using :meth:`Process.oneshot` context
+  manager.
+
+5.5.1 — 2019-02-15
+^^^^^^^^^^^^^^^^^^
+
+**API changes**
+
+- :gh:`1384`, [Windows]: on Windows >= 8.1, :meth:`Process.cmdline` falls back
+  to ``NtQueryInformationProcess`` on ``ERROR_ACCESS_DENIED``. (patch by
+  EccoTheFlintstone)
+
+**Bug fixes**
+
+- :gh:`1408`, [AIX], :label:`build-fail`: psutil won't compile on AIX 7.1 due
+  to missing header. (patch by :user:`Arnon Yaari <wiggin15>`)
+- :gh:`1394`, [Windows]: :meth:`Process.exe` returns "[Error 0] The operation
+  completed successfully" when Python process runs in "Virtual Secure Mode".
+- :gh:`1402`: psutil exceptions' ``repr()`` show the internal private module
+  path.
+
+5.5.0 — 2019-01-23
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`1350`, [FreeBSD]: added support for :func:`sensors_temperatures`. (patch
+  by Alex Manuskin)
+- :gh:`1352`, [FreeBSD]: added support for :func:`cpu_freq`. (patch by
+  :user:`Alex Manuskin <amanusk>`)
+
+**Bug fixes**
+
+- :gh:`1111`: :meth:`Process.oneshot` is now thread safe.
+- :gh:`1354`, [Linux]: :func:`disk_io_counters` fails on Linux kernel 4.18+.
+- :gh:`1357`, [Linux]: :meth:`Process.memory_maps` and
+  :meth:`Process.io_counters` methods are no longer exposed if not supported by
+  the kernel.
+- :gh:`1368`, [Windows]: fix :meth:`Process.ionice` mismatch. (patch by
+  EccoTheFlintstone)
+- :gh:`1370`, [Windows]: improper usage of ``CloseHandle()`` may lead to
+  override the original error code when raising an exception.
+- :gh:`1373`: incorrect handling of cache in :meth:`Process.oneshot` context
+  causes :class:`Process` instances to return incorrect results.
+- :gh:`1376`, [Windows]: ``OpenProcess`` now uses
+  ``PROCESS_QUERY_LIMITED_INFORMATION`` where possible, reducing
+  :exc:`AccessDenied` for system processes.
+- :gh:`1376`, [Windows]: check if variable is ``NULL`` before ``free()`` ing
+  it. (patch by :user:`EccoTheFlintstone <EccoTheFlintstone>`)
+
+5.4.8 — 2018-10-30
+^^^^^^^^^^^^^^^^^^
+
+**API changes**
+
+- :gh:`1197`, [Linux]: :func:`cpu_freq` falls back to :proc:`/proc/cpuinfo` if
+  ``/sys/devices/system/cpu/*`` is not available.
+- :gh:`1310`, [Linux]: :func:`sensors_temperatures` falls back to
+  ``/sys/class/thermal`` if ``/sys/class/hwmon`` is not available (e.g.
+  Raspberry Pi). (patch by :user:`Alex Manuskin <amanusk>`)
+
+**Build and packaging**
+
+- :gh:`1320`, [POSIX]: better compilation support when using g++ instead of
+  GCC. (patch by :user:`Jaime Fullaondo <truthbk>`)
+
+**Bug fixes**
+
+- :gh:`715`: do not print exception on import time in case :func:`cpu_times`
+  fails.
+- :gh:`1004`, [Linux]: :meth:`Process.io_counters` may raise :exc:`ValueError`.
+- :gh:`1277`, [macOS]: available and used memory (:func:`virtual_memory`)
+  metrics are not accurate.
+- :gh:`1294`, [Windows]: :meth:`Process.connections` may sometimes fail with
+  intermittent ``0xC0000001``. (patch by
+  :user:`Sylvain Duchesne <sylvainduchesne>`)
+- :gh:`1307`, [Linux]: :func:`disk_partitions` does not honour
+  :data:`PROCFS_PATH`.
+- :gh:`1320`, [AIX]: system CPU times (:func:`cpu_times`) were being reported
+  with ticks unit as opposed to seconds. (patch by
+  :user:`Jaime Fullaondo <truthbk>`)
+- :gh:`1332`, [macOS]: psutil debug messages are erroneously printed all the
+  time. (patch by :user:`Ilya Yanok <yanok>`)
+- :gh:`1346`, [SunOS]: :func:`net_connections` returns an empty list. (patch by
+  Oleksii Shevchuk)
+
+5.4.7 — 2018-08-14
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`1309`, [Linux]: added :data:`STATUS_PARKED` constant for
+  :meth:`Process.status`.
+
+**API changes**
+
+- :gh:`1286`, [macOS]: :data:`OSX` constant is now deprecated in favor of new
+  :data:`MACOS`.
+- :gh:`1321`, [Linux]: :func:`disk_io_counters` falls back to ``/sys/block`` if
+  :proc:`/proc/diskstats` is not available. (patch by
+  :user:`Lawrence Ye <LEAFERx>`)
+
+**Bug fixes**
+
+- :gh:`1209`, [macOS]: :meth:`Process.memory_maps` may fail with ``EINVAL`` due
+  to poor ``task_for_pid()`` syscall. :exc:`AccessDenied` is now raised
+  instead.
+- :gh:`1278`, [macOS]: :meth:`Process.threads` incorrectly return microseconds
+  instead of seconds. (patch by :user:`Nikhil Marathe <nikhilm>`)
+- :gh:`1279`, [Linux], [macOS], [BSD]: :func:`net_if_stats` may return
+  ``ENODEV``.
+- :gh:`1294`, [Windows]: :meth:`Process.connections` may sometime fail with
+  :exc:`MemoryError`. (patch by :user:`sylvainduchesne`)
+- :gh:`1305`, [Linux]: :func:`disk_io_counters` may report inflated r/w bytes
+  values.
+- :gh:`1309`, [Linux]: :meth:`Process.status` is unable to recognize
+  :field:`idle` and :field:`parked` statuses (returns ``"?"``).
+- :gh:`1313`, [Linux]: :func:`disk_io_counters` can report inflated values due
+  to counting base disk device and its partition(s) twice.
+- :gh:`1323`, [Linux]: :func:`sensors_temperatures` may fail with
+  :exc:`ValueError`.
+
+5.4.6 — 2018-06-07
+^^^^^^^^^^^^^^^^^^
+
+**API changes**
+
+- :gh:`1273`: :func:`net_if_addrs` named tuple's name has been renamed from
+  ``snic`` to ``snicaddr``.
+
+**Bug fixes**
+
+- :gh:`1258`, [Windows], :label:`critical`: :meth:`Process.username` may cause
+  a segfault (Python interpreter crash). (patch by
+  :user:`Jean-Luc Migot <jmigot-tehtris>`)
+- :gh:`1274`, [Linux]: there was a small chance :meth:`Process.children` may
+  swallow :exc:`AccessDenied` exceptions.
+
+5.4.5 — 2018-04-13
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`1268`: setup.py's ``extra_require`` parameter requires latest setuptools
+  version, breaking quite a lot of installations.
+
+5.4.4 — 2018-04-13
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`1239`, [Linux]: expose kernel :field:`slab` memory field for
+  :func:`virtual_memory`. (patch by :user:`Maxime Mouial <hush-hush>`)
+
+**API changes**
+
+- :gh:`771`, [Windows], :label:`breaking`: :func:`cpu_count` with
+  ``logical=False`` on Windows XP and Vista is no longer supported and returns
+  ``None``.
+
+**Bug fixes**
+
+- :gh:`1194`, [SunOS], :label:`critical`: fix double ``free()`` in
+  :meth:`Process.cpu_num`. (patch by Georg Sauthoff)
+- :gh:`694`, [SunOS]: :meth:`Process.cmdline` could be truncated at the 15th
+  character when reading it from ``/proc``. An extra effort is made by reading
+  it from process address space first. (patch by
+  :user:`Georg Sauthoff <gsauthof>`)
+- :gh:`771`, [Windows]: :func:`cpu_count` (both logical and cores) return a
+  wrong (smaller) number on systems using process groups (> 64 cores).
+- :gh:`771`, [Windows]: :func:`cpu_times` with ``percpu=True`` return fewer
+  CPUs on systems using process groups (> 64 cores).
+- :gh:`771`, [Windows]: :func:`cpu_stats` and :func:`cpu_freq` may return
+  incorrect results on systems using process groups (> 64 cores).
+- :gh:`1193`, [SunOS]: return uid/gid from ``/proc/pid/psinfo`` if there aren't
+  enough permissions for ``/proc/pid/cred``. (patch by
+  :user:`Georg Sauthoff <gsauthof>`)
+- :gh:`1194`, [SunOS]: return nice value from ``psinfo`` as ``getpriority()``
+  doesn't support real-time processes. (patch by
+  :user:`Georg Sauthoff <gsauthof>`)
+- :gh:`1194`, [SunOS]: fix undefined behavior related to strict-aliasing rules
+  and warnings. (patch by :user:`Georg Sauthoff <gsauthof>`)
+- :gh:`1210`, [Linux]: :func:`cpu_percent` steal time may remain stuck at 100%
+  due to Linux erroneously reporting a decreased steal time between calls.
+  (patch by :user:`Arnon Yaari <wiggin15>`)
+- :gh:`1216`, [Windows]: fix compatibility with Python 2.6 (patch by
+  :user:`Dan Vinakovsky <hexaclock>`)
+- :gh:`1222`, [Linux]: :meth:`Process.memory_full_info` was erroneously summing
+  "Swap:" and "SwapPss:". Same for "Pss:" and "SwapPss". Not anymore.
+- :gh:`1224`, [Windows]: :meth:`Process.wait` may erroneously raise
+  :exc:`TimeoutExpired`.
+- :gh:`1238`, [Linux]: :func:`sensors_battery` may return ``None`` in case
+  battery is not listed as "BAT0" under ``/sys/class/power_supply``.
+- :gh:`1240`, [Windows]: :func:`cpu_times` float loses accuracy in a long
+  running system. (patch by :user:`stswandering <stswandering>`)
+- :gh:`1245`, [Linux]: :func:`sensors_temperatures` may fail with
+  :exc:`IOError` "no such file".
+- :gh:`1255`, [FreeBSD]: :func:`swap_memory` stats were erroneously represented
+  in KB. (patch by :user:`Denis Krienbühl <href>`)
+
+5.4.3 — 2018-01-01
+^^^^^^^^^^^^^^^^^^
+
+**API changes**
+
+- :gh:`775`, [Windows]: :func:`disk_partitions` return mount points.
+
+**Bug fixes**
+
+- :gh:`1190`, [macOS]: :func:`pids` may return ``False`` on macOS.
+
+5.4.2 — 2017-12-07
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`1173`: add :envvar:`PSUTIL_DEBUG` environment variable to print debug
+  messages on stderr.
+- :gh:`1177`, [macOS]: added support for :func:`sensors_battery`. (patch by
+  Arnon Yaari)
+
+**API changes**
+
+- :gh:`1188`: ``Process.memory_info_ex()`` now warns with :exc:`FutureWarning`
+  instead of :exc:`DeprecationWarning`.
+
+**Performance**
+
+- :gh:`1183`: :meth:`Process.children` is **2x faster** on POSIX and
+  **2.4x faster** on Linux.
+
+**Internals**
+
+- :gh:`1172`, [Windows]: ``make test`` does not work.
+
+**Bug fixes**
+
+- :gh:`1152`, [Windows]: :func:`disk_io_counters` may return an empty dict.
+- :gh:`1169`, [Linux]: :func:`users` ``hostname`` returns username instead.
+  (patch by :user:`janderbrain <janderbrain>`)
+- :gh:`1179`, [Linux]: :meth:`Process.cmdline` can now split args for processes
+  that overwrite :proc:`/proc/pid/cmdline` with spaces instead of null bytes.
+- :gh:`1181`, [macOS]: :meth:`Process.memory_maps` may raise ``ENOENT``.
+- :gh:`1187`, [macOS]: :func:`pids` does not return PID 0 on recent macOS
+  versions.
+
+5.4.1 — 2017-11-08
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`1164`, [AIX]: add support for :meth:`Process.num_ctx_switches`. (patch
+  by Arnon Yaari)
+
+**Internals**
+
+- :gh:`1151`: ``python -m psutil.tests`` fail.
+
+**Dropped support**
+
+- :gh:`1053`, :label:`breaking`: drop Python 3.3 support (psutil still works
+  but it's no longer tested).
+
+**Bug fixes**
+
+- :gh:`1154`, [AIX], :label:`build-fail`: psutil won't compile on AIX 6.1.0.
+  (patch by Arnon Yaari)
+- :gh:`1150`, [Windows]: when a process is terminated now the exit code is set
+  to ``SIGTERM`` instead of ``0``. (patch by :user:`Akos Kiss <akosthekiss>`)
+- :gh:`1167`, [Windows]: :func:`net_io_counters` packets count now include also
+  non-unicast packets. (patch by :user:`Matthew Long <matray>`)
+
+5.4.0 — 2017-10-12
+^^^^^^^^^^^^^^^^^^
+
+**New platforms**
+
+- :gh:`1123`, [AIX]: added support for AIX platform. (patch by
+  :user:`Arnon Yaari <wiggin15>`)
+
+**Bug fixes**
+
+- :gh:`1127`, [macOS], :label:`critical`: invalid reference counting in
+  :meth:`Process.open_files` may lead to segfault. (patch by
+  :user:`Jakub Bacic <jakub-bacic>`)
+- :gh:`1133`, [Windows], :label:`build-fail`: can't compile on newer versions
+  of Visual Studio 2017 15.4. (patch by :user:`Max Bélanger <maxbelanger>`)
+- :gh:`1138`, [Linux], :label:`build-fail`: can't compile on CentOS 5.0 and
+  RedHat 5.0. (patch by Prodesire)
+- :gh:`1009`, [Linux]: :func:`sensors_temperatures` may crash with
+  :exc:`IOError`.
+- :gh:`1012`, [Windows]: :func:`disk_io_counters` :field:`read_time` and
+  :field:`write_time` were expressed in tens of micro seconds instead of
+  milliseconds.
+- :gh:`1129`, [Linux]: :func:`sensors_fans` may crash with :exc:`IOError`.
+  (patch by :user:`Sebastian Saip <ssaip>`)
+- :gh:`1131`, [SunOS]: fix compilation warnings. (patch by
+  :user:`Arnon Yaari <wiggin15>`)
+
+5.3.1 — 2017-09-10
+^^^^^^^^^^^^^^^^^^
+
+**Build and packaging**
+
+- :gh:`1120`, [Windows], :label:`breaking`: ``.exe`` files are no longer
+  uploaded on PyPI as per PEP-527. Only wheels are provided.
+
+**Documentation**
+
+- :gh:`1124`: documentation moved to http://psutil.readthedocs.io
+
+**Bug fixes**
+
+- :gh:`1105`, [FreeBSD], :label:`build-fail`: psutil does not compile on
+  FreeBSD 12.
+- :gh:`1125`, [BSD]: :func:`net_connections` raises :exc:`TypeError`.
+
+5.3.0 — 2017-09-01
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`802`: :func:`disk_io_counters` and :func:`net_io_counters` no longer
+  wrap (restart from 0). New *nowrap* argument.
+- :gh:`1022`: :func:`users` provides a new :field:`pid` field.
+- :gh:`1025`: :func:`process_iter` accepts new *attrs* and *ad_value*
+  parameters to invoke :meth:`Process.as_dict` inline.
+- :gh:`1051`: :func:`disk_usage` on Python 3 is now able to accept bytes.
+- :gh:`1091`, [SunOS]: implemented :meth:`Process.environ`. (patch by
+  :user:`Oleksii Shevchuk <alxchk>`)
+
+**API changes**
+
+- :gh:`1039`, :label:`breaking`: returned types consolidation. 1) Windows /
+  :meth:`Process.cpu_times`: fields #3 and #4 were int instead of float. 2)
+  Linux / FreeBSD / OpenBSD: :meth:`Process.connections` :field:`raddr` is now
+  set to ``""`` instead of ``None`` when retrieving UNIX sockets.
+- :gh:`1040`, :label:`breaking`: all strings are encoded by using OS fs
+  encoding.
+- :gh:`1040`, :label:`breaking`: the following Windows APIs on Python 2 now
+  return a string instead of unicode: :meth:`Process.memory_maps`'s
+  :field:`path` field, :meth:`WindowsService.binpath`,
+  :meth:`WindowsService.description`, :meth:`WindowsService.display_name`,
+  :meth:`WindowsService.username`.
+- :gh:`928`: :func:`net_connections` and :meth:`Process.connections`
+  :field:`laddr` and :field:`raddr` are now named tuples.
+- :gh:`1015`: :func:`swap_memory` now reads :proc:`/proc/meminfo` instead of
+  ``sysinfo()`` syscall, so it works with :data:`PROCFS_PATH` for containers.
+- :gh:`1040`: implemented full unicode support.
+- :gh:`1079`, [FreeBSD]: :func:`net_connections` :field:`fd` number is now
+  being set for real (instead of ``-1``). (patch by
+  :user:`Gleb Smirnoff <glebius>`)
+
+**Build and packaging**
+
+- :gh:`1060`: source distribution now only includes relevant files.
+
+**Internals**
+
+- :gh:`1058`: test suite now enables all warnings by default.
+
+**Bug fixes**
+
+- :gh:`1064`, [NetBSD], :label:`critical`: :func:`swap_memory` may segfault in
+  case of error.
+- :gh:`1042`, [FreeBSD], :label:`build-fail`: psutil won't compile on FreeBSD
+  12.
+- :gh:`1033`, [macOS], [FreeBSD], :label:`memleak`: memory leak for
+  :func:`net_connections` and :meth:`Process.connections` when retrieving UNIX
+  sockets (``kind='unix'``).
+- :gh:`1047`, [Windows], :label:`memleak`: :meth:`Process.username`: memory
+  leak in case exception is thrown.
+- :gh:`1050`, [Windows], :label:`memleak`: :meth:`Process.memory_maps` leaks
+  memory.
+- :gh:`1067`, [NetBSD], :label:`memleak`: :meth:`Process.cmdline` leaks memory
+  if process has terminated.
+- :gh:`1068`, [OpenBSD], :label:`memleak`: :func:`net_connections` leaks memory
+  if ``sysctl()`` fails.
+- :gh:`989`, [Windows]: :func:`boot_time` may return a negative value.
+- :gh:`1007`, [Windows]: :func:`boot_time` can have a 1 sec fluctuation between
+  calls. The first call value is now cached.
+- :gh:`1013`, [FreeBSD]: :func:`net_connections` may return incorrect PID.
+  (patch by :user:`Gleb Smirnoff <glebius>`)
+- :gh:`1014`, [Linux]: :class:`Process` class can mask legitimate ``ENOENT``
+  exceptions as :exc:`NoSuchProcess`.
+- :gh:`1016`: :func:`disk_io_counters` raises :exc:`RuntimeError` on a system
+  with no disks.
+- :gh:`1017`: :func:`net_io_counters` raises :exc:`RuntimeError` on a system
+  with no network cards installed.
+- :gh:`1021`, [Linux]: :meth:`Process.open_files` may erroneously raise
+  :exc:`NoSuchProcess` instead of skipping a file which gets deleted while open
+  files are retrieved.
+- :gh:`1029`, [macOS], [FreeBSD]: :meth:`Process.connections` with
+  ``family=unix`` on Python 3 doesn't properly handle unicode paths and may
+  raise :exc:`UnicodeDecodeError`.
+- :gh:`1040`: fixed many unicode related issues such as
+  :exc:`UnicodeDecodeError` on Python 3 + POSIX and invalid encoded data on
+  Windows.
+- :gh:`1044`, [macOS]: different :class:`Process` methods incorrectly raise
+  :exc:`AccessDenied` for zombie processes.
+- :gh:`1046`, [Windows]: :func:`disk_partitions` on Windows overrides user's
+  ``SetErrorMode``.
+- :gh:`1048`, [Windows]: :func:`users`'s :field:`host` field report an invalid
+  IP address.
+- :gh:`1055`: :func:`cpu_count` is no longer cached (CPUs can be disabled at
+  runtime on Linux). :meth:`Process.cpu_percent` also affected.
+- :gh:`1058`: fixed Python warnings.
+- :gh:`1062`: :func:`disk_io_counters` and :func:`net_io_counters` raise
+  :exc:`TypeError` if no disks or NICs are installed on the system.
+- :gh:`1063`, [NetBSD]: :func:`net_connections` may list incorrect sockets.
+- :gh:`1065`, [OpenBSD]: :meth:`Process.cmdline` may raise :exc:`SystemError`.
+- :gh:`1069`, [FreeBSD]: :meth:`Process.cpu_num` may return 255 for certain
+  kernel processes.
+- :gh:`1071`, [Linux]: :func:`cpu_freq` may raise :exc:`IOError` on old RedHat
+  distros.
+- :gh:`1074`, [FreeBSD]: :func:`sensors_battery` raises :exc:`OSError` in case
+  of no battery.
+- :gh:`1075`, [Windows]: :func:`net_if_addrs`: ``inet_ntop()`` return value is
+  not checked.
+- :gh:`1077`, [SunOS]: :func:`net_if_addrs` shows garbage addresses on SunOS
+  5.10. (patch by :user:`Oleksii Shevchuk <alxchk>`)
+- :gh:`1077`, [SunOS]: :func:`net_connections` does not work on SunOS 5.10.
+  (patch by :user:`Oleksii Shevchuk <alxchk>`)
+- :gh:`1079`, [FreeBSD]: :func:`net_connections` didn't list locally connected
+  sockets. (patch by :user:`Gleb Smirnoff <glebius>`)
+- :gh:`1085`: :func:`cpu_count` return value is now checked and forced to
+  ``None`` if <= 1.
+- :gh:`1087`: :meth:`Process.cpu_percent` guard against :func:`cpu_count`
+  returning ``None`` and assumes 1 instead.
+- :gh:`1093`, [SunOS]: :meth:`Process.memory_maps` shows wrong 64 bit
+  addresses.
+- :gh:`1094`, [Windows]: fix :func:`pid_exists` returning wrong result. All
+  ``OpenProcess`` APIs now verify the PID is actually running.
+- :gh:`1098`, [Windows]: :meth:`Process.wait` may erroneously return sooner,
+  when the PID is still alive.
+- :gh:`1099`, [Windows]: :meth:`Process.terminate` may raise
+  :exc:`AccessDenied` even if the process already died.
+- :gh:`1101`, [Linux]: :func:`sensors_temperatures` may raise ``ENODEV``.
+
+5.2.2 — 2017-04-10
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`1000`: fixed some setup.py warnings.
+- :gh:`1002`, [SunOS]: remove C macro which will not be available on new
+  Solaris versions. (patch by :user:`Danek Duvall <dhduvall>`)
+- :gh:`1004`, [Linux]: :meth:`Process.io_counters` may raise :exc:`ValueError`.
+- :gh:`1006`, [Linux]: :func:`cpu_freq` may return ``None`` on some Linux
+  versions does not support the function. Let's not make the function available
+  instead.
+- :gh:`1009`, [Linux]: :func:`sensors_temperatures` may raise :exc:`OSError`.
+- :gh:`1010`, [Linux]: :func:`virtual_memory` may raise :exc:`ValueError` on
+  Ubuntu 14.04.
+
+5.2.1 — 2017-03-24
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`981`, [Linux]: :func:`cpu_freq` may return an empty list.
+- :gh:`993`, [Windows]: :meth:`Process.memory_maps` on Python 3 may raise
+  :exc:`UnicodeDecodeError`.
+- :gh:`996`, [Linux]: :func:`sensors_temperatures` may not show all
+  temperatures.
+- :gh:`997`, [FreeBSD]: :func:`virtual_memory` may fail due to missing
+  ``sysctl`` parameter on FreeBSD 12.
+
+5.2.0 — 2017-03-05
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`974`, [Linux]: Add :func:`sensors_fans` function. (patch by
+  :user:`Nicolas Hennion <nicolargo>`)
+- :gh:`976`, [Windows]: :meth:`Process.io_counters` has 2 new fields:
+  :field:`other_count` and :field:`other_bytes`.
+- :gh:`976`, [Linux]: :meth:`Process.io_counters` has 2 new fields:
+  :field:`read_chars` and :field:`write_chars`.
+
+**Bug fixes**
+
+- :gh:`985`, [Windows], :label:`critical`: Fix a crash in
+  :meth:`Process.open_files` when the worker thread for ``NtQueryObject`` times
+  out.
+- :gh:`872`, [Linux], :label:`build-fail`: can now compile on Linux by using
+  MUSL C library.
+- :gh:`986`, [Linux]: :meth:`Process.cwd` may raise :exc:`NoSuchProcess`
+  instead of :exc:`ZombieProcess`.
+
+5.1.3 — 2017-02-07
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`971`, [Linux]: :func:`sensors_temperatures` didn't work on CentOS 7.
+- :gh:`973`: :func:`cpu_percent` may raise :exc:`ZeroDivisionError`.
+
+5.1.2 — 2017-02-03
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`966`, [Linux]: :func:`sensors_battery` :field:`power_plugged` may
+  erroneously return ``None`` on Python 3.
+- :gh:`968`, [Linux]: :func:`disk_io_counters` raises :exc:`TypeError` on
+  Python 3.
+- :gh:`970`, [Linux]: :func:`sensors_battery` :field:`name` and :field:`label`
+  fields on Python 3 are bytes instead of str.
+
+5.1.1 — 2017-02-03
+^^^^^^^^^^^^^^^^^^
+
+**API changes**
+
+- :gh:`966`, [Linux]: :func:`sensors_battery` :field:`percent` is a float and
+  is more precise.
+
+**Bug fixes**
+
+- :gh:`964`, [Windows]: :meth:`Process.username` and :func:`users` may return
+  badly decoded character on Python 3.
+- :gh:`965`, [Linux]: :func:`disk_io_counters` may miscalculate sector size and
+  report the wrong number of bytes read and written.
+- :gh:`966`, [Linux]: :func:`sensors_battery` may fail with
+  :exc:`FileNotFoundError`.
+- :gh:`966`, [Linux]: :func:`sensors_battery` :field:`power_plugged` may lie.
+
+5.1.0 — 2017-02-01
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`357`: added :meth:`Process.cpu_num` (what CPU a process is on).
+- :gh:`371`, [Linux]: added :func:`sensors_temperatures`.
+- :gh:`941`: added :func:`cpu_freq` (CPU frequency).
+- :gh:`955`, [Linux], [Windows]: added :func:`sensors_battery`.
+- :gh:`956`: :meth:`Process.cpu_affinity` can now be passed ``[]`` argument as
+  an alias to set affinity against all eligible CPUs.
+
+**Bug fixes**
+
+- :gh:`948`, :label:`build-fail`: cannot install psutil with
+  ``PYTHONOPTIMIZE=2``.
+- :gh:`687`, [Linux]: :func:`pid_exists` no longer returns ``True`` if passed a
+  process thread ID.
+- :gh:`950`, [Windows]: :meth:`Process.cpu_percent` was calculated incorrectly
+  and showed higher number than real usage.
+- :gh:`951`, [Windows]: the uploaded wheels for Python 3.6 64 bit didn't work.
+- :gh:`959`: psutil exception objects could not be pickled.
+- :gh:`960`: :class:`Popen` ``wait()`` did not return the correct negative exit
+  status if process is killed by a signal.
+- :gh:`961`, [Windows]: :meth:`WindowsService.description` method may fail with
+  ``ERROR_MUI_FILE_NOT_FOUND``.
+
+5.0.1 — 2016-12-21
+^^^^^^^^^^^^^^^^^^
+
+**Build and packaging**
+
+- :gh:`939`: tar.gz distribution went from 1.8M to 258K.
+
+**Bug fixes**
+
+- :gh:`609`, [SunOS], :label:`build-fail`: psutil does not compile on Solaris
+  10.
+- :gh:`936`, [Windows], :label:`build-fail`: fix compilation error on VS 2013
+  (patch by :user:`Max Bélanger <maxbelanger>`).
+- :gh:`811`, [Windows]: provide a more meaningful error message if trying to
+  use psutil on unsupported Windows XP.
+- :gh:`940`, [Linux]: :func:`cpu_percent` and :func:`cpu_times_percent` was
+  calculated incorrectly as :field:`iowait`, :field:`guest` and
+  :field:`guest_nice` times were not properly taken into account.
+- :gh:`944`, [OpenBSD]: :func:`pids` was omitting PID 0.
+
+5.0.0 — 2016-11-06
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`799`: new :meth:`Process.oneshot` context manager (**+2x faster** in
+  general, **+2x to +6x** on Windows).
+
+**Bug fixes**
+
+- :gh:`933`, [Windows], :label:`memleak`: memory leak in :func:`cpu_stats` and
+  :meth:`WindowsService.description` method.
+- :gh:`932`, [NetBSD]: :func:`net_connections` and :meth:`Process.connections`
+  may fail without raising an exception.
+- :gh:`943`: better error message in case of version conflict on import.
+
+4.4.2 — 2016-10-26
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`931`, [SunOS], :label:`build-fail`: psutil no longer compiles on
+  Solaris.
+
+4.4.1 — 2016-10-25
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`927`: :class:`Popen` ``__del__`` may cause maximum recursion depth
+  error.
+
+4.4.0 — 2016-10-23
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`874`, [Windows]: make :func:`net_if_addrs` also return the
+  :field:`netmask`.
+
+**API changes**
+
+- :gh:`887`, [Linux]: :func:`virtual_memory` :field:`available` and
+  :field:`used` are more precise and match ``free`` utility. Also handles LXC
+  containers.
+
+**Internals**
+
+- :gh:`891`: :src:`scripts/procinfo.py` has been updated and provides a lot
+  more info.
+
+**Bug fixes**
+
+- :gh:`514`, [macOS], :label:`critical`: :meth:`Process.memory_maps` can
+  segfault.
+- :gh:`926`, [macOS], :label:`critical`: :meth:`Process.environ` can crash the
+  interpreter on Python 3 if the process environment contains an invalid
+  unicode string.
+- :gh:`783`, [macOS]: :meth:`Process.status` may erroneously return
+  :data:`STATUS_RUNNING` for zombie processes.
+- :gh:`798`, [Windows]: :meth:`Process.open_files` returns and empty list on
+  Windows 10.
+- :gh:`825`, [Linux]: :meth:`Process.cpu_affinity`: fix possible double close
+  and use of unopened socket.
+- :gh:`880`, [Windows]: fix race condition inside :func:`net_connections`.
+- :gh:`885`: :exc:`ValueError` is raised if a negative integer is passed to
+  :func:`cpu_percent` functions.
+- :gh:`892`, [Linux]: :meth:`Process.cpu_affinity` with ``[-1]`` as arg raises
+  :exc:`SystemError` with no error set; now :exc:`ValueError` is raised.
+- :gh:`906`, [BSD]: :func:`disk_partitions` with ``all=False`` returned an
+  empty list. Now the argument is ignored and all partitions are always
+  returned.
+- :gh:`907`, [FreeBSD]: :meth:`Process.exe` may fail with :exc:`OSError`
+  ``ENOENT``.
+- :gh:`908`, [macOS], [BSD]: different process methods could errounesuly mask
+  the real error for high-privileged PIDs and raise :exc:`NoSuchProcess` and
+  :exc:`AccessDenied` instead of :exc:`OSError` and :exc:`RuntimeError`.
+- :gh:`909`, [macOS]: :meth:`Process.open_files` and
+  :meth:`Process.connections` methods may raise :exc:`OSError` with no
+  exception set if process is gone.
+- :gh:`916`, [macOS]: fix many compilation warnings.
+
+4.3.1 — 2016-09-01
+^^^^^^^^^^^^^^^^^^
+
+**Build and packaging**
+
+- :gh:`881`: ``make install`` now works also when using a virtual env.
+
+**Bug fixes**
+
+- :gh:`870`, [Windows], :label:`memleak`: handle leak inside
+  ``psutil_get_process_data``.
+- :gh:`854`: :meth:`Process.as_dict` raises :exc:`ValueError` if passed an
+  erroneous attrs name.
+- :gh:`857`, [SunOS]: :meth:`Process.cpu_times`, :meth:`Process.cpu_percent`,
+  :meth:`Process.threads` and :meth:`Process.memory_maps` may raise
+  :exc:`RuntimeError` if attempting to query a 64bit process with a 32bit
+  Python. "Null" values are returned as a fallback.
+- :gh:`858`: :meth:`Process.as_dict` should not call
+  ``Process.memory_info_ex()`` because it's deprecated.
+- :gh:`863`, [Windows]: :meth:`Process.memory_maps` truncates addresses above
+  32 bits.
+- :gh:`866`, [Windows]: :func:`win_service_iter` and services in general are
+  not able to handle unicode service names / descriptions.
+- :gh:`869`, [Windows]: :meth:`Process.wait` may raise :exc:`TimeoutExpired`
+  with wrong timeout unit (ms instead of sec).
+
+4.3.0 — 2016-06-18
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`812`, [NetBSD], :label:`build-fail`: fix compilation on NetBSD-5.x.
+- :gh:`810`, [Windows]: Windows wheels are incompatible with pip 7.1.2.
+- :gh:`823`, [NetBSD]: :func:`virtual_memory` raises :exc:`TypeError` on Python
+  3.
+- :gh:`829`, [POSIX]: :func:`disk_usage` :field:`percent` field takes root
+  reserved space into account.
+- :gh:`816`, [Windows]: fixed :func:`net_io_counters` values wrapping after
+  4.3GB in Windows Vista (NT 6.0) and above using 64bit values from newer win
+  APIs.
+
+4.2.0 — 2016-05-14
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`795`, [Windows]: new APIs to deal with Windows services:
+  :func:`win_service_iter` and :func:`win_service_get`.
+- :gh:`800`, [Linux]: :func:`virtual_memory` returns a new :field:`shared`
+  field.
+
+**Performance**
+
+- :gh:`819`, [Linux]: speedup ``/proc`` parsing: :meth:`Process.ppid` +20%
+  faster. :meth:`Process.status` **+28% faster**. :meth:`Process.name`
+  **+25% faster**. :meth:`Process.num_threads` **+20% faster** on Python 3.
+
+**Bug fixes**
+
+- :gh:`797`, [Linux]: :func:`net_if_stats` may raise :exc:`OSError` for certain
+  NIC cards.
+- :gh:`813`: :meth:`Process.as_dict` should ignore extraneous attribute names
+  which gets attached to the :class:`Process` instance.
+
+4.1.0 — 2016-03-12
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`777`, [Linux]: :meth:`Process.open_files` on Linux return 3 new fields:
+  :field:`position`, :field:`mode` and :field:`flags`.
+- :gh:`779`: :meth:`Process.cpu_times` returns two new fields,
+  :field:`children_user` and :field:`children_system` (always set to 0 on macOS
+  and Windows).
+- :gh:`789`, [Windows]: :func:`cpu_times` return two new fields:
+  :field:`interrupt` and :field:`dpc`. Same for :func:`cpu_times_percent`.
+- :gh:`792`: new :func:`cpu_stats` function returning number of CPU
+  :field:`ctx_switches`, :field:`interrupts`, :field:`soft_interrupts` and
+  :field:`syscalls`.
+
+**Bug fixes**
+
+- :gh:`780`, [macOS], :label:`build-fail`: psutil does not compile with some
+  GCC versions.
+- :gh:`790`, [macOS], :label:`build-fail`: psutil won't compile on macOS 10.4.
+- :gh:`774`, [FreeBSD]: :func:`net_io_counters` dropout is no longer set to 0
+  if the kernel provides it.
+- :gh:`776`, [Linux]: :meth:`Process.cpu_affinity` may erroneously raise
+  :exc:`NoSuchProcess`. (patch by :user:`wxwright`)
+- :gh:`786`: :func:`net_if_addrs` may report incomplete MAC addresses.
+- :gh:`788`, [NetBSD]: :func:`virtual_memory` :field:`buffers` and
+  :field:`shared` values were set to 0.
+
+4.0.0 — 2016-02-17
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`523`, [Linux], [FreeBSD]: :func:`disk_io_counters` return a new
+  :field:`busy_time` field.
+- :gh:`732`: :meth:`Process.environ`. (patch by
+  :user:`Frank Benkstein <fbenkstein>`)
+- :gh:`753`, [Linux], [macOS], [Windows]: process :term:`USS` and :term:`PSS`
+  (Linux) "real" memory stats. (patch by :user:`Eric Rahm <EricRahm>`)
+- :gh:`755`: :meth:`Process.memory_percent` ``memtype`` parameter.
+- :gh:`760`: expose OS constants (:data:`LINUX`, :data:`OSX`, etc.)
+- :gh:`756`, [Linux]: :func:`disk_io_counters` return 2 new fields:
+  :field:`read_merged_count` and :field:`write_merged_count`.
+
+**Build and packaging**
+
+- :gh:`660`, [Windows]: make.bat is smarter in finding alternative VS install
+  locations. (patch by :user:`mpderbec`)
+
+**Internals**
+
+- :gh:`758`: tests now live in psutil namespace.
+- :gh:`762`: add :src:`scripts/procsmem.py`.
+
+**Bug fixes**
+
+- :gh:`751`, [Linux], :label:`critical`: fixed call to ``Py_DECREF`` on
+  possible ``NULL`` object.
+- :gh:`704`, [SunOS], :label:`build-fail`: psutil does not compile on Solaris
+  sparc.
+- :gh:`741`, [OpenBSD], :label:`build-fail`: psutil does not compile on mips64.
+- :gh:`764`, [NetBSD], :label:`build-fail`: fix compilation on NetBSD-6.x.
+- :gh:`685`, [Linux]: :func:`virtual_memory` provides wrong results on systems
+  with a lot of physical memory.
+- :gh:`734`: on Python 3 invalid UTF-8 data is not correctly handled for
+  :meth:`Process.name`, :meth:`Process.cwd`, :meth:`Process.exe`,
+  :meth:`Process.cmdline` and :meth:`Process.open_files` methods resulting in
+  :exc:`UnicodeDecodeError` exceptions. ``'surrogateescape'`` error handler is
+  now used as a workaround for replacing the corrupted data.
+- :gh:`737`, [Windows]: when the bitness of psutil and the target process was
+  different, :meth:`Process.cmdline` and :meth:`Process.cwd` could return a
+  wrong result or incorrectly report an :exc:`AccessDenied` error.
+- :gh:`754`, [Linux]: :meth:`Process.cmdline` can be wrong in case of zombie
+  process.
+- :gh:`759`, [Linux]: :meth:`Process.memory_maps` may return paths ending with
+  ``" (deleted)"``.
+- :gh:`761`, [Windows]: :func:`boot_time` wraps to 0 after 49 days.
+- :gh:`766`, [Linux]: :func:`net_connections` can't handle malformed
+  ``/proc/net/unix`` file.
+- :gh:`767`, [Linux]: :func:`disk_io_counters` may raise :exc:`ValueError` on
+  2.6 kernels and it's broken on 2.4 kernels.
+- :gh:`770`, [NetBSD]: :func:`disk_io_counters` metrics didn't update.
+
+3.4.2 — 2016-01-20
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`728`, [SunOS]: exposed :data:`PROCFS_PATH` constant to change the
+  default location of ``/proc`` filesystem.
+
+**Bug fixes**
+
+- :gh:`724`, [FreeBSD]: :func:`virtual_memory` :field:`total` is incorrect.
+- :gh:`730`, [FreeBSD]: :func:`virtual_memory` crashes with "OSError: [Errno
+  12] Cannot allocate memory".
+
+3.4.1 — 2016-01-15
+^^^^^^^^^^^^^^^^^^
+
+**New platforms**
+
+- :gh:`557`, [NetBSD]: added NetBSD support. (contributed by Ryo Onodera and
+  Thomas Klausner)
+
+**API changes**
+
+- :gh:`718`: :func:`process_iter` is now thread safe.
+
+**Performance**
+
+- :gh:`708`, [Linux]: :func:`net_connections` and :meth:`Process.connections`
+  on Python 2 can be up to **3x faster** in case of many connections. Also
+  :meth:`Process.memory_maps` is slightly faster.
+
+**Bug fixes**
+
+- :gh:`715`, :label:`critical`: don't crash at import time if :func:`cpu_times`
+  fail for some reason.
+- :gh:`714`, [OpenBSD]: :func:`virtual_memory` :field:`cached` value was always
+  set to 0.
+- :gh:`717`, [Linux]: :meth:`Process.open_files` fails if deleted files still
+  visible.
+- :gh:`722`, [Linux]: :func:`swap_memory` no longer crashes if :field:`sin` /
+  :field:`sout` can't be determined due to missing :proc:`/proc/vmstat`.
+- :gh:`724`, [FreeBSD]: :func:`virtual_memory` :field:`total` is slightly
+  incorrect.
+
+3.3.0 — 2015-11-25
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`558`, [Linux]: exposed :data:`PROCFS_PATH` constant to change the
+  default location of ``/proc`` filesystem.
+
+**New platforms**
+
+- :gh:`615`, [OpenBSD]: added OpenBSD support.  (contributed by Landry Breuil)
+
+**Bug fixes**
+
+- :gh:`692`, [POSIX]: :meth:`Process.name` is no longer cached as it may
+  change.
+
+3.2.2 — 2015-10-04
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`610`, [SunOS], :label:`build-fail`: fix build and tests on Solaris 10
+- :gh:`678`, [Linux], :label:`build-fail`: can't install psutil due to bug in
+  setup.py.
+- :gh:`688`, [Windows], :label:`build-fail`: compilation fails with MSVC 2015,
+  Python 3.5. (patch by Mike Sarahan)
+- :gh:`690`, [Windows], :label:`build-fail`: can't compile with MSVC 2015,
+  which enforces the C++11 rule forbidding duplicate values in an unscoped
+  enum.
+- :gh:`517`, [SunOS]: :func:`net_io_counters` failed to detect network
+  interfaces correctly on Solaris 10
+- :gh:`541`, [FreeBSD]: :func:`disk_io_counters` r/w times were expressed in
+  seconds instead of milliseconds. (patch by :user:`dasumin <denis-sumin>`)
+- :gh:`623`, [Linux]: process or system connections raises :exc:`ValueError` if
+  IPv6 is not supported by the system.
+
+3.2.1 — 2015-09-03
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`677`, [Linux], :label:`build-fail`: can't install psutil due to bug in
+  setup.py.
+
+3.2.0 — 2015-09-02
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`644`, [Windows]: added support for ``CTRL_C_EVENT`` and
+  ``CTRL_BREAK_EVENT`` signals to use with :meth:`Process.send_signal`.
+
+**API changes**
+
+- :gh:`663`, [POSIX]: :func:`net_if_addrs` now returns point-to-point (VPNs)
+  addresses.
+- :gh:`655`, [Windows]: fix various unicode handling issues. On Python 2,
+  string APIs now return encoded strings using
+  :func:`sys.getfilesystemencoding`.
+
+**Internals**
+
+- :gh:`648`, [macOS]: CI test integration. (patch by
+  :user:`Jeff Tang <mrjefftang>`)
+
+**Bug fixes**
+
+- :gh:`670`, [Windows], :label:`critical`: segfault of :func:`net_if_addrs` in
+  case of non-ASCII NIC names. (patch by :user:`sk6249 <sk6249>`)
+- :gh:`659`, [Linux], :label:`build-fail`: compilation error on Suse 10. (patch
+  by :user:`maozguttman`)
+- :gh:`664`, [Linux], :label:`build-fail`: compilation error on Alpine Linux.
+  (patch by :user:`Bart van Kleef <bkleef>`)
+- :gh:`672`, [Windows], :label:`build-fail`: compilation fails if using Windows
+  SDK v8.0. (patch by Steven Winfield)
+- :gh:`513`, [Linux]: fixed integer overflow for :data:`RLIM_INFINITY`
+- :gh:`641`, [Windows]: fixed many compilation warnings. (patch by
+  :user:`Jeff Tang <mrjefftang>`)
+- :gh:`652`, [Windows]: :func:`net_if_addrs` :exc:`UnicodeDecodeError` in case
+  of non-ASCII NIC names.
+- :gh:`655`, [Windows]: :func:`net_if_stats` :exc:`UnicodeDecodeError` in case
+  of non-ASCII NIC names.
+- :gh:`675`, [Linux]: :func:`net_connections`: :exc:`UnicodeDecodeError` may
+  occur when listing UNIX sockets.
+
+3.1.1 — 2015-07-15
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`603`, [Linux]: :meth:`Process.ionice` set value range is incorrect.
+  (patch by :user:`spacewander <spacewander>`)
+- :gh:`645`, [Linux]: :func:`cpu_times_percent` may produce negative results.
+- :gh:`656`: ``from psutil import *`` does not work.
+
+3.1.0 — 2015-07-15
+^^^^^^^^^^^^^^^^^^
+
+**API changes**
+
+- :gh:`534`, [Linux]: :func:`disk_partitions` added support for ZFS
+  filesystems.
+
+**Documentation**
+
+- :gh:`647`: new dev guide:
+  https://github.com/giampaolo/psutil/blob/master/docs/devguide.rst
+
+**Internals**
+
+- :gh:`646`, [Windows]: continuous tests integration for Windows with
+  https://ci.appveyor.com/project/giampaolo/psutil.
+- :gh:`651`: continuous code quality test integration with scrutinizer-ci.com
+
+**Bug fixes**
+
+- :gh:`340`, [Windows], :label:`critical`: :meth:`Process.open_files` no longer
+  hangs (uses a thread with timeout). (patch by :user:`Jeff Tang <mrjefftang>`)
+- :gh:`627`, [Windows]: :meth:`Process.name` no longer raises
+  :exc:`AccessDenied` for pids owned by another user.
+- :gh:`636`, [Windows]: :meth:`Process.memory_info` raise :exc:`AccessDenied`.
+- :commit:`5ae30c79`, [POSIX]: raise exception if trying to send signal to PID
+  0 as it will affect :func:`os.getpid` 's process group and not PID 0.
+- :gh:`639`, [Linux]: :meth:`Process.cmdline` can be truncated.
+- :gh:`640`, [Linux]: ``*connections`` functions may swallow errors and return
+  an incomplete list of connections.
+- :gh:`642`: ``repr()`` of exceptions is incorrect.
+- :gh:`653`, [Windows]: add ``inet_ntop()`` function for Windows XP to support
+  IPv6.
+- :gh:`641`, [Windows]: replace deprecated string functions with safe
+  equivalents.
+
+3.0.1 — 2015-06-18
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`635`, [POSIX], :label:`critical`: crash on module import if :mod:`enum`
+  package is installed on Python < 3.4.
+- :gh:`632`, [Linux]: better error message if cannot parse process UNIX
+  connections.
+- :gh:`634`, [Linux]: :meth:`Process.cmdline` does not include empty string
+  arguments.
+
+3.0.0 — 2015-06-13
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`250`: new :func:`net_if_stats` returning NIC statistics (:field:`isup`,
+  :field:`duplex`, :field:`speed`, :field:`mtu`).
+- :gh:`376`: new :func:`net_if_addrs` returning all NIC addresses a-la
+  ``ifconfig``.
+
+**API changes**
+
+- :gh:`594`, :label:`breaking`: all deprecated APIs were removed.
+- :gh:`469`: on Python >= 3.4 ``IOPRIO_CLASS_*`` and ``*_PRIORITY_CLASS``
+  constants returned by :meth:`Process.ionice` and :meth:`Process.nice` are
+  enums instead of plain integers.
+- :gh:`582`: connection constants returned by :func:`net_connections` and
+  :meth:`Process.connections` were turned from int to enums on Python > 3.4.
+- :gh:`589`: :meth:`Process.cpu_affinity` accepts any kind of iterable (set,
+  tuple, ...), not only lists.
+- :gh:`599`, [Windows]: :meth:`Process.name` can now be determined for all
+  processes even when running as a limited user.
+
+**Build and packaging**
+
+- :gh:`587`: move native extension into the package.
+
+**Internals**
+
+- :gh:`581`: add ``.gitignore``. (patch by :user:`Gabi Davar <mindw>`)
+- :gh:`602`: pre-commit GIT hook.
+- :gh:`629`: enhanced support for ``pytest`` and ``nose`` test runners.
+- :gh:`616`, [Windows]: add ``inet_ntop()`` function for Windows XP.
+
+**Bug fixes**
+
+- :gh:`512`, [BSD], :label:`critical`: fix segfault in :func:`net_connections`.
+- :gh:`586`, [FreeBSD], :label:`critical`: :meth:`Process.cpu_affinity`
+  segfaults on set in case an invalid CPU number is provided.
+- :gh:`593`, [FreeBSD], :label:`critical`: :meth:`Process.memory_maps`
+  segfaults.
+- :gh:`607`, [Linux], :label:`build-fail`: can't compile on old RedHat versions
+  where ``DUPLEX_UNKNOWN`` is not defined.
+- :gh:`428`, [POSIX]: correct handling of zombie processes on POSIX. Introduced
+  new :exc:`ZombieProcess` exception class.
+- :gh:`555`, [Linux]: :func:`users` correctly handles ``":0"`` as an alias for
+  ``"localhost"``.
+- :gh:`579`, [Windows]: fixed :meth:`Process.open_files` for PID > 64K.
+- :gh:`579`, [Windows]: fixed many compiler warnings.
+- :gh:`585`, [FreeBSD]: :func:`net_connections` may raise :exc:`KeyError`.
+- :gh:`606`: :meth:`Process.parent` may swallow :exc:`NoSuchProcess`
+  exceptions.
+- :gh:`611`, [SunOS]: :func:`net_io_counters` has send and received swapped
+- :gh:`614`, [Linux]:: :func:`cpu_count` with ``logical=False`` return the
+  number of sockets instead of cores.
+- :gh:`618`, [SunOS]: swap tests fail on Solaris when run as normal user.
+- :gh:`628`, [Linux]: :meth:`Process.name` truncates string in case it contains
+  spaces or parentheses.
+
+2.2.1 — 2015-02-02
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`572`, [Linux]: fix "ValueError: ambiguous inode with multiple PIDs
+  references" for :meth:`Process.connections`. (patch by
+  :user:`Bruno Binet <bbinet>`)
+
+2.2.0 — 2015-01-06
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`569`, [FreeBSD]: add support for :meth:`Process.cpu_affinity` on
+  FreeBSD.
+
+**Internals**
+
+- :gh:`553`: add :src:`scripts/pstree.py`.
+- :gh:`568`: add :src:`scripts/pidof.py`.
+
+**Dropped support**
+
+- :gh:`521`, :label:`breaking`: drop support for Python 2.4 and 2.5.
+
+**Bug fixes**
+
+- :gh:`496`, [SunOS], :label:`critical`: can't import psutil.
+- :gh:`556`, [Linux], :label:`memleak`: lots of file handles were left open.
+- :gh:`569`, [FreeBSD], :label:`memleak`: fix memory leak in :func:`cpu_count`
+  with ``logical=False``.
+- :gh:`547`, [POSIX]: :meth:`Process.username` may raise :exc:`KeyError` if UID
+  can't be resolved.
+- :gh:`551`, [Windows]: get rid of the unicode hack for :func:`net_io_counters`
+  NIC names.
+- :gh:`561`, [Linux]: :func:`net_connections` might skip some legitimate UNIX
+  sockets. (patch by :user:`spacewander <spacewander>`)
+- :gh:`564`: C extension version mismatch is now detected at import time.
+- :gh:`565`, [Windows]: use proper encoding for :meth:`Process.username` and
+  :func:`users`. (patch by :user:`Sylvain Mouquet <sylvainmouquet>`)
+- :gh:`567`, [Linux]: in the alternative implementation of
+  :meth:`Process.cpu_affinity` ``PyList_Append`` and ``Py_BuildValue`` return
+  values are not checked.
+- :gh:`571`, [Linux]: :meth:`Process.open_files` might swallow
+  :exc:`AccessDenied` exceptions and return an incomplete list of open files.
+
+2.1.3 — 2014-09-26
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`536`, [Linux], :label:`build-fail`: fix "undefined symbol: CPU_ALLOC"
+  compilation error.
+
+2.1.2 — 2014-09-21
+^^^^^^^^^^^^^^^^^^
+
+**Build and packaging**
+
+- :gh:`505`, [Windows]: distribution as wheel packages.
+
+**Internals**
+
+- :gh:`407`: project moved from Google Code to Github; code moved from
+  Mercurial to Git.
+- :gh:`492`: use ``tox`` to run tests on multiple Python versions. (patch by
+  msabramo)
+- :gh:`511`: add :src:`scripts/ps.py`.
+
+**Bug fixes**
+
+- :gh:`340`, [Windows], :label:`critical`: :meth:`Process.open_files` no longer
+  hangs. (patch by Jeff Tang)
+- :gh:`501`, [Windows]: :func:`disk_io_counters` may return negative values.
+- :gh:`503`, [Linux]: in rare conditions :meth:`Process.exe`,
+  :meth:`Process.open_files` and :meth:`Process.connections` can raise
+  ``OSError(ESRCH)`` instead of :exc:`NoSuchProcess`.
+- :gh:`504`, [Linux]: can't build RPM packages via setup.py
+- :gh:`506`, [Linux]: Python 2.4 support was broken.
+- :gh:`522`, [Linux]: :meth:`Process.cpu_affinity` might return ``EINVAL``.
+  (patch by :user:`David Daeschler <ddaeschler>`)
+- :gh:`529`, [Windows]: :meth:`Process.exe` may raise unhandled
+  :exc:`WindowsError` exception for PIDs 0 and 4. (patch by
+  :user:`Jeff Tang <mrjefftang>`)
+- :gh:`530`, [Linux]: :func:`disk_io_counters` may crash on old Linux distros
+  (< 2.6.5) (patch by :user:`Yaolong Huang <airekans>`)
+- :gh:`533`, [Linux]: :meth:`Process.memory_maps` may raise :exc:`TypeError` on
+  old Linux distros.
+
+2.1.1 — 2014-04-30
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`446`, [Windows]: fix encoding error when using :func:`net_io_counters`
+  on Python 3. (patch by :user:`Szigeti Gabor Niif <gszigeti>`)
+- :gh:`460`, [Windows]: :func:`net_io_counters` wraps after 4G.
+- :gh:`497`, [Linux]: :func:`net_connections` exceptions. (patch by
+  :user:`Alexander Grothe <agrethe>`)
+
+2.1.0 — 2014-04-08
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`387`: system-wide open connections a-la ``netstat`` (add
+  :func:`net_connections`).
+
+**Bug fixes**
+
+- :gh:`421`, [SunOS], :label:`build-fail`: psutil does not compile on SunOS
+  5.10. (patch by Naveed Roudsari)
+- :gh:`489`, [Linux]: :func:`disk_partitions` return an empty list.
+
+2.0.0 — 2014-03-10
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`427`: add :func:`cpu_count`.
+
+**API changes**
+
+- :gh:`447`: :func:`wait_procs` *timeout* parameter is now optional.
+- :gh:`452`: make :class:`Process` instances hashable and usable with ``set()``
+  s.
+
+For the sake of consistency a lot of psutil APIs have been renamed. In most
+cases accessing the old names will work but it will cause a
+:exc:`DeprecationWarning`.
+
+- ``psutil.*`` module level constants have being replaced by functions:
+
+  +-----------------------+----------------------------------+
+  | Old name              | Replacement                      |
+  +=======================+==================================+
+  | psutil.NUM_CPUS       | psutil.cpu_count()               |
+  +-----------------------+----------------------------------+
+  | psutil.BOOT_TIME      | psutil.boot_time()               |
+  +-----------------------+----------------------------------+
+  | psutil.TOTAL_PHYMEM   | virtual_memory.total             |
+  +-----------------------+----------------------------------+
+
+- Renamed ``psutil.*`` functions:
+
+  +------------------------+-------------------------------+
+  | Old name               | Replacement                   |
+  +========================+===============================+
+  | psutil.get_pid_list()  | psutil.pids()                 |
+  +------------------------+-------------------------------+
+  | psutil.get_users()     | psutil.users()                |
+  +------------------------+-------------------------------+
+  | psutil.get_boot_time() | psutil.boot_time()            |
+  +------------------------+-------------------------------+
+
+- All :class:`Process` ``get_*`` methods lost the ``get_`` prefix. E.g.
+  ``get_ext_memory_info()`` was renamed to ``memory_info_ex()``. Assuming
+  ``p = psutil.Process()``:
+
+  +--------------------------+----------------------+
+  | Old name                 | Replacement          |
+  +==========================+======================+
+  | p.get_children()         | p.children()         |
+  +--------------------------+----------------------+
+  | p.get_connections()      | p.connections()      |
+  +--------------------------+----------------------+
+  | p.get_cpu_affinity()     | p.cpu_affinity()     |
+  +--------------------------+----------------------+
+  | p.get_cpu_percent()      | p.cpu_percent()      |
+  +--------------------------+----------------------+
+  | p.get_cpu_times()        | p.cpu_times()        |
+  +--------------------------+----------------------+
+  | p.get_ext_memory_info()  | p.memory_info_ex()   |
+  +--------------------------+----------------------+
+  | p.get_io_counters()      | p.io_counters()      |
+  +--------------------------+----------------------+
+  | p.get_ionice()           | p.ionice()           |
+  +--------------------------+----------------------+
+  | p.get_memory_info()      | p.memory_info()      |
+  +--------------------------+----------------------+
+  | p.get_memory_maps()      | p.memory_maps()      |
+  +--------------------------+----------------------+
+  | p.get_memory_percent()   | p.memory_percent()   |
+  +--------------------------+----------------------+
+  | p.get_nice()             | p.nice()             |
+  +--------------------------+----------------------+
+  | p.get_num_ctx_switches() | p.num_ctx_switches() |
+  +--------------------------+----------------------+
+  | p.get_num_fds()          | p.num_fds()          |
+  +--------------------------+----------------------+
+  | p.get_num_threads()      | p.num_threads()      |
+  +--------------------------+----------------------+
+  | p.get_open_files()       | p.open_files()       |
+  +--------------------------+----------------------+
+  | p.get_rlimit()           | p.rlimit()           |
+  +--------------------------+----------------------+
+  | p.get_threads()          | p.threads()          |
+  +--------------------------+----------------------+
+  | p.getcwd()               | p.cwd()              |
+  +--------------------------+----------------------+
+
+- All :class:`Process` ``set_*`` methods lost the ``set_`` prefix. Assuming
+  ``p = psutil.Process()``:
+
+  +----------------------+---------------------------------+
+  | Old name             | Replacement                     |
+  +======================+=================================+
+  | p.set_nice()         | p.nice(value)                   |
+  +----------------------+---------------------------------+
+  | p.set_ionice()       | p.ionice(ioclass, value=None)   |
+  +----------------------+---------------------------------+
+  | p.set_cpu_affinity() | p.cpu_affinity(cpus)            |
+  +----------------------+---------------------------------+
+  | p.set_rlimit()       | p.rlimit(resource, limits=None) |
+  +----------------------+---------------------------------+
+
+- Except for ``pid``, all :class:`Process` class properties have been turned
+  into methods. This is the only case which there are no aliases. Assuming
+  ``p = psutil.Process()``:
+
+  +---------------+-----------------+
+  | Old name      | Replacement     |
+  +===============+=================+
+  | p.name        | p.name()        |
+  +---------------+-----------------+
+  | p.parent      | p.parent()      |
+  +---------------+-----------------+
+  | p.ppid        | p.ppid()        |
+  +---------------+-----------------+
+  | p.exe         | p.exe()         |
+  +---------------+-----------------+
+  | p.cmdline     | p.cmdline()     |
+  +---------------+-----------------+
+  | p.status      | p.status()      |
+  +---------------+-----------------+
+  | p.uids        | p.uids()        |
+  +---------------+-----------------+
+  | p.gids        | p.gids()        |
+  +---------------+-----------------+
+  | p.username    | p.username()    |
+  +---------------+-----------------+
+  | p.create_time | p.create_time() |
+  +---------------+-----------------+
+
+- :gh:`479`, :label:`breaking`: long deprecated ``psutil.error`` module is
+  gone; exception classes now live in "psutil" namespace only.
+- :gh:`463`: *timeout* parameter of ``cpu_percent*`` functions defaults to 0.0
+  instead of 0.1, avoiding a common source of accidental slowdowns.
+- :class:`Process` instances' ``retcode`` attribute returned by
+  :func:`wait_procs` has been renamed to ``returncode`` for consistency with
+  :class:`subprocess.Popen`.
+
+**Performance**
+
+- :gh:`477`: :meth:`Process.cpu_percent` is about **30% faster**. (suggested by
+  crusaderky)
+- :gh:`478`, [Linux]: almost all APIs are about **30% faster** on Python 3.X.
+
+**Build and packaging**
+
+- :gh:`424`, [Windows]: installer for Python 3.X 64 bit.
+
+**Documentation**
+
+- :gh:`468`: move documentation to readthedocs.com.
+
+**Internals**
+
+- :gh:`453`: tests on Python < 2.7 require ``unittest2`` module.
+- :gh:`459`: add a Makefile for running tests and other repetitive tasks (also
+  on Windows).
+
+**Bug fixes**
+
+- :gh:`340`, [Windows], :label:`critical`: :meth:`Process.open_files` no longer
+  hangs. (patch by jtang@vahna.net)
+- :gh:`448`, [Windows], :label:`memleak`: :meth:`Process.children` and
+  :meth:`Process.ppid` memory leak (patch by Ulrich Klank).
+- :gh:`193`: :class:`Popen` constructor can throw an exception if the spawned
+  process terminates quickly.
+- :gh:`443`, [Linux]: fix a potential overflow issue for
+  :meth:`Process.cpu_affinity` (set) on systems with more than 64 CPUs.
+- :gh:`457`, [POSIX]: :func:`pid_exists` always returns ``True`` for PID 0.
+- :gh:`461`: named tuples are not pickle-able.
+- :gh:`466`, [Linux]: :meth:`Process.exe` improper null bytes handling. (patch
+  by Gautam Singh)
+- :gh:`470`: :func:`wait_procs` might not wait.  (patch by :user:`crusaderky`)
+- :gh:`471`, [Windows]: :meth:`Process.exe` improper unicode handling. (patch
+  by alex@mroja.net)
+- :gh:`473`: :class:`Popen` ``wait()`` method does not set ``returncode``
+  attribute.
+- :gh:`474`, [Windows]: :meth:`Process.cpu_percent` is no longer capped at
+  100%.
+- :gh:`476`, [Linux]: encoding error for :meth:`Process.name` and
+  :meth:`Process.cmdline`.
+
+1.2.1 — 2013-11-25
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`348`, [Windows], :label:`critical`: fixed "ImportError: DLL load failed"
+  occurring on module import on Windows XP.
+- :gh:`425`, [SunOS], :label:`critical`: crash on import due to failure at
+  determining ``BOOT_TIME``.
+- :gh:`443`, [Linux]: :meth:`Process.cpu_affinity` can't set affinity on
+  systems with more than 64 cores.
+
+1.2.0 — 2013-11-20
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`440`: new :func:`wait_procs` utility function which waits for multiple
+  processes to terminate.
+
+**API changes**
+
+- :gh:`439`: assume :func:`os.getpid` if no argument is passed to
+  :class:`Process` class constructor.
+
+**Bug fixes**
+
+- :gh:`348`, [Windows], :label:`critical`: fix "ImportError: DLL load failed"
+  occurring on module import on Windows XP / Vista.
+
+1.1.3 — 2013-11-07
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`442`, [Linux], :label:`build-fail`: psutil won't compile on certain
+  version of Linux because of missing :manpage:`prlimit(2)` syscall.
+
+1.1.2 — 2013-10-22
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`442`, [Linux], :label:`build-fail`: psutil won't compile on Debian 6.0
+  because of missing :manpage:`prlimit(2)` syscall.
+
+1.1.1 — 2013-10-08
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`442`, [Linux], :label:`build-fail`: psutil won't compile on kernels <
+  2.6.36 due to missing :manpage:`prlimit(2)` syscall.
+
+1.1.0 — 2013-09-28
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`412`, [Linux]: add :meth:`Process.rlimit`.
+
+**API changes**
+
+- :gh:`408`: turn ``STATUS_*`` and ``CONN_*`` constants into plain Python
+  strings.
+
+**Performance**
+
+- :gh:`415`, [Windows]: :meth:`Process.children` is an order of magnitude
+  faster.
+- :gh:`426`, [Windows]: :meth:`Process.name` is an order of magnitude faster.
+- :gh:`431`, [POSIX]: :meth:`Process.name` is slightly faster because it
+  unnecessarily retrieved also :meth:`Process.cmdline`.
+
+**Build and packaging**
+
+- :gh:`410`: host tar.gz and Windows binary files are on PyPI.
+
+**Bug fixes**
+
+- :gh:`413`, [Windows], :label:`memleak`: :meth:`Process.memory_info` leaks
+  memory.
+- :gh:`392`, [Windows]: :func:`cpu_times_percent` returns negative percentages.
+- :gh:`408`: ``STATUS_*`` and ``CONN_*`` constants don't properly serialize on
+  JSON.
+- :gh:`411`, [Windows]: :src:`scripts/disk_usage.py` may pop-up a GUI error.
+- :gh:`414`, [Windows]: :meth:`Process.exe` on Windows XP may raise
+  ``ERROR_INVALID_PARAMETER``.
+- :gh:`416`: :func:`disk_usage` doesn't work well with unicode path names.
+- :gh:`430`, [Linux]: :meth:`Process.io_counters` report wrong number of r/w
+  syscalls.
+- :gh:`435`, [Linux]: :func:`net_io_counters` might report erreneous NIC names.
+- :gh:`436`, [Linux]: :func:`net_io_counters` reports a wrong ``dropin`` value.
+
+1.0.1 — 2013-07-12
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`405`: :func:`net_io_counters` ``pernic=True`` no longer works as
+  intended in 1.0.0.
+
+1.0.0 — 2013-07-10
+^^^^^^^^^^^^^^^^^^
+
+**New platforms**
+
+- :gh:`18`, [SunOS]: add Solaris support (yay!)  (thanks Justin Venus)
+
+**API changes**
+
+- :gh:`367`: :meth:`Process.connections` :field:`status` is no longer a string
+  but a constant object (``psutil.CONN_*``).
+- :meth:`Process.connections` :field:`local_address` and
+  :field:`remote_address` fields renamed to :field:`laddr` and :field:`raddr`.
+- psutil.network_io_counters() renamed to :func:`net_io_counters`.
+
+**Internals**
+
+- :gh:`380`: test suite exits with non-zero on failure. (patch by floppymaster)
+- :gh:`391`: introduce unittest2 facilities and provide workarounds if
+  unittest2 is not installed (Python < 2.7).
+
+**Bug fixes**
+
+- :gh:`404`, [Linux], :label:`build-fail`: ``sched_*affinity()`` are implicitly
+  declared. (patch by Arfrever)
+- :gh:`374`, [Windows]: negative memory usage reported if process uses a lot of
+  memory.
+- :gh:`379`, [Linux]: :meth:`Process.memory_maps` may raise :exc:`ValueError`.
+- :gh:`394`, [macOS]: :term:`mapped memory` regions of
+  :meth:`Process.memory_maps` report incorrect file name.
+
+0.7.1 — 2013-05-03
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`325`, [BSD]: :func:`virtual_memory` can raise :exc:`SystemError`. (patch
+  by :user:`Jan Beich <jbeich>`)
+- :gh:`370`, [BSD]: :meth:`Process.connections` requires root. (patch by
+  :user:`John Baldwin <bsdjhb>`)
+- :gh:`372`, [BSD]: different process methods raise :exc:`NoSuchProcess`
+  instead of :exc:`AccessDenied`.
+
+0.7.0 — 2013-04-12
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`328`, [Windows]: :meth:`Process.ionice` support.
+- :gh:`359`: add :func:`boot_time` as a substitute of ``psutil.BOOT_TIME``
+  since the latter cannot reflect system clock updates.
+- :gh:`361`, [Linux]: :func:`cpu_times` now includes new :field:`steal`,
+  :field:`guest` and :field:`guest_nice` fields available on recent Linux
+  kernels. Also, :func:`cpu_percent` is more accurate.
+- :gh:`362`: add :func:`cpu_times_percent` (per-CPU-time utilization as a
+  percentage).
+
+**API changes**
+
+- :gh:`246`: psutil.error module is deprecated and scheduled for removal.
+
+**Internals**
+
+- :gh:`233`: code migrated to Mercurial (yay!)
+
+**Bug fixes**
+
+- :gh:`313`, [Linux], :label:`critical`: :func:`virtual_memory` and
+  :func:`swap_memory` can crash on certain exotic Linux flavors having an
+  incomplete ``/proc`` interface. If that's the case we now set the
+  unretrievable stats to ``0`` and raise :exc:`RuntimeWarning` instead.
+- :gh:`341`, [Linux], :label:`critical`: psutil might crash on import due to
+  error in retrieving system terminals map.
+- :gh:`333`, [macOS], :label:`memleak`: leak of Mach ports (patch by
+  :user:`rsesek`)
+- :gh:`339`, [FreeBSD], :label:`memleak`: ``get_pid_list()`` can allocate all
+  the memory on system.
+- :gh:`234`, [Windows]: :func:`disk_io_counters` fails to list certain disks.
+- :gh:`264`, [Windows]: use of :func:`disk_partitions` may cause a message box
+  to appear.
+- :gh:`315`, [macOS]: fix some compilation warnings.
+- :gh:`317`, [Windows]: cannot set process :term:`CPU affinity` above 31 cores.
+- :gh:`319`, [Linux]: :meth:`Process.memory_maps` raises :exc:`KeyError`
+  'Anonymous' on Debian squeeze.
+- :gh:`321`, [POSIX]: :meth:`Process.ppid` property is no longer cached as the
+  kernel may set the PPID to 1 in case of a :term:`zombie process`.
+- :gh:`323`, [macOS]: :func:`disk_io_counters` ``read_time`` and ``write_time``
+  parameters were reporting microseconds not milliseconds. (patch by
+  :user:`Gregory Szorc <indygreg>`)
+- :gh:`331`: :meth:`Process.cmdline` is no longer cached after first access as
+  it may change.
+- :gh:`337`, [Linux]: :class:`Process` methods not working because of a poor
+  ``/proc`` implementation will raise :exc:`NotImplementedError` rather than
+  :exc:`RuntimeError` and :meth:`Process.as_dict` will not blow up. (patch by
+  Curtin1060)
+- :gh:`338`, [Linux]: :func:`disk_io_counters` fails to find some disks.
+- :gh:`344`, [FreeBSD]: :func:`swap_memory` might return incorrect results due
+  to ``kvm_open(3)`` not being called. (patch by
+  :user:`Jean Sebastien <JeanSebTr>`)
+- :gh:`351`, [Windows]: if psutil is compiled with MinGW32 (provided installers
+  for py2.4 and py2.5 are) :func:`disk_io_counters` will fail. (Patch by
+  m.malycha)
+- :gh:`353`, [macOS]: :func:`users` returns an empty list on macOS 10.8.
+- :gh:`356`: :meth:`Process.parent` now checks whether parent PID has been
+  reused in which case returns ``None``.
+- :gh:`365`: :meth:`Process.nice` (set) should check PID has not been reused by
+  another process.
+- :gh:`366`, [FreeBSD]: :meth:`Process.memory_maps`, :meth:`Process.num_fds`,
+  :meth:`Process.open_files` and :meth:`Process.cwd` methods raise
+  :exc:`RuntimeError` instead of :exc:`AccessDenied`.
+
+0.6.1 — 2012-08-16
+^^^^^^^^^^^^^^^^^^
+
+**API changes**
+
+- :gh:`316`: :meth:`Process.cmdline` property now makes a better job at
+  guessing the process executable from the cmdline.
+- :meth:`Process.exe` can now return an empty string instead of raising
+  :exc:`AccessDenied`.
+
+**Bug fixes**
+
+- :gh:`316`: :meth:`Process.exe` was resolved in case it was a symlink.
+- :gh:`318`: Python 2.4 compatibility was broken.
+
+0.6.0 — 2012-08-13
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`216`, [POSIX]: add :meth:`Process.connections` UNIX sockets support.
+- :gh:`222`, [macOS]: add support for :meth:`Process.cwd`.
+- :gh:`261`: add ``Process.memory_info_ex()``.
+- :gh:`302`: add :meth:`Process.num_ctx_switches`.
+- :gh:`311`: add :func:`virtual_memory` and :func:`swap_memory`. Old
+  memory-related functions are deprecated. New example scripts:
+  :src:`scripts/free.py` and :src:`scripts/meminfo.py`.
+- :gh:`312`: :func:`net_io_counters` adds 4 new fields: :field:`errin`,
+  :field:`errout`, :field:`dropin` and :field:`dropout`.
+
+**API changes**
+
+- :gh:`295`, [macOS]: :meth:`Process.exe` path is now determined by asking the
+  OS instead of being guessed from :meth:`Process.cmdline`.
+- :gh:`297`, [macOS]: :meth:`Process.name`, :meth:`Process.memory_info`,
+  :meth:`Process.memory_percent`, :meth:`Process.cpu_times`,
+  :meth:`Process.cpu_percent`, :meth:`Process.num_threads` no longer raise
+  :exc:`AccessDenied` for other users' processes and are **2.5x faster**.
+- :gh:`301`: :func:`process_iter` now yields processes sorted by their PIDs.
+- :gh:`304`, [Windows]: :meth:`Process.create_time`, :meth:`Process.cpu_times`,
+  :meth:`Process.cpu_percent`, :meth:`Process.memory_info`,
+  :meth:`Process.memory_percent`, :meth:`Process.num_handles`,
+  :meth:`Process.io_counters` no longer raise :exc:`AccessDenied` for other
+  users' processes.
+- ``psutil.phymem_usage()`` is deprecated (use :func:`virtual_memory`)
+- ``psutil.virtmem_usage()`` is deprecated (use :func:`swap_memory`)
+- [Linux]: ``psutil.phymem_buffers()`` is deprecated (use
+  :func:`virtual_memory`)
+- [Linux]: ``psutil.cached_phymem()`` is deprecated (use
+  :func:`virtual_memory`)
+
+**Performance**
+
+- :gh:`220`, [FreeBSD]: :func:`net_connections` has been rewritten in C and no
+  longer requires ``lsof``.
+
+**Internals**
+
+- :gh:`300`: add :src:`scripts/pmap.py`.
+- :commit:`6e45ac1a`: add :src:`scripts/netstat.py`.
+
+**Bug fixes**
+
+- :gh:`303`, [Windows], :label:`critical`: potential heap corruption in
+  :meth:`Process.num_threads` and :meth:`Process.status` methods.
+- :gh:`306`, :label:`critical`: at C level, errors are not checked when
+  invoking ``Py*`` functions which create or manipulate Python objects leading
+  to potential memory related errors and/or segmentation faults.
+- :gh:`305`, [FreeBSD], :label:`build-fail`: can't compile on FreeBSD 9 due to
+  removal of ``utmp.h``.
+- :gh:`298`, [macOS], [BSD], :label:`memleak`: memory leak in
+  :meth:`Process.num_fds`.
+- :gh:`299`, :label:`memleak`: potential memory leak every time
+  ``PyList_New(0)`` is used.
+- :gh:`307`, [FreeBSD]: values returned by :func:`net_io_counters` are wrong.
+- :gh:`308`, [BSD], [Windows]: ``psutil.virtmem_usage()`` wasn't actually
+  returning information about :term:`swap memory` usage as it was supposed to
+  do. It does now.
+- :gh:`310`: :meth:`Process.open_files` might not return files which can not be
+  accessed due to limited permissions. :exc:`AccessDenied` is now raised
+  instead.
+
+0.5.1 — 2012-06-29
+^^^^^^^^^^^^^^^^^^
+
+**API changes**
+
+- :gh:`293`, [Windows]: :meth:`Process.exe` path is now determined by asking
+  the OS instead of being guessed from :meth:`Process.cmdline`.
+
+**Bug fixes**
+
+- :gh:`292`, [Linux]: race condition in process :meth:`Process.open_files`,
+  :meth:`Process.connections`, :meth:`Process.threads`.
+- :gh:`294`, [Windows]: :meth:`Process.cpu_affinity` is only able to set CPU
+  #0.
+
+0.5.0 — 2012-06-27
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`195`, [Windows]: add :meth:`Process.num_handles`.
+- :gh:`209`: :func:`disk_partitions` now provides also mount options.
+- :gh:`229`: add :func:`users`.
+- :gh:`238`, [Linux], [Windows]: add :meth:`Process.cpu_affinity`.
+- :gh:`242`: add ``recursive=True`` to :meth:`Process.children`: return all
+  process descendants.
+- :gh:`260`: add :meth:`Process.memory_maps`. (Windows patch by :user:`wj32`,
+  macOS patch by :user:`Jeremy Whitlock <whitlockjc>`)
+- :gh:`278`: add :meth:`Process.as_dict`.
+- :gh:`284`, [POSIX]: add :meth:`Process.num_fds`.
+
+**API changes**
+
+- :gh:`273`: ``psutil.get_process_list()`` is deprecated.
+- :gh:`281`: :meth:`Process.ppid`, :meth:`Process.name`, :meth:`Process.exe`,
+  :meth:`Process.cmdline` and :meth:`Process.create_time` are now cached after
+  first access, so :exc:`NoSuchProcess` is no longer raised if the process is
+  gone in the meantime.
+- :gh:`282`: ``psutil.STATUS_*`` constants can now be compared by using their
+  string representation.
+- :gh:`290`: :meth:`Process.nice` property is deprecated in favor of new
+  ``get_nice()`` and ``set_nice()`` methods.
+
+**Performance**
+
+- :gh:`245`, [POSIX]: :meth:`Process.wait` incrementally consumes less CPU
+  cycles.
+- :gh:`258`, [Linux]: :meth:`Process.memory_info` is now **0.5x faster**.
+- :gh:`262`, [Windows]: :func:`disk_partitions` was slow due to inspecting the
+  floppy disk drive also when parameter is ``all=False``.
+- :gh:`283`: speedup :meth:`Process.is_running` by caching its return value in
+  case the process is terminated.
+- :gh:`287`: :func:`process_iter` now caches :class:`Process` instances between
+  calls.
+
+**Build and packaging**
+
+- :gh:`274`: psutil no longer requires ``2to3`` at installation time in order
+  to work with Python 3.
+
+**Dropped support**
+
+- :gh:`257`, [Windows], :label:`breaking`: removed Windows 2000 support.
+
+**Bug fixes**
+
+- :gh:`240`, [macOS], :label:`critical`: incorrect use of ``free()`` for
+  :meth:`Process.connections`.
+- :gh:`193`: :class:`Popen` constructor can throw an exception if the spawned
+  process terminates quickly.
+- :gh:`244`, [POSIX]: :meth:`Process.wait` can hog CPU resources if called
+  against a process which is not our children.
+- :gh:`248`, [Linux]: :func:`net_io_counters` might return erroneous NIC names.
+- :gh:`252`, [Windows]: :meth:`Process.cwd` erroneously raise
+  :exc:`NoSuchProcess` for processes owned by another user. It now raises
+  :exc:`AccessDenied` instead.
+- :gh:`266`, [Windows]: ``psutil.get_pid_list()`` only shows 1024 processes.
+  (patch by :user:`amoser`)
+- :gh:`267`, [macOS]: :meth:`Process.connections` returns wrong remote address.
+  (Patch by Amoser)
+- :gh:`272`, [Linux]: :meth:`Process.open_files` potential race condition can
+  lead to unexpected :exc:`NoSuchProcess` exception. Also, we can get incorrect
+  reports of not absolutized path names.
+- :gh:`275`, [Linux]: :meth:`Process.io_counters` erroneously raise
+  :exc:`NoSuchProcess` on old Linux versions. Where not available it now raises
+  :exc:`NotImplementedError`.
+- :gh:`286`: :meth:`Process.is_running` doesn't actually check whether PID has
+  been reused.
+- :gh:`314`: :meth:`Process.children` can sometimes return non-children.
+
+0.4.1 — 2011-12-14
+^^^^^^^^^^^^^^^^^^
+
+**Bug fixes**
+
+- :gh:`230`, [Windows], [macOS], :label:`memleak`: fix memory leak in
+  :meth:`Process.connections`.
+- :gh:`236`, [Windows], :label:`memleak`: fix memory/handle leak in
+  :meth:`Process.memory_info`, :meth:`Process.suspend` and
+  :meth:`Process.resume` methods.
+- :gh:`228`: some example scripts were not working with Python 3.
+- :gh:`232`, [Linux]: ``psutil.phymem_usage()`` can report erroneous values
+  which are different than ``free`` command.
+
+0.4.0 — 2011-10-29
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`150`: add :func:`net_io_counters` (macOS and Windows patch by
+  :user:`Jeremy Whitlock <whitlockjc>`)
+- :gh:`154`, [FreeBSD]: add support for :meth:`Process.cwd`.
+- :gh:`206`: add :func:`disk_io_counters`). (macOS and Windows patch by
+  :user:`Jeremy Whitlock <whitlockjc>`)
+- :gh:`217`: :meth:`Process.connections` now has a *kind* argument to filter
+  for connections with different criteria.
+
+**API changes**
+
+- :gh:`198`: :meth:`Process.wait` with ``timeout=0`` can now be used to make
+  the function return immediately.
+
+**Performance**
+
+- :gh:`221`, [FreeBSD]: :meth:`Process.open_files` has been rewritten in C and
+  no longer relies on ``lsof``.
+
+**Build and packaging**
+
+- :gh:`157`, [Windows]: provide installer for Python 3.2 64-bit.
+
+**Internals**
+
+- :gh:`213`: add :src:`scripts/iotop.py`.
+- :gh:`223`: add :src:`scripts/top.py`.
+- :gh:`227`: add :src:`scripts/nettop.py`.
+
+**Bug fixes**
+
+- :gh:`188`, [Linux], :label:`critical`: psutil import error on Linux ARM
+  architectures.
+- :gh:`200`, [Linux], :label:`critical`: ``psutil.NUM_CPUS`` not working on
+  armel and sparc architectures and causing crash on module import.
+- :gh:`218`, [Linux], :label:`critical`: crash at import time on Debian 64-bit
+  because of a missing line in :proc:`/proc/meminfo`.
+- :gh:`226`, [FreeBSD], :label:`critical`: crash at import time on FreeBSD 7
+  and minor.
+- :gh:`135`, [macOS]: psutil cannot create :class:`Process` object.
+- :gh:`144`, [Linux]: no longer support 0 special PID.
+- :gh:`194`, [POSIX]: :meth:`Process.cpu_percent` now reports a percentage over
+  100 on multi core processors.
+- :gh:`197`, [Linux]: :meth:`Process.connections` is broken on platforms not
+  supporting IPv6.
+- :gh:`201`, [Linux]: :meth:`Process.connections` is broken on big-endian
+  architectures.
+- :gh:`211`: :class:`Process` instance can unexpectedly raise
+  :exc:`NoSuchProcess` if tested for equality with another object.
+
+0.3.0 — 2011-07-08
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`125`: add :func:`cpu_times` and :func:`cpu_percent` per-cpu support.
+- :gh:`163`: add :meth:`Process.terminal`.
+- :gh:`171`: add ``get_phymem()`` and ``get_virtmem()``. Old ``total_*``,
+  ``avail_*`` and ``used_*`` memory functions are deprecated.
+- :gh:`172`: add :func:`disk_usage`.
+- :gh:`174`: add :func:`disk_partitions`.
+
+**Build and packaging**
+
+- :gh:`179`: setuptools is now used in setup.py
+
+**Bug fixes**
+
+- :gh:`159`, [Windows], :label:`memleak`: ``SetSeDebug()`` does not close
+  handles or unset impersonation on return.
+- :gh:`166`, :label:`memleak`: :meth:`Process.memory_info` leaks handles
+  hogging system resources.
+- :gh:`178`, [macOS], :label:`memleak`: :meth:`Process.threads` leaks memory.
+- :gh:`164`, [Windows]: :meth:`Process.wait` raises a ``TimeoutException`` when
+  a process returns ``-1``.
+- :gh:`165`: :meth:`Process.status` raises an unhandled exception.
+- :gh:`168`: :func:`cpu_percent` returns erroneous results when used in
+  non-blocking mode. (patch by :user:`Philip Roberts <latentflip>`)
+- :gh:`180`, [Windows]: :meth:`Process.num_threads` and :meth:`Process.threads`
+  methods can raise :exc:`NoSuchProcess` exception while process still exists.
+
+0.2.1 — 2011-03-20
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`64`: add :meth:`Process.io_counters`.
+- :gh:`116`: add :meth:`Process.wait`.
+- :gh:`134`: add :meth:`Process.threads`.
+- :gh:`137`: add :meth:`Process.uids` and :meth:`Process.gids`.
+- :gh:`140`: add :func:`boot_time`.
+- :gh:`142`: add :meth:`Process.nice`.
+- :gh:`143`: add :meth:`Process.status`.
+- :gh:`147`, [Linux]: add :meth:`Process.ionice`.
+- :gh:`148`: add :class:`Popen` class combining :class:`subprocess.Popen` and
+  :class:`Process` in a single interface.
+
+**API changes**
+
+- :gh:`136`, [FreeBSD]: :meth:`Process.exe` path is now determined by asking
+  the kernel instead of guessing it from cmdline[0].
+- :class:`Process` ``uid`` and ``gid`` properties are deprecated in favor of
+  ``uids`` and ``gids`` properties.
+
+**Performance**
+
+- :gh:`152`, [macOS]: :meth:`Process.open_files` rewritten in C (no longer
+  relies on ``lsof``, **3x faster**).
+- :gh:`153`, [macOS]: :meth:`Process.connections` rewritten in C (no longer
+  relies on ``lsof``, **3x faster**).
+
+**Bug fixes**
+
+- :gh:`83`, [macOS]:  :meth:`Process.cmdline` is empty on macOS 64-bit.
+- :gh:`130`, [Linux]: a race condition can cause :exc:`IOError` exception be
+  raised on if process disappears between ``open()`` and the subsequent
+  ``read()`` call.
+- :gh:`145`, [Windows]: :exc:`WindowsError` was raised instead of
+  :exc:`AccessDenied` when using :meth:`Process.resume` or
+  :meth:`Process.suspend`.
+- :gh:`146`, [Linux]: :meth:`Process.exe` property can raise :exc:`TypeError`
+  if path contains NULL bytes.
+- :gh:`151`, [Linux]: :meth:`Process.exe` and :meth:`Process.cwd` for PID 0
+  return inconsistent data.
+
+0.2.0 — 2010-11-13
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`79`: add :meth:`Process.open_files`.
+- :gh:`88`: total system physical cached memory.
+- :gh:`88`: total system physical memory :term:`buffers` used by the kernel.
+- :gh:`91`: add :meth:`Process.send_signal` and :meth:`Process.terminate`
+  methods.
+- :gh:`95`: :exc:`NoSuchProcess` and :exc:`AccessDenied` exception classes now
+  provide ``pid``, ``name`` and ``msg`` attributes.
+- :gh:`97`: add :meth:`Process.children`.
+- :gh:`103`: add :meth:`Process.connections`.
+- :gh:`111`: add :meth:`Process.exe`.
+- :gh:`123`: :func:`cpu_percent` and :meth:`Process.cpu_percent` accept a new
+  *interval* parameter.
+- :gh:`129`: add :meth:`Process.threads`.
+
+**New platforms**
+
+- :gh:`107`, [Windows]: add support for Windows 64 bit. (patch by cjgohlke)
+- :gh:`117`, [Windows]: added support for Windows 2000.
+
+**API changes**
+
+- :gh:`98`: :meth:`Process.cpu_times` and :meth:`Process.memory_info` now
+  return a named tuple instead of a tuple.
+- :gh:`113`: exception messages now include :meth:`Process.name` and
+  :attr:`Process.pid`.
+- ``psutil.Process.path`` property is deprecated and works as an alias for
+  ``psutil.Process.exe`` property.
+- :meth:`Process.kill`: *signal* argument was removed - to send a signal to the
+  process use :meth:`Process.send_signal` method instead.
+- :func:`cpu_times` returns a named tuple instead of a tuple.
+- :meth:`Process.cpu_percent` and :func:`cpu_percent` no longer returns
+  immediately by default (see :gh:`123`).
+
+**Performance**
+
+- :gh:`114`, [Windows]: :meth:`Process.username` rewritten in C (no longer uses
+  WMI, much faster, pywin32 no longer required). (patch by :user:`wj32`)
+
+**Bug fixes**
+
+- :gh:`81`, [Windows], :label:`build-fail`: psutil fails to compile with Visual
+  Studio.
+- :gh:`86`, [FreeBSD], :label:`build-fail`: psutil didn't compile against
+  FreeBSD 6.x.
+- :gh:`102`, [Windows], :label:`memleak`: orphaned process handles obtained by
+  using ``OpenProcess`` in C were left behind every time :class:`Process` class
+  was instantiated.
+- :gh:`80`: fixed warnings when installing psutil with easy_install.
+- :gh:`94`: :meth:`Process.suspend` raises :exc:`OSError` instead of
+  :exc:`AccessDenied`.
+- :gh:`111`, [POSIX]: ``path`` and ``name`` :class:`Process` properties report
+  truncated or erroneous values on POSIX.
+- :gh:`120`, [macOS]: :func:`cpu_percent` always returning 100%.
+- :gh:`112`: ``uid`` and ``gid`` properties don't change if process changes
+  effective user/group id at some point.
+- :gh:`126`: :meth:`Process.ppid`, :meth:`Process.uids`, :meth:`Process.gids`,
+  :meth:`Process.name`, :meth:`Process.exe`, :meth:`Process.cmdline` and
+  :meth:`Process.create_time` properties are no longer cached and correctly
+  raise :exc:`NoSuchProcess` exception if the process disappears.
+
+0.1.3 — 2010-03-02
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`14`: :meth:`Process.username`.
+- :gh:`51`, [Linux], [Windows]: add :meth:`Process.cwd`.
+- :gh:`71`: add :meth:`Process.suspend` and :meth:`Process.resume`.
+
+**New platforms**
+
+- :gh:`61`, [FreeBSD]: added support for FreeBSD 64 bit.
+- :gh:`75`: Python 3 support.
+
+**Performance**
+
+- :gh:`59`: :meth:`Process.is_running` is now **10 times faster**.
+
+**Bug fixes**
+
+- :gh:`49`, [FreeBSD], :label:`memleak`: possible memory leak due to missing
+  ``free()`` on error condition in ``getcmdpath()``.
+- :gh:`62`, [Windows], :label:`memleak`: :meth:`Process.cwd` leaked a string
+  object on every call.
+- :gh:`36`: :meth:`Process.cpu_times` and :meth:`Process.memory_info` functions
+  succeeded. also for dead processes while a :exc:`NoSuchProcess` exception is
+  supposed to be raised.
+- :gh:`48`, [FreeBSD]: incorrect size for MIB array defined in ``getcmdargs``.
+- :gh:`50`, [macOS]: fixed ``getcmdargs()`` memory fragmentation.
+- :gh:`55`, [Windows]: ``test_pid_4`` was failing on Windows Vista.
+- :gh:`57`: some unit tests were failing on systems where no swap memory is
+  available.
+- :gh:`58`: :meth:`Process.is_running` is now called before
+  :meth:`Process.kill` to make sure we are going to kill the correct process.
+- :gh:`73`, [macOS]: virtual memory size reported on includes shared library
+  size.
+- :gh:`77`: :exc:`NoSuchProcess` wasn't raised on :meth:`Process.create_time`
+  if :meth:`Process.kill` was used first.
+
+0.1.2 — 2009-05-06
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`32`: add :meth:`Process.cpu_times`.
+- :gh:`33`: add :meth:`Process.create_time`.
+- :gh:`34`: add :meth:`Process.cpu_percent`.
+- :gh:`38`: add :meth:`Process.memory_info`.
+- :gh:`41`: add :meth:`Process.memory_percent`.
+- :gh:`39`: add :func:`boot_time`.
+- :gh:`43`: Total system virtual memory.
+- :gh:`46`: Total system physical memory.
+- :gh:`44`: Total system used/free virtual and physical memory.
+
+**Bug fixes**
+
+- :gh:`36`, [Windows]: :exc:`NoSuchProcess` not raised when accessing timing
+  methods.
+- :gh:`40`, [FreeBSD], [macOS]: fix ``test_get_cpu_times`` failures.
+- :gh:`42`, [Windows]: :meth:`Process.memory_percent` raises
+  :exc:`AccessDenied`.
+
+0.1.1 — 2009-03-06
+^^^^^^^^^^^^^^^^^^
+
+**New APIs**
+
+- :gh:`9`, [macOS], [Windows]: add ``Process.uid`` and ``Process.gid``,
+  returning process UID and GID.
+- :gh:`11`: per-process parent object: :meth:`Process.parent` property returns
+  a :class:`Process` object representing the parent process, and
+  :meth:`Process.ppid` returns the parent PID.
+- :gh:`21`, [Windows]: :exc:`AccessDenied` exception created for raising access
+  denied errors from :exc:`OSError` or :exc:`WindowsError` on individual
+  platforms.
+- :gh:`26`: :func:`process_iter` function to iterate over processes as
+  :class:`Process` objects with a generator.
+
+**New platforms**
+
+- :gh:`4`, [FreeBSD]: support for all functions of psutil.
+
+**API changes**
+
+- :gh:`12`, :gh:`15`: :exc:`NoSuchProcess` exception now raised when creating
+  an object for a nonexistent process, or when retrieving information about a
+  process that has gone away.
+- :class:`Process` objects can now also be compared with == operator for
+  equality (PID, name, command line are compared).
+
+**Bug fixes**
+
+- :gh:`16`, [Windows]: Special case for "System Idle Process" (PID 0) which
+  otherwise would return an "invalid parameter" exception.
+- :gh:`17`: ``get_process_list()`` ignores :exc:`NoSuchProcess` and
+  :exc:`AccessDenied` exceptions during building of the list.
+- :gh:`22`, [Windows]: :meth:`Process.kill` for PID 0 was failing with an unset
+  exception.
+- :gh:`23`, [Linux], [macOS]: create special case for :func:`pid_exists` with
+  PID 0.
+- :gh:`24`, [Windows]: :meth:`Process.kill` for PID 0 now raises
+  :exc:`AccessDenied` exception instead of :exc:`WindowsError`.
+- :gh:`30`: psutil.get_pid_list() was returning two 0 PIDs.
+
+0.1.0 — 2009-01-27
+^^^^^^^^^^^^^^^^^^
+
+Initial release. Supports Linux, Windows, and macOS via per-platform backends
+(``_pslinux``, ``_psmswindows``, ``_psosx``) with C extensions for Windows and
+macOS.
+
+**New APIs**
+
+- :class:`Process` class exposing ``pid``, ``name``, ``path``, and ``cmdline``,
+  with a ``kill()`` method.
+- ``get_process_list()`` returning all running processes.
+- ``ProcessInfo`` value object passed between the public API and the platform
+  backends.
diff --git a/docs/conf.py b/docs/conf.py
index 9fa163b65e..98617c8e88 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -1,248 +1,327 @@
-# -*- coding: utf-8 -*-
-#
-# psutil documentation build configuration file, created by
-# sphinx-quickstart.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
+# Copyright (c) 2009, Giampaolo Rodola. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Sphinx configuration file.
+
+Sphinx doc:
+https://www.sphinx-doc.org/en/master/usage/configuration.html
+"""
 
 import datetime
+import importlib.util
+import json
+import locale
 import os
+import pathlib
+import sys
+import time
+
+_HERE = pathlib.Path(__file__).resolve().parent
+_ROOT_DIR = _HERE.parent
+sys.path.insert(0, str(_HERE / "_ext"))  # needed to load local extensions
+
 
+# Load _bootstrap.py (at the repo root) without putting the repo
+# root on sys.path. Doing so would expose the uncompiled source
+# `psutil/` package and shadow any installed psutil, breaking
+# `import psutil` at build time (needed by sphinx-codeautolink to
+# resolve things like `p.name()` in code blocks).
+def _load(path):
+    spec = importlib.util.spec_from_file_location(path.stem, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+get_version = _load(_ROOT_DIR / "_bootstrap.py").get_version
 
 PROJECT_NAME = "psutil"
-AUTHOR = "Giampaolo Rodola'"
+AUTHOR = "Giampaolo Rodola"
 THIS_YEAR = str(datetime.datetime.now().year)
-HERE = os.path.abspath(os.path.dirname(__file__))
-
-
-def get_version():
-    INIT = os.path.abspath(os.path.join(HERE, '../psutil/__init__.py'))
-    with open(INIT, 'r') as f:
-        for line in f:
-            if line.startswith('__version__'):
-                ret = eval(line.strip().split(' = ')[1])
-                assert ret.count('.') == 2, ret
-                for num in ret.split('.'):
-                    assert num.isdigit(), ret
-                return ret
-        else:
-            raise ValueError("couldn't find version string")
-
 VERSION = get_version()
 
-# If your documentation needs a minimal Sphinx version, state it here.
-needs_sphinx = '1.0'
+# =====================================================================
+# Core
+# =====================================================================
+
+needs_sphinx = "9.1"
+language = "en"
+nitpicky = True  # always warn on unresolved cross-references
+
+# =====================================================================
+# Extensions
+# =====================================================================
+
+_third_party_exts = [
+    "ablog",
+    "notfound.extension",  # custom 404 page
+    "sphinx.ext.extlinks",
+    "sphinx.ext.githubpages",  # writes .nojekyll + CNAME from html_baseurl
+    "sphinx.ext.intersphinx",
+    "sphinx.ext.viewcode",
+    "sphinx_codeautolink",
+    "sphinx_copybutton",
+    "sphinx_design",  # tabbed code examples on the home page
+    "sphinx_sitemap",
+    "sphinxext.opengraph",
+]
 
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = ['sphinx.ext.autodoc',
-              'sphinx.ext.coverage',
-              'sphinx.ext.pngmath',
-              'sphinx.ext.viewcode',
-              'sphinx.ext.intersphinx']
+_local_exts = [  # defined in the _ext/ folder
+    "ablog_extras",
+    "availability",
+    "changelog_anchors",
+    "check_python_syntax",
+    "field_role",
+    "genindex_filter",
+    "giscus",
+    "glossary_toc",
+    "label_role",
+    "notfound_extras",
+    "opengraph_override",
+    "post_banner",
+    "proc_role",
+    "substitutions",
+]
 
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['_template']
+extensions = _third_party_exts + _local_exts
 
-# The suffix of source filenames.
-source_suffix = '.rst'
+# =====================================================================
+# Project metadata
+# =====================================================================
 
-# The encoding of source files.
-# source_encoding = 'utf-8-sig'
+project = PROJECT_NAME
+author = AUTHOR
+version = release = VERSION
+copyright = f"2009-{THIS_YEAR} {AUTHOR}"  # shown in the footer
 
-# The master toctree document.
-master_doc = 'index'
+# =====================================================================
+# Cross-references and external links
+# =====================================================================
 
-# General information about the project.
-project = PROJECT_NAME
-copyright = '2009-%s, %s' % (THIS_YEAR, AUTHOR)
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = VERSION
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-# language = None
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-# today = ''
-# Else, today_fmt is used as the format for a strftime call.
-# today_fmt = '%B %d, %Y'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-exclude_patterns = ['_build']
-
-# The reST default role (used for this markup: `text`) to use for all
-# documents.
-# default_role = None
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-add_function_parentheses = True
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-# add_module_names = True
-
-autodoc_docstring_signature = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-# show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-pygments_style = 'sphinx'
-
-# A list of ignored prefixes for module index sorting.
-# modindex_common_prefix = []
-
-
-# -- Options for HTML output -------------------------------------------------
-
-# The theme to use for HTML and HTML Help pages.  See the documentation for
-# a list of builtin themes.
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further.  For a list of options available for each theme, see the
-# documentation.
-html_theme = 'pydoctheme'
-html_theme_options = {'collapsiblesidebar': True}
-
-# Add any paths that contain custom themes here, relative to this directory.
-html_theme_path = ["_themes"]
-
-# The name for this set of Sphinx documents.  If None, it defaults to
-# "<project> v<release> documentation".
-html_title = "{project} {version} documentation".format(**locals())
-
-# A shorter title for the navigation bar.  Default is the same as html_title.
-# html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-# html_logo = 'logo.png'
-
-# The name of an image file (within the static path) to use as favicon of the
-# docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-html_favicon = '_static/favicon.ico'
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
-# using the given strftime format.
-html_last_updated_fmt = '%b %d, %Y'
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-html_sidebars = {
-    'index': 'indexsidebar.html',
-    '**': ['globaltoc.html',
-           'relations.html',
-           'sourcelink.html',
-           'searchbox.html']
+intersphinx_mapping = {
+    "python": ("https://docs.python.org/3", None),
+}
+extlinks = {
+    "gh": ("https://github.com/giampaolo/psutil/issues/%s", "#%s"),
+    "pr": ("https://github.com/giampaolo/psutil/pull/%s", "PR-%s"),
+    "user": ("https://github.com/%s", "@%s"),
+    "commit": ("https://github.com/giampaolo/psutil/commit/%s", "%s"),
+    "pypi": ("https://pypi.org/project/psutil/%s/", "%s"),
+    "bpo": ("https://bugs.python.org/issue%s", "BPO-%s"),
+    "cpy": ("https://github.com/python/cpython/issues/%s", "cpython/#%s"),
+    "cpy-pr": ("https://github.com/python/cpython/pull/%s", "cpython/PR-%s"),
+    "src": ("https://github.com/giampaolo/psutil/blob/master/%s", "%s"),
 }
+manpages_url = "https://manpages.debian.org/{path}"
 
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-# html_additional_pages = {
-#    'index': 'indexcontent.html',
-# }
+# =====================================================================
+# Paths
+# =====================================================================
 
-# If false, no module index is generated.
-html_domain_indices = False
+exclude_patterns = ["_build"]
+rst_prolog = ".. currentmodule:: psutil\n"  # Prepended to every .rst file
 
-# If false, no index is generated.
-html_use_index = True
+# =====================================================================
+# HTML
+# =====================================================================
 
-# If true, the index is split into individual pages for each letter.
-# html_split_index = False
+# Canonical site URL. Picked up by Sphinx for <link rel="canonical">
+# tags. Reused below by sphinxext-opengraph (og:url), sphinx-sitemap,
+# and (via blog_baseurl) ablog's atom feed.
+html_baseurl = "https://psutil.io/"
 
-# If true, links to the reST sources are added to the pages.
-# html_show_sourcelink = True
+# sphinx-notfound-page: absolute URL prefix for static files and
+# nav links on 404.html.
+notfound_urls_prefix = "/"
 
-# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-# html_show_sphinx = True
+html_title = PROJECT_NAME
+html_favicon = "_static/images/favicon.svg"
+html_last_updated_fmt = "%Y-%m-%d"  # ISO date shown in the footer
+html_show_sphinx = False  # removes "Created using Sphinx" in the footer
+html_show_sourcelink = False  # removes "View page source" sidebar link
 
-# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-# html_show_copyright = True
+# Sidebar shows method() instead of Class.method()
+toc_object_entries_show_parents = "hide"
 
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it.  The value of this option must be the
-# base URL from which the finished HTML is served.
-# html_use_opensearch = ''
+# =====================================================================
+# Plugins
+# =====================================================================
 
-# This is the file name suffix for HTML files (e.g. ".xhtml").
-# html_file_suffix = None
+copybutton_exclude = ".linenos, .gp"
 
-# Output file base name for HTML help builder.
-htmlhelp_basename = '%s-doc' % PROJECT_NAME
+# =====================================================================
+# Theming
+# =====================================================================
 
-# -- Options for LaTeX output ------------------------------------------------
+# Custom psutil-sphinx-theme, built on top of Sphinx's `basic` theme.
 
-# The paper size ('letter' or 'a4').
-# latex_paper_size = 'letter'
+html_theme = "basic"
+html_theme_options = {
+    "globaltoc_maxdepth": 1,
+    "globaltoc_collapse": False,
+    "globaltoc_includehidden": True,
+}
+html_static_path = ["_static"]
+html_extra_path = ["_extra"]  # robots.txt, copied verbatim to site root
+templates_path = ["_templates"]
+pygments_style = "tango"  # base palette (overridden by css/code.css)
 
-# The font size ('10pt', '11pt' or '12pt').
-# latex_font_size = '10pt'
 
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title, author, documentclass
-# [howto/manual]).
-latex_documents = [
-    ('index', '%s.tex' % PROJECT_NAME,
-     '%s documentation' % PROJECT_NAME, AUTHOR),
-]
+def _css_files():
+    css_dir = _HERE / "_static" / "css"
+    # giscus.css is loaded inside the giscus iframe (see
+    # _templates/comments.html), never by our own pages. Linking it
+    # here would make every page fetch its @import from giscus.app.
+    skip = {"giscus.css"}
+    files = sorted(p.name for p in css_dir.glob("*.css") if p.name not in skip)
+    head = ["base.css", "fonts.css", "fontawesome.css", "typography.css"]
+    tail = ["home.css"]
+    middle = [f for f in files if f not in head + tail]
+    return [f"css/{name}" for name in head + middle + tail if name in files]
 
-# The name of an image file (relative to this directory) to place at
-# the top of the title page.
-# latex_logo = None
 
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-# latex_use_parts = False
+html_css_files = _css_files()
 
-# If true, show page references after internal links.
-# latex_show_pagerefs = False
 
-# If true, show URL addresses after external links.
-# latex_show_urls = False
+def _js_files():
+    js_dir = _HERE / "_static" / "js"
+    # blog-comment-counts.js is pulled in by the blog listing template
+    # only (_templates/ablog/collection.html).
+    files = sorted(
+        p.name
+        for p in js_dir.glob("*.js")
+        if p.name != "blog-comment-counts.js"
+    )
+    return [(f"js/{name}", {"defer": "defer"}) for name in files]
 
-# Additional stuff for the LaTeX preamble.
-# latex_preamble = ''
 
-# Documents to append as an appendix to all manuals.
-# latex_appendices = []
+html_js_files = _js_files()
 
-# If false, no module index is generated.
-# latex_domain_indices = True
+# =====================================================================
+# Version selector
+# =====================================================================
 
+VERSIONS = json.loads((_HERE / "versions.json").read_text(encoding="utf-8"))
 
-# -- Options for manual page output ------------------------------------------
+html_context = {
+    "versions": VERSIONS["versions"],
+    "versions_current": VERSIONS["current"],
+}
 
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
-    ('index', PROJECT_NAME, '%s documentation' % PROJECT_NAME, [AUTHOR], 1)
+# =====================================================================
+# Blog (ablog package)
+# =====================================================================
+
+# Force UTC for build-time timestamps so atom feed entries are
+# the same across build hosts (CI runs UTC; local devs may not).
+os.environ["TZ"] = "UTC"
+if hasattr(time, "tzset"):
+    time.tzset()
+
+# Fix for ablog, which otherwise formats dates in the local locale.
+try:
+    locale.setlocale(locale.LC_TIME, "C")
+except locale.Error:
+    pass
+
+# Drives atom feed entry <id>s and <link>s. Same value as html_baseurl
+# so feed URLs track canonicals URLs.
+blog_baseurl = html_baseurl
+
+# =====================================================================
+# Comments (giscus)
+# =====================================================================
+
+giscus_repo = "giampaolo/psutil-blog-comments"
+giscus_repo_id = "R_kgDOTfVGLA"
+giscus_category = "User Comments"
+giscus_category_id = "DIC_kwDOTfVGLM4DBrKC"
+
+# =====================================================================
+# sphinxext-opengraph
+# =====================================================================
+
+# sphinxext-opengraph emits <meta property="og:*"> + Twitter Card tags
+# in every page's <head>, so that URLs shared on social medias render
+# as rich preview cards instead of bare links.
+ogp_site_url = html_baseurl
+ogp_site_name = PROJECT_NAME
+ogp_description_length = 160  # Google SERP snippet width
+
+# The logo shown in the preview. sphinxext-opengraph requires a .png
+# file.
+_logo = "_static/images/logo-psutil.png"
+ogp_social_cards = {"image": _logo, "image_mini": _logo}
+
+# =====================================================================
+# sphinx-sitemap
+# =====================================================================
+
+# sphinx-sitemap emits <build>/sitemap.xml listing every built page,
+# for search engine discovery. Reads html_baseurl; {link} scheme avoids
+# the default {lang}{version} prefix (we don't use either in URLs).
+sitemap_url_scheme = "{link}"
+sitemap_show_lastmod = True
+# dirhtml URLs are directories, so match the dir form (e.g. "search/",
+# not "search.html") or these leak into the sitemap.
+sitemap_excludes = [
+    "search/",
+    "genindex/",
+    "py-modindex/",
+    "404/",
+    "_modules/*",
+    "blog/archive/",
+    "blog/drafts/",
+    "blog/tag/",
+    "blog/tag/*",
+    "blog/category/",
+    "blog/category/*",
+    "blog/author/",
+    "blog/author/*",
+    "blog/????/",  # exclude years
 ]
-
-# If true, show URL addresses after external links.
-# man_show_urls = False
+# Suppress sphinx-sitemap warning (turned into error by
+# --fail-on-warning) occurring on CI.
+suppress_warnings = ["git.too_shallow"]
+
+# =====================================================================
+# sphinx-codeautolink
+# =====================================================================
+
+# Treat all code blocks on the same page as one interpreter session: a
+# variable defined in block 1 stays known in block 2. Without this,
+# snippets like `>>> p = psutil.Process()` followed by `>>> p.name()`
+# in a later block lose the type of `p`.
+codeautolink_concat_default = True
+
+# Seed every block with an implicit `import psutil`, so snippets that
+# start mid-session (no explicit import line) still have `psutil.X`
+# references resolvable.
+codeautolink_global_preface = "import psutil"
+
+# Print warnings for names it can't resolve.
+# codeautolink_warn_on_failed_resolve = True
+
+# =====================================================================
+# Sphinx setup hook
+# =====================================================================
+
+
+def setup(app):
+    # sphinx-codeautolink needs `import psutil` to resolve things like
+    # `p.name()` in code blocks. It imports psutil itself internally,
+    # but silently passes if it can't, so we do it here to crash
+    # explicitly. Kept inside setup() (not at module scope) so pytest
+    # collection of docs/test_docs.py doesn't hit it.
+    import psutil  # noqa: F401
+
+    # ablog and sphinx-codeautolink synthesize pages (blog/tag/*,
+    # blog/2025, _modules/*) with no .rst behind them. The footer's
+    # "Edit on GitHub" / "Updated" links would point at files that
+    # don't exist.
+    def set_has_rst_source(app, pagename, templatename, context, doctree):
+        path = pathlib.Path(app.env.doc2path(pagename))
+        context["has_rst_source"] = path.is_file()
+
+    app.connect("html-page-context", set_has_rst_source)
diff --git a/docs/credits.rst b/docs/credits.rst
new file mode 100644
index 0000000000..a583decf43
--- /dev/null
+++ b/docs/credits.rst
@@ -0,0 +1,452 @@
+Credits
+=======
+
+I would like to recognize some of the people who have been instrumental in the
+development of psutil. I'm sure I'm forgetting someone (feel free to email me)
+but here is a short list.
+
+A big thanks to all of you.
+
+— Giampaolo Rodola
+
+Top contributors
+----------------
+
+* :user:`Giampaolo Rodola <giampaolo>`: creator, primary author and long-time
+  maintainer
+* :user:`Jay Loden <jloden>`: original co-author, initial design and project
+  bootstrap, initial macOS / Windows / FreeBSD implementations
+* :user:`Arnon Yaari <wiggin15>`: AIX implementation
+* :user:`Landry Breuil <landryb>`: initial OpenBSD implementation
+* :user:`Ryo Onodera <ryoon>` and :user:`Thomas Klausner <0-wiz-0>`: initial
+  NetBSD implementation
+
+Donations
+---------
+
+The following individuals and organizations have supported psutil development
+through donations.
+
+Companies:
+
+* `Apivoid`_ *(sponsor)*
+* `Canonical Juju`_
+* `Canonical Launchpad`_
+* `Canonical`_
+* `Codecov`_
+* `Indeed Engineering`_
+* `Kubernetes`_
+* `Robusta`_
+* `sansec.io`_ *(sponsor)*
+* `Sentry`_
+* `Sourcegraph`_
+* `Tidelift`_ *(sponsor)*
+
+People:
+
+* :user:`Alex Laird <alexdlaird>`
+* Alexander Kaftan
+* `Alexey Vazhnov`_
+* Amit Kulkarni
+* Andrew Bays
+* :user:`Artyom Vancyan <ArtyomVancyan>`
+* Brett Harris
+* :user:`c0m4r`
+* Carver Koella
+* `Chenyoo Hao`_
+* :user:`CoÅŸkun Deniz <coskundeniz>`
+* :user:`cybersecgeek`
+* :user:`Daniel Widdis <dbwiddis>`
+* :user:`Eugenio E Breijo <u93>`
+* :user:`Evan Allrich <eallrich>`
+* Florian Bruhin
+* :user:`great-work-told-is`
+* Gyula �fra
+* HTB Industries
+* :user:`inarikami`
+* :user:`JeremyGrosser`
+* :user:`Johannes Maron <codingjoe>`
+* :user:`Jakob P. Liljenberg <aristocratos>`
+* :user:`Karthik Kumar <guilt>`
+* Kahntent
+* Kristjan Võrk
+* Mahmut Dumlupinar
+* Marco Schrank
+* Matthew Callow
+* Mindview LLC
+* :user:`Maximilian Wu <maxesisn>`
+* Mehver
+* mirko
+* Morgan Heijdemann
+* Oche Ejembi
+* :user:`Ofek Lev <ofek>`
+* Olivier Grisel
+* Pavan Maddamsetti
+* `PySimpleGUI`_
+* Peter Friedland
+* Praveen Bhamidipati
+* Remi Chateauneu
+* `roboflow.com`_
+* Rodion Stratov
+* Russell Robinson
+* :user:`Sašo Živanović <sasozivanovic>`
+* `scoutapm-sponsorships`_
+* Sigmund Vik
+* `trashnothing.com`_
+* Thomas Guettler
+* Willem de Groot
+* Wompasoft
+* :user:`Valeriy Abramov <abramov-v>`
+* Григорьев �ндрей
+
+Code contributors by year
+-------------------------
+
+.. image:: https://img.shields.io/github/contributors/giampaolo/psutil.svg?label=Total%20contributors&style=flat
+    :target: https://github.com/giampaolo/psutil/graphs/contributors
+    :alt: contributors
+
+2026
+~~~~
+
+* :user:`Alex Chen <l46983284-cpu>` - :gh:`2859`, :gh:`1959`
+* :user:`Amaan Qureshi <amaanq>` - :gh:`2770`
+* :user:`Anshul Nautiyal <ANSHUL-REAL>` - :gh:`2858`
+* :user:`Arman Luthra <Arman-Luthra>` - :gh:`2695`
+* :user:`Bert Pluymers <bertpl>` - :gh:`2642`
+* :user:`Data-hYg <Data-hYg>` - :gh:`2789`
+* :user:`Ding Qiuran <dynapx>` - :gh:`2860`
+* :user:`Ehtesham Siddiqui <EhteshamSid>` - :gh:`2793`
+* :user:`Felix Yan <felixonmars>` - :gh:`2732`
+* :user:`Gabriel Changamire <gabrielchangamire-arch>` - :gh:`2809`
+* :user:`Hanson Wang <hansonw>` - :gh:`2810`
+* :user:`Jinhyuk Hong <jinh-labs>` - :gh:`2855`
+* :user:`Julien Stephan <justeph>` - :gh:`2512`
+* :user:`Karl Hill <karlhillx>` - :gh:`2857`
+* :user:`Kataoka Katsuki <kataokatsuki>` - :gh:`2854`
+* :user:`Marcel Telka <mtelka>` - :gh:`2687`
+* :user:`Omprakash Chauhan <omprakash2929>` - :gh:`2655`
+* :user:`Robert Kirkman <robertkirkman>` - :gh:`2611`
+* :user:`Santhosh Raju <fraggerfox>` - :gh:`2805`
+* :user:`Sebastian Cao <cycsmail>` - :gh:`2628`
+* :user:`Sergey Fedorov <barracuda156>` - :gh:`2701`
+* :user:`Tobias Klauser <tklauser>` - :gh:`2711`
+
+2025
+~~~~
+
+* :user:`Ben Peddell <klightspeed>` - :gh:`2495`, :gh:`2568`
+* :user:`Ben Raz <ben9923>` - :gh:`2643`
+* :user:`Eli Wenig <elisw93>` - :gh:`2638`
+* :user:`Fabien Bousquet <fafanoulele>` - :gh:`2529`
+* :user:`Irene Sheen <ceda-ei>` - :gh:`2606`
+* :user:`Isaac K. Ko <1saac-k>` - :gh:`2612`
+* :user:`Jonathan Kohler <kohlerjl>` - :gh:`2527`
+* :user:`Lysandros Nikolaou <lysnikolaou>` - :gh:`2565`, :gh:`2588`,
+  :gh:`2589`, :gh:`2590`, :gh:`2591`, :gh:`2609`, :gh:`2615`, :gh:`2627`,
+  :gh:`2659` (wheels for free-threaded Python)
+* :user:`Marcel Telka <mtelka>` - :gh:`2469`, :gh:`2545`, :gh:`2546`,
+  :gh:`2592`, :gh:`2594`
+* :user:`Matthieu Darbois <mayeut>` - :gh:`2503`, :gh:`2581` (Windows ARM64
+  wheels)
+* :user:`Sergey Fedorov <barracuda156>` - :gh:`2694`
+* :user:`Will Hawes <wdh>` - :gh:`2496`
+* :user:`Xianpeng Shen <shenxianpeng>` - :gh:`2640`
+
+2024
+~~~~
+
+* :user:`Aleksey Lobanov <AlekseyLobanov>` - :gh:`2457`
+* :user:`Cristian Vîjdea <cvijdea-bd>` - :gh:`2442`
+* :user:`Matthieu Darbois <mayeut>` - :gh:`2370`, :gh:`2375`, :gh:`2417`,
+  :gh:`2425`, :gh:`2429`, :gh:`2450`, :gh:`2479`, :gh:`2486` (macOS and Linux
+  ARM64 wheels)
+* :user:`Mayank Jha <maynk27>` - :gh:`2379`
+* :user:`Oliver Tomé <snom3ad>` - :gh:`2222`
+* :user:`Ryan Carsten Schmidt <ryandesign>` - :gh:`2361`, :gh:`2364`,
+  :gh:`2365`
+* :user:`Sam Gross <colesbury>` - :gh:`2401`, :gh:`2402`, :gh:`2427`,
+  :gh:`2428` (free-threading Python)
+* :user:`Shade Gladden <shadeyg56>` - :gh:`2376`
+
+2023
+~~~~
+
+* :user:`Amir Rossert <arossert>` - :gh:`2346`
+* :user:`Matthieu Darbois <mayeut>` - :gh:`2211`, :gh:`2216`, :gh:`2246`,
+  :gh:`2247`, :gh:`2252`, :gh:`2269`, :gh:`2270`, :gh:`2315`
+* :user:`Po-Chuan Hsieh <sunpoet>` - :gh:`2186`, :gh:`1646`
+* :user:`Thomas Klausner <0-wiz-0>` - :gh:`2241`
+* :user:`Xuehai Pan <XuehaiPan>` - :gh:`2266`
+
+2022
+~~~~
+
+* :user:`Amir Rossert <arossert>` - :gh:`2156`, :gh:`2345`
+* :user:`Bernhard Urban-Forster <lewurm>` - :gh:`2135`
+* :user:`Chris Lalancette <clalancette>` - :gh:`2037` (:func:`net_if_stats`
+  flags arg on POSIX)
+* :user:`Daniel Li <li-dan>` - :gh:`2150`
+* :user:`Daniel Widdis <dbwiddis>` - :gh:`2077`, :gh:`2160`
+* :user:`Garrison Carter <garrisoncarter>` - :gh:`2096`
+* :user:`Hiroyuki Tanaka <myheroyuki>` - :gh:`2086`
+* :user:`Hugo van Kemenade <hugovk>` - :gh:`2099` (Drop Python 2.6 support)
+* :user:`Lawrence D'Anna <smoofra>` - :gh:`2010`
+* :user:`Matthieu Darbois <mayeut>` - :gh:`1954`, :gh:`2021`, :gh:`2039`,
+  :gh:`2040`, :gh:`2102`, :gh:`2111`, :gh:`2142`, :gh:`2145`, :gh:`2146`,
+  :gh:`2147`, :gh:`2153`, :gh:`2155`, :gh:`2168`
+* :user:`Steve Dower <zooba>` - :gh:`2080`
+* :user:`Thomas Klausner <0-wiz-0>` - :gh:`2088`, :gh:`2128`
+* :user:`Torsten Blum <Torsten-B>` - :gh:`2114`
+
+2021
+~~~~
+
+* :user:`David Knaack <davidkna>` - :gh:`1921`
+* :user:`Guillermo <guille>` - :gh:`1913`
+* :user:`Martin Liška <marxin>` - :gh:`1851`
+* :user:`MaWe2019 <MaWe2019>` - :gh:`1953`
+* :user:`Nikita Radchenko <nradchenko>` - :gh:`1940`
+* :user:`Oleksii Shevchuk <alxchk>` - :gh:`1904`
+* :user:`Olivier Dormond <odormond>` - :gh:`1956`
+* :user:`Pablo Baeyens <mx-psi>` - :gh:`1598`
+* :user:`PetrPospisil <PetrPospisil>` - :gh:`1980`
+* :user:`Saeed Rasooli <ilius>` - :gh:`1996`
+* :user:`Wilfried Goesgens <dothebart>` - :gh:`1990`
+* :user:`Xuehai Pan <XuehaiPan>` - :gh:`1949`
+
+2020
+~~~~
+
+* :user:`Anselm Kruis <akruis>` - :gh:`1695`
+* :user:`Armin Gruner <ArminGruner>` - :gh:`1800` (:meth:`Process.environ` on
+  BSD)
+* :user:`Chris Burger <phobozad>` - :gh:`1830`
+* :user:`vser1 <vser1>` - :gh:`1637`
+* :user:`Grzegorz Bokota <Czaki>` - :gh:`1758`, :gh:`1762`
+* :user:`Jake Omann <jomann09>` - :gh:`1876`
+* :user:`Jakob P. Liljenberg <aristocratos>` - :gh:`1837`, :gh:`1838`
+* :user:`Javad Karabi <karabijavad>` - :gh:`1648`
+* :user:`Julien Lebot <julien-lebot>` - :gh:`1768` (Windows Nano server
+  support)
+* :user:`Michał Górny <mgorny>` - :gh:`1726`
+* :user:`Mike Hommey <glandium>` - :gh:`1665`
+* :user:`Po-Chuan Hsieh <sunpoet>` - :gh:`1646`
+* :user:`Riccardo Schirone <ret2libc>` - :gh:`1616`
+* :user:`Tim Schlueter <modelrockettier>` - :gh:`1708`
+* :user:`Vincent A. Arcila <jandrovins>` - :gh:`1620`, :gh:`1727`
+
+2019
+~~~~
+
+* :user:`qcha0 <qcha0>` - :gh:`1491`
+* :user:`Alex Manuskin <amanusk>` - :gh:`1487`
+* :user:`Ammar Askar <ammaraskar>` - :gh:`1485` (:func:`getloadavg` on Windows)
+* :user:`Arnon Yaari <wiggin15>` - :gh:`607`, :gh:`1349`, :gh:`1409`,
+  :gh:`1500`, :gh:`1505`, :gh:`1507`, :gh:`1533`
+* :user:`Athos Ribeiro <athos-ribeiro>` - :gh:`1585`
+* :user:`Benjamin Drung <bdrung>` - :gh:`1462`
+* :user:`Bernát Gábor <gaborbernat>` - :gh:`1565`
+* :user:`Cedric Lamoriniere <clamoriniere>` - :gh:`1470`
+* :user:`Daniel Beer <dbeer1>` - :gh:`1471`
+* :user:`David Brochart <davidbrochart>` - :gh:`1493`, :gh:`1496`
+* :user:`EccoTheFlintstone <EccoTheFlintstone>` - :gh:`1368`, :gh:`1348`
+* :user:`Erwan Le Pape <erwan-le-pape>` - :gh:`1570`
+* :user:`Ghislain Le Meur <gigi206>` - :gh:`1379`
+* :user:`Kamil Rytarowski <krytarowski>` - :gh:`1526`, :gh:`1530`, :gh:`1534`
+  (:meth:`Process.cwd` for NetBSD)
+* :user:`Nathan Houghton <n1000>` - :gh:`1619`
+* :user:`Samer Masterson <samertm>` - :gh:`1480`
+* :user:`Xiaoling Bao <xiaolingbao>` - :gh:`1223`
+* Mozilla Foundation - Sample code for process :term:`USS` memory
+
+2018
+~~~~
+
+* :user:`Alex Manuskin <amanusk>` - :gh:`1284`, :gh:`1345`, :gh:`1350`,
+  :gh:`1369` (:func:`sensors_temperatures` for macOS, FreeBSD, Linux)
+* :user:`Arnon Yaari <wiggin15>` - :gh:`1214`
+* :user:`Dan Vinakovsky <hexaclock>` - :gh:`1216`
+* :user:`Denis Krienbühl <href>` - :gh:`1260`
+* :user:`Ilya Yanok <yanok>` - :gh:`1332`
+* :user:`janderbrain <janderbrain>` - :gh:`1169`
+* :user:`Jaime Fullaondo <truthbk>` - :gh:`1320`
+* :user:`Jean-Luc Migot <jmigot-tehtris>` - :gh:`1258`, :gh:`1289`
+* :user:`Koen Kooi <koenkooi>` - :gh:`1360`
+* :user:`Lawrence Ye <LEAFERx>` - :gh:`1321`
+* :user:`Maxime Mouial <hush-hush>` - :gh:`1239`
+* :user:`Nikhil Marathe <nikhilm>` - :gh:`1278`
+* :user:`stswandering <stswandering>` - :gh:`1243`
+* :user:`Sylvain Duchesne <sylvainduchesne>` - :gh:`1294`
+
+2017
+~~~~
+
+* :user:`Adrian Page <adpag>` - :gh:`1160`
+* :user:`Akos Kiss <akosthekiss>` - :gh:`1150`
+* :user:`Alexander Hasselhuhn <alexanha>` - :gh:`1022`
+* :user:`Antoine Pitrou <pitrou>` - :gh:`1186`
+* :user:`Arnon Yaari <wiggin15>` - :gh:`1130`, :gh:`1137`, :gh:`1145`,
+  :gh:`1156`, :gh:`1164`, :gh:`1174`, :gh:`1177`, :gh:`1123` (AIX
+  implementation)
+* :user:`Baruch Siach <baruchsiach>` - :gh:`872`
+* :user:`Danek Duvall <dhduvall>` - :gh:`1002`
+* :user:`Gleb Smirnoff <glebius>` - :gh:`1070`, :gh:`1076`, :gh:`1079`
+* :user:`Himanshu Shekhar <himanshub16>` - :gh:`1036`
+* :user:`Jakub Bacic <jakub-bacic>` - :gh:`1127`
+* :user:`Matthew Long <matray>` - :gh:`1167`
+* :user:`Nicolas Hennion <nicolargo>` - :gh:`974`
+* :user:`Oleksii Shevchuk <alxchk>` - :gh:`1091`, :gh:`1093`, :gh:`1220`,
+  :gh:`1346`
+* :user:`Pierre Fersing <PierreF>` - :gh:`950`
+* :user:`Sebastian Saip <ssaip>` - :gh:`1141`
+* :user:`Thiago Borges Abdnur <bolaum>` - :gh:`959`
+* :user:`Yannick Gingras <ygingras>` - :gh:`1057`
+
+2016
+~~~~
+
+* :user:`Andre Caron <AndreLouisCaron>` - :gh:`880`
+* :user:`Arcadiy Ivanov <arcivanov>` - :gh:`919`
+* :user:`ewedlund <ewedlund>` - :gh:`874`
+* :user:`Eric Rahm <EricRahm>` - :gh:`745`, :gh:`746` (:term:`USS` memory on
+  macOS and Windows)
+* :user:`Farhan Khan <khanzf>` - :gh:`823`
+* :user:`Frank Benkstein <fbenkstein>` - :gh:`732`, :gh:`733`, :gh:`736`,
+  :gh:`738`, :gh:`739`, :gh:`740`
+* :user:`Ilya Georgievsky <xBeAsTx>` - :gh:`870`
+* :user:`Jake Omann <jomann09>` - :gh:`816`, :gh:`775`, :gh:`1874`
+* :user:`Jeremy Humble <jhumble>` - :gh:`863`
+* :user:`Landry Breuil <landryb>` - :gh:`741`
+* :user:`Mark Derbecker <mpderbec>` - :gh:`660`
+* :user:`Max Bélanger <maxbelanger>` - :gh:`936`, :gh:`1133`
+* :user:`Patrick Welche <prlw1>` - :gh:`812`
+* :user:`Syohei YOSHIDA <syohex>` - :gh:`730`
+* :user:`Timmy Konick <tijko>` - :gh:`751`
+* :user:`Yago Jesus <YJesus>` - :gh:`798`
+
+2015
+~~~~
+
+* :user:`Arnon Yaari <wiggin15>` - :gh:`680`, :gh:`679`, :gh:`610`
+* :user:`Bruno Binet <bbinet>` - :gh:`572`
+* :user:`Denis <denis-sumin>` - :gh:`541`
+* :user:`Fabian Groffen <fabian>` - :gh:`611`, :gh:`618`
+* :user:`Gabi Davar <mindw>` - :gh:`578`, :gh:`581`, :gh:`587`
+* :user:`Jeff Tang <mrjefftang>` - :gh:`616`, :gh:`648`, :gh:`653`, :gh:`654`
+* :user:`John Burnett <johnburnett>` - :gh:`614`
+* :user:`karthik <karthikrev>` - :gh:`568`
+* :user:`Landry Breuil <landryb>` - :gh:`713`, :gh:`709` (OpenBSD
+  implementation)
+* :user:`Mike Sarahan <msarahan>` - :gh:`690`
+* :user:`Sebastian-Gabriel Brestin <bsebi>` - :gh:`704`
+* :user:`sk6249 <sk6249>` - :gh:`670`
+* :user:`spacewander <spacewander>` - :gh:`561`, :gh:`603`, :gh:`555`
+* :user:`Steven Winfield <stevenwinfield>` - :gh:`672`
+* :user:`Sylvain Mouquet <sylvainmouquet>` - :gh:`565`
+* :user:`�rni Már Jónsson <arnimarj>` - :gh:`634`
+* :user:`Ryo Onodera <ryoon>`:
+  `e124acba <https://github.com/giampaolo/psutil/commit/e124acba>`_ (NetBSD
+  implementation)
+
+2014
+~~~~
+
+* :user:`Alexander Grothe <agrethe>` - :gh:`497`
+* :user:`Anders Chrigström <anders-chrigstrom>` - :gh:`548`
+* Francois Charron - :gh:`474`
+* :user:`Guido Imperiale <crusaderky>` - :gh:`470`, :gh:`477`
+* :user:`Jeff Tang <mrjefftang>` - :gh:`340`, :gh:`519`, :gh:`529`, :gh:`654`
+* :user:`Marc Abramowitz <msabramo>` - :gh:`492`
+* Naveed Roudsari - :gh:`421`
+* :user:`Yaolong Huang <airekans>` - :gh:`530`
+
+2013
+~~~~
+
+* :user:`Arfrever.FTA <Arfrever>` - :gh:`404`
+* :user:`Daniel Fox <danudey>` - :gh:`386`
+* Jason Kirtland - backward compatible implementation of
+  collections.defaultdict
+* :user:`John Baldwin <bsdjhb>` - :gh:`370`
+* John Pankov - :gh:`435`
+* :user:`Josiah Carlson <josiahcarlson>` - :gh:`451`, :gh:`452`
+* m.malycha - :gh:`351`
+* :user:`Matt Good <mgood>` - :gh:`438`
+* :user:`Thomas Klausner <0-wiz-0>` - :gh:`557` (NetBSD implementation)
+* Ulrich Klank - :gh:`448`
+
+2012
+~~~~
+
+* :user:`Amoser` - :gh:`266`, :gh:`267`, :gh:`340`
+* :user:`Florent Xicluna <florentx>` - :gh:`319`
+* :user:`Gregory Szorc <indygreg>` - :gh:`323`
+* :user:`Jan Beich <jbeich>` - :gh:`344`
+* Youngsik Kim - :gh:`317`
+
+2011
+~~~~
+
+* :user:`Jeremy Whitlock <whitlockjc>` - :gh:`125`, :gh:`150`, :gh:`206`,
+  :gh:`217`, :gh:`260` (:func:`net_io_counters` and :func:`disk_io_counters` on
+  macOS)
+
+2010
+~~~~
+
+* :user:`Christoph Gohlke <cgohlke>` - :gh:`107`
+* :user:`Wen Jia Liu (wj32) <wj32>` - :gh:`114`, :gh:`115`
+
+2009
+~~~~
+
+* Yan Raber: `c861c08b <https://github.com/giampaolo/psutil/commit/c861c08b>`_
+  (Windows :func:`cpu_times`),
+  `15159111 <https://github.com/giampaolo/psutil/commit/15159111>`_ (Windows
+  :meth:`Process.username`)
+* :user:`Jay Loden <jloden>` -
+  `79128baa <https://github.com/giampaolo/psutil/commit/79128baa>`_ (first
+  commit of FreeBSD implementation)
+
+2008
+~~~~
+
+* :user:`Jay Loden <jloden>` -
+  `efe9236a <https://github.com/giampaolo/psutil/commit/efe9236a>`_ (first
+  commit of macOS implementation)
+* Dave Daeschler -
+  `71875761 <https://github.com/giampaolo/psutil/commit/71875761>`_ (first
+  commit of Windows implementation)
+* :user:`Giampaolo Rodola <giampaolo>` -
+  `6296c2ab <https://github.com/giampaolo/psutil/commit/6296c2ab>`_ (first
+  commit of Linux implementation)
+* :user:`Giampaolo Rodola <giampaolo>` -
+  `8472a17f <https://github.com/giampaolo/psutil/commit/8472a17f>`_ (inception
+  / initial directory structure)
+
+.. People Donors
+.. ============================================================================
+
+.. _`Alexey Vazhnov`: https://opencollective.com/alexey-vazhnov
+.. _`Chenyoo Hao`: https://opencollective.com/chenyoo-hao
+.. _`PySimpleGUI`: https://github.com/PySimpleGUI
+.. _`roboflow.com`: https://github.com/roboflow
+.. _`sansec.io`: https://github.com/sansecio
+.. _`scoutapm-sponsorships`: https://github.com/scoutapm-sponsorships
+.. _`trashnothing.com`: https://github.com/Trash-Nothing
+
+.. Company donors
+.. ============================================================================
+
+.. _`Apivoid`: https://www.apivoid.com
+.. _`Canonical Juju`: https://github.com/juju
+.. _`Canonical Launchpad`: https://launchpad.net/
+.. _`Canonical`: https://github.com/canonical
+.. _`Codecov`: https://github.com/codecov
+.. _`Kubernetes`: https://github.com/kubernetes/kubernetes
+.. _`Indeed Engineering`: https://github.com/indeedeng
+.. _`Robusta`: https://github.com/robusta-dev
+.. _`Sentry`: https://sentry.io/
+.. _`Sourcegraph`: https://sourcegraph.com/
+.. _`Tidelift`: https://tidelift.com
diff --git a/docs/devguide.rst b/docs/devguide.rst
new file mode 100644
index 0000000000..42331c8009
--- /dev/null
+++ b/docs/devguide.rst
@@ -0,0 +1,221 @@
+Development guide
+=================
+
+.. seealso:: `Contributing to psutil project <https://github.com/giampaolo/psutil/blob/master/CONTRIBUTING.md>`_
+
+Build, setup and test
+---------------------
+
+- psutil makes extensive use of C code, so a C compiler and the Python
+  development headers are required. First clone the repository:
+
+  .. code-block:: bash
+
+     git clone https://github.com/giampaolo/psutil.git
+     cd psutil
+
+  On Linux, FreeBSD, OpenBSD, NetBSD and Solaris, install the system deps:
+
+  .. code-block:: bash
+
+     make install-sysdeps       # compiler + python headers
+     make install-sysdeps-test  # CLI tools used by tests
+
+  On macOS, AIX and Windows there's no such target, see
+  :ref:`install_from_source`. Then, everywhere:
+
+  .. code-block:: bash
+
+     make install-pydeps-dev    # python development deps (linters, etc)
+     make build                 # compile the C extension in place
+     make test
+
+- ``make`` (via the :src:`Makefile`) is used for building, testing and general
+  development tasks, including on Windows (see below):
+
+  .. code-block:: bash
+
+     make clean
+     make test
+     make test-parallel
+     make test-memleaks
+     make coverage
+     make lint-all
+     make fix-all
+     make uninstall
+     make help
+
+- To run a specific test:
+
+  .. code-block:: none
+
+     make test ARGS=tests/test_system.py
+
+- ``make build`` compiles the extension in place, so you can import psutil
+  straight from the repo. No need to install it.
+
+- Don't use ``sudo``, except for the ``install-sysdeps-*`` targets, which
+  invoke it themselves when needed.
+
+- To target a specific Python version, pass ``PYTHON`` to every step, so that
+  the extension is built by the same interpreter that runs the tests:
+
+  .. code-block:: none
+
+     make install-pydeps-dev PYTHON=python3.13
+     make build PYTHON=python3.13
+     make test PYTHON=python3.13
+
+Windows
+-------
+
+- The recommended way to develop on Windows is to use ``make``.
+- For the build tools, Git Bash and GNU Make setup see :ref:`install_windows`.
+- Once inside a Git Bash shell, run:
+
+  .. code-block:: bash
+
+     make install-pydeps-dev
+     make build
+     make test-parallel
+
+.. _devguide_debug_mode:
+
+Debug mode
+----------
+
+If you need to debug unusual situations or report a bug, you can enable debug
+mode via the :envvar:`PSUTIL_DEBUG` environment variable. In this mode, psutil
+may print additional information to stderr. Usually these are non-severe error
+conditions that are ignored instead of causing a crash. Unit tests
+automatically run with debug mode enabled. To enable debug mode in UNIX (or on
+Windows + Bash):
+
+.. code-block:: none
+
+  $ PSUTIL_DEBUG=1 python3 test_script.py
+  psutil-debug [psutil/_psutil_linux.c:150]> setmntent() failed (ignored)
+
+On Windows using cmd.exe:
+
+.. code-block:: none
+
+  set PSUTIL_DEBUG=1 && python.exe test_script.py
+  psutil-debug [psutil/arch/windows/proc.c:56]> ReadProcessMemory -> ERROR_NOACCESS (ignored)
+
+Coding style
+------------
+
+All style and formatting checks are enforced locally on each ``git commit`` and
+via a GitHub Actions pipeline.
+
+- Python: follows `PEP-8`_, formatted and linted with ``black`` and ``ruff``.
+- C: generally follows `PEP-7`_, formatted with ``clang-format``.
+- Other files (``.rst``, ``.toml``, ``.md``, ``.yml``): validated by linters.
+
+The pipeline re-runs all checks for consistency (``make lint-all``).
+
+Run ``make fix-all`` before committing; it usually fixes Python issues (via
+``black`` and ``ruff``) and C issues (via ``clang-format``).
+
+Code organization
+-----------------
+
+Not every API reaches C: many are implemented in python alone (on Linux, by
+parsing ``/proc``). For those that do, a call travels down through the
+platform-specific layers. Linux is used here as an example:
+
+.. code-block:: none
+
+   import psutil
+        │
+        â–¼
+   psutil/__init__.py          public API, Process class
+        │
+        â–¼
+   psutil/_pslinux.py          python layer: parses /proc, calls into C
+        │
+        â–¼
+   psutil/_psutil_linux.c      C extension entry point (arg parsing)
+        │
+        â–¼
+   psutil/arch/linux/*.c       platform-specific C implementation
+                               + arch/posix/*.c   shared by POSIX
+                               + arch/all/*.c     shared by everything
+
+Where things live:
+
+.. code-block:: bash
+
+   psutil/__init__.py                   # Public API ("import psutil")
+   psutil/_common.py                    # Generic utilities
+   psutil/_ntuples.py                   # Named tuples returned by psutil APIs
+   psutil/_enums.py                     # Enum containers
+   psutil/_ps{platform}.py              # OS-specific python wrapper
+   psutil/_psutil_{platform}.c          # OS-specific C extension (entry point)
+   psutil/arch/all/*.c                  # C code common to all OSes
+   psutil/arch/posix/*.c                # C code common to POSIX OSes
+   psutil/arch/bsd/*.c                  # C code common to the BSDs
+   psutil/arch/{platform}/*.c           # OS-specific C implementation
+   tests/test_process.py                # Main process API tests
+   tests/test_system.py                 # Main system API tests
+   tests/test_{platform}.py             # OS-specific tests
+
+Adding a new API
+----------------
+
+- Define the public API in :src:`psutil/__init__.py`.
+- Implement it for each applicable platform in ``psutil/_ps{platform}.py``
+  (e.g. :src:`psutil/_pslinux.py`).
+- If needed, add C code in ``psutil/arch/{platform}/file.c``.
+- Add a generic test in :src:`tests/test_system.py` or
+  :src:`tests/test_process.py`.
+- Add a platform-specific test in ``tests/test_{platform}.py``.
+- Update :src:`docs/api.rst`.
+- Open a pull request.
+
+Make a pull request
+-------------------
+
+- Fork psutil on GitHub.
+- Clone your fork: ``git clone git@github.com:YOUR-USERNAME/psutil.git``
+- Create a branch: ``git checkout -b new-feature``
+- Stage and commit: ``git add <files>`` then
+  ``git commit -m 'Add some feature'``
+- Push: ``git push origin new-feature``
+- Open a pull request (see :src:`CONTRIBUTING.md`).
+
+Continuous integration
+----------------------
+
+Tests run automatically on pull requests and on relevant pushes, covering all
+regularly tested platforms except AIX. See
+`.github/workflows <https://github.com/giampaolo/psutil/tree/master/.github/workflows>`_.
+
+Documentation
+-------------
+
+- Source is in the :src:`docs/ <docs/>` directory.
+- To build HTML:
+
+  .. code-block:: bash
+
+     make install-pydeps-docs
+     cd docs/
+     make html
+
+- The documentation is hosted at https://psutil.io. It's a single version,
+  rebuilt and deployed automatically on every push to ``master``.
+
+Releases
+--------
+
+For project maintainers:
+
+- Releases are uploaded to `PyPI`_ via ``make release``.
+- Git tags use the ``vX.Y.Z`` format (e.g. ``v7.2.2``).
+- The version string is defined in :src:`psutil/__init__.py` (``__version__``).
+
+.. _`PEP-7`: https://www.python.org/dev/peps/pep-0007/
+.. _`PEP-8`: https://www.python.org/dev/peps/pep-0008/
+.. _`PyPI`: https://pypi.org/project/psutil/
diff --git a/docs/faq.rst b/docs/faq.rst
new file mode 100644
index 0000000000..162878de79
--- /dev/null
+++ b/docs/faq.rst
@@ -0,0 +1,402 @@
+FAQ
+===
+
+This section answers common questions and pitfalls when using psutil.
+
+General
+-------
+
+.. _faq_named_tuple_unpacking:
+
+Why should I avoid positional unpacking of named tuples?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Most psutil functions return named tuples. It is tempting to unpack them
+positionally, but **field order may change across major releases** (as happened
+in 8.0 with :func:`cpu_times` and :meth:`Process.memory_info`). Always use
+attribute access instead:
+
+.. code-block:: python
+
+  # bad
+  rss, vms = p.memory_info()
+
+  # good
+  m = p.memory_info()
+  print(m.rss, m.vms)
+
+See the :ref:`migration guide <migration-8.0>` for the full list of field-order
+changes in 8.0.
+
+Exceptions
+----------
+
+.. _faq_access_denied:
+
+Why do I get AccessDenied?
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:exc:`AccessDenied` is raised when the OS refuses to return information about a
+process because the calling user does not have sufficient privileges. This is
+expected behavior and is not a bug. It typically happens when:
+
+- querying processes owned by other users (e.g. *root*)
+- calling certain methods like :meth:`Process.memory_maps`,
+  :meth:`Process.open_files` or :meth:`Process.net_connections` for privileged
+  processes
+
+You have two options to deal with it.
+
+- Option 1: call the method directly and catch the exception:
+
+  .. code-block:: python
+
+    import psutil
+
+    p = psutil.Process(pid)
+    try:
+        print(p.memory_maps())
+    except (psutil.AccessDenied, psutil.NoSuchProcess):
+        pass
+
+- Option 2: use :func:`process_iter` with a list of attribute names to
+  pre-fetch. Both :exc:`AccessDenied` and :exc:`NoSuchProcess` are handled
+  internally: the corresponding method returns ``None`` (or ``ad_value``)
+  instead of raising. This also avoids the race condition where a process
+  disappears between iteration and method call:
+
+  .. code-block:: python
+
+    import psutil
+
+    for p in psutil.process_iter(["name", "username"], ad_value="N/A"):
+        print(p.name(), p.username())  # no try/except needed
+
+.. _faq_no_such_process:
+
+Why do I get NoSuchProcess?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:exc:`NoSuchProcess` is raised when a process no longer exists. The most common
+cause is a race condition: a process can die between the moment its PID is
+obtained and the moment it is queried. The following two naive patterns are
+racy:
+
+.. code-block:: python
+
+  import psutil
+
+  for pid in psutil.pids():
+      p = psutil.Process(pid)  # may raise NoSuchProcess
+      print(p.name())  # may raise NoSuchProcess
+
+.. code-block:: python
+
+  import psutil
+
+  if psutil.pid_exists(pid):
+      p = psutil.Process(pid)  # may raise NoSuchProcess
+      print(p.name())  # may raise NoSuchProcess
+
+The correct approach is to use :func:`process_iter`, which handles
+:exc:`NoSuchProcess` internally and skips processes that disappear during
+iteration:
+
+.. code-block:: python
+
+  import psutil
+
+  for p in psutil.process_iter(["name"]):
+      print(p.name())
+
+If you have a specific PID (e.g. a known child process), wrap the call in a
+try/except:
+
+.. code-block:: python
+
+  import psutil
+
+  try:
+      p = psutil.Process(pid)
+      print(p.name(), p.status())
+  except (psutil.NoSuchProcess, psutil.AccessDenied):
+      pass
+
+You can also catch :exc:`Error`, which implies both :exc:`AccessDenied` and
+:exc:`NoSuchProcess`:
+
+.. code-block:: python
+
+  import psutil
+
+  try:
+      p = psutil.Process(pid)
+      print(p.name(), p.status())
+  except psutil.Error:
+      pass
+
+Processes
+---------
+
+.. _faq_pid_reuse:
+
+PID reuse
+^^^^^^^^^
+
+Operating systems recycle PIDs. A :class:`Process` object obtained now may
+later refer to a different process if the original one terminated and a new one
+was assigned the same PID.
+
+**How psutil handles this:**
+
+- *Most read-only methods* (e.g. :meth:`Process.name`,
+  :meth:`Process.cpu_percent`) do **not** check for PID reuse and instead query
+  whatever process currently holds that PID.
+
+- *Signal methods* (e.g. :meth:`Process.send_signal`, :meth:`Process.suspend`,
+  :meth:`Process.resume`, :meth:`Process.terminate`, :meth:`Process.kill`)
+  **do** check for PID reuse (via PID + creation time) before acting, raising
+  :exc:`NoSuchProcess` if the PID was recycled. This prevents accidentally
+  killing the wrong process (:bpo:`6973`).
+
+- *Set methods* :meth:`Process.nice` (set), :meth:`Process.ionice` (set),
+  :meth:`Process.cpu_affinity` (set), and :meth:`Process.rlimit` (set) also
+  perform this check before applying changes.
+
+:meth:`Process.is_running` is the recommended way to verify whether a
+:class:`Process` instance still refers to the same process. It compares PID and
+creation time, and returns ``False`` if the PID was reused. Prefer it over
+:func:`pid_exists`.
+
+.. note::
+
+  On FreeBSD, OpenBSD, SunOS and AIX the PID reuse check is disabled, and
+  process identity is based on the PID alone. That's because on these platforms
+  the process creation time is not stable across system clock updates (e.g.
+  NTP), which previously caused false :exc:`NoSuchProcess` exceptions for
+  processes which were still alive (:gh:`2888`).
+
+.. _faq_zombie_process:
+
+What is a zombie process?
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+A :term:`zombie process` is a process that has finished execution but whose
+entry remains in the process table until the parent calls ``wait()``. When
+psutil encounters a :term:`zombie process` it raises :exc:`ZombieProcess`, a
+subclass of :exc:`NoSuchProcess`.
+
+**Behavior:**
+
+- A zombie process can be instantiated via :class:`Process` (pid) without
+  error.
+- :meth:`Process.status` always returns :data:`STATUS_ZOMBIE`.
+- :meth:`Process.is_running` and :func:`pid_exists` return ``True``.
+- The zombie appears in :func:`process_iter` and :func:`pids`.
+- Sending signals (:meth:`Process.terminate`, :meth:`Process.kill`, etc.) has
+  no effect.
+- Most methods (:meth:`Process.cmdline`, :meth:`Process.exe`,
+  :meth:`Process.memory_maps`, etc.) may raise :exc:`ZombieProcess`, return a
+  meaningful value, or return a null/empty value depending on the platform.
+- :meth:`Process.as_dict` will not crash.
+
+**How to create a zombie:**
+
+.. code-block:: python
+
+  import os, time
+
+  pid = os.fork()  # the zombie
+  if pid == 0:
+      os._exit(0)  # child exits immediately
+  else:
+      time.sleep(1000)  # parent does NOT call wait()
+
+**How to detect zombies:**
+
+.. code-block:: python
+
+  import psutil
+
+  for p in psutil.process_iter(["status"]):
+      if p.status() == psutil.STATUS_ZOMBIE:
+          print(f"zombie: pid={p.pid}")
+
+**How to get rid of a zombie:**
+
+The only way is to have its parent process call ``wait()`` (or ``waitpid()``).
+If the parent never does this, killing the parent will cause the zombie to be
+re-parented to ``init`` / ``systemd``, which will reap it automatically.
+
+.. _faq_open_files_windows:
+
+Why does open_files() not return all files on Windows?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:meth:`Process.open_files` on Windows is not guaranteed to enumerate all
+regular file handles. The underlying Windows API may hang when retrieving
+certain :term:`handle` names, so psutil spawns a thread to query each handle
+and kills it if it doesn't respond within 100 ms. This means some entries can
+be missed. This is a known OS-level limitation shared by tools like Process
+Hacker (see `issue 597 <https://github.com/giampaolo/psutil/pull/597>`_).
+
+.. _faq_pid_exists_vs_isrunning:
+
+What is the difference between pid_exists() and Process.is_running()?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:func:`pid_exists` checks whether a PID is present in the process list.
+:meth:`Process.is_running` does the same, but also detects
+:ref:`PID reuse <faq_pid_reuse>` by comparing the process creation time. Use
+:func:`pid_exists` when you have a bare PID and don't need to guard against
+reuse (it's faster). Use :meth:`Process.is_running` when you hold a
+:class:`Process` object and want to confirm it still refers to the same
+process.
+
+CPU
+---
+
+.. _faq_cpu_percent:
+
+Why does cpu_percent() return 0.0 on first call?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:func:`cpu_percent` (and :meth:`Process.cpu_percent`) measures CPU usage
+*between two calls*. The very first call has no prior sample to compare
+against, so it always returns ``0.0``. The fix is to call it once to initialize
+the baseline, discard the result, then call it again after a short sleep:
+
+.. code-block:: python
+
+  import time
+  import psutil
+
+  psutil.cpu_percent()          # discard first call
+  time.sleep(0.5)
+  print(psutil.cpu_percent())   # meaningful value
+
+Alternatively, pass ``interval`` to make it block internally:
+
+.. code-block:: python
+
+  print(psutil.cpu_percent(interval=0.5))
+
+The same applies to :meth:`Process.cpu_percent`:
+
+.. code-block:: python
+
+  p = psutil.Process()
+  p.cpu_percent()               # discard
+  time.sleep(0.5)
+  print(p.cpu_percent())        # meaningful value
+
+.. _faq_cpu_percent_gt_100:
+
+Can Process.cpu_percent() return a value higher than 100%?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Yes. On a multi-core system a process can run threads on several CPUs at the
+same time. The maximum value is ``psutil.cpu_count() * 100``. For example, on a
+4-core machine a fully-loaded process can reach 400%. The system-wide
+:func:`cpu_percent` (without a :class:`Process`) always stays in the 0–100%
+range because it averages across all cores.
+
+The returned value is explicitly *not* split evenly between all available CPUs.
+This is consistent with the ``top`` UNIX utility: a busy loop on a system with
+2 :term:`logical CPUs <logical CPU>` is reported as 100%, not 50%. Note that
+Windows ``taskmgr.exe`` behaves differently (it would report 50%). To emulate
+that: ``p.cpu_percent() / psutil.cpu_count()``.
+
+.. _faq_cpu_count:
+
+What is the difference between psutil, os, and multiprocessing cpu_count()?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+- :func:`os.cpu_count` returns the number of :term:`logical CPUs <logical CPU>`
+  (including hyperthreads). It is the same as
+  ``psutil.cpu_count(logical=True)``, but psutil does not honour
+  :envvar:`PYTHON_CPU_COUNT` environment variable introduced in Python 3.13.
+- :func:`os.process_cpu_count` (Python 3.13+) returns the number of CPUs the
+  calling process is **allowed to use** (respects :term:`CPU affinity` and
+  cgroups). The psutil equivalent is ``len(psutil.Process().cpu_affinity())``.
+- :func:`multiprocessing.cpu_count` returns the same value as
+  :func:`os.process_cpu_count` (Python 3.13+).
+- :func:`psutil.cpu_count` with ``logical=False`` returns the number of
+  :term:`physical cores <physical CPU>`, which has no stdlib equivalent.
+
+Memory
+------
+
+.. _faq_virtual_memory_available:
+
+What is the difference between virtual_memory() available and free?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:func:`virtual_memory` returns both :field:`free` and :field:`available`, but
+they measure different things:
+
+- :field:`free`: memory that is not being used at all.
+- :field:`available`: how much memory can be given to processes without
+  :term:`swapping <swap memory>`. This includes reclaimable
+  :term:`caches <page cache>` and :term:`buffers` that the OS can reclaim under
+  pressure.
+
+In practice, :field:`available` is almost always the metric you want when
+monitoring memory. :field:`free` can be misleadingly low on systems where the
+OS aggressively uses RAM for caches (which is normal and healthy). On Windows,
+:field:`free` and :field:`available` are the same value.
+
+.. _faq_memory_rss_vs_vms:
+
+What is the difference between RSS and VMS?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+- :field:`rss` (:term:`Resident Set Size <RSS>`) is the amount of physical
+  memory (RAM) currently mapped into the process.
+- :field:`vms` (:term:`Virtual Memory Size <VMS>`) is the total virtual address
+  space of the process, including memory that has been
+  :term:`swapped out <swap-out>`, shared libraries, and
+  :term:`memory-mapped files <mapped memory>`.
+
+:field:`rss` is generally the most useful metric for answering "how much RAM is
+this process using?". Note that it includes :term:`shared memory`, so it may
+overestimate actual usage when compared across processes. :field:`vms` is
+generally larger and can be misleadingly high, as it includes memory that is
+not resident in physical RAM. Both values are portable across platforms and are
+returned by :meth:`Process.memory_info`.
+
+.. _faq_memory_footprint:
+
+When should I use memory_footprint() vs memory_info()?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:meth:`Process.memory_info` returns :field:`rss`
+(:term:`Resident Set Size <RSS>`), which includes
+:term:`shared libraries <shared memory>` counted in every process that uses
+them. For example, if ``libc`` uses 2 MB and 100 processes map it, each process
+includes those 2 MB in its :field:`rss`.
+
+:meth:`Process.memory_footprint` returns :field:`uss`
+(:term:`Unique Set Size <USS>`), i.e. :term:`private memory` of the process. It
+represents the amount of memory that would be freed if the process were
+terminated right now. It is more accurate than :term:`RSS`, but substantially
+slower and requires higher privileges. On Linux it also returns :field:`pss`
+(:term:`Proportional Set Size <PSS>`) and :term:`swap <swap memory>`.
+
+.. _faq_used_plus_free:
+
+Why does virtual_memory() used + free != total?
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Because some memory (like :term:`page cache` and :term:`buffers`) is
+reclaimable and accounted separately:
+
+.. code-block:: pycon
+
+  >>> import psutil
+  >>> m = psutil.virtual_memory()
+  >>> m.used + m.free == m.total
+  False
+
+The :field:`available` field already includes this reclaimable memory and is
+the best indicator of memory pressure. See :ref:`faq_virtual_memory_available`.
diff --git a/docs/funding.rst b/docs/funding.rst
new file mode 100644
index 0000000000..72234552be
--- /dev/null
+++ b/docs/funding.rst
@@ -0,0 +1,50 @@
+Funding
+=======
+
+psutil is free and open source software, maintained by a single developer in
+his spare time. It is among the
+`top 100 most-downloaded Python packages <https://pypistats.org/top>`_, used by
+millions of developers and hundreds of thousands of projects worldwide,
+including TensorFlow, PyTorch, Home Assistant, Ansible, and Celery.
+
+Keeping up with bug reports, platform compatibility, user support, and ongoing
+maintenance has become increasingly difficult to sustain as a one-person
+effort. Financial support helps dedicate more time to the project and ensures
+its long-term health.
+
+How to fund
+-----------
+
+There are several ways to support psutil development financially:
+
+`GitHub Sponsors <https://github.com/sponsors/giampaolo>`_
+    The preferred platform for recurring or one-time sponsorships. GitHub
+    matches contributions for eligible sponsors.
+
+`Open Collective <https://opencollective.com/psutil>`_
+    Transparent, open funding for individuals and companies. Expenses and
+    income are publicly visible.
+
+`PayPal <https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=A9ZS7PKKRM3S8>`_
+    One-time donations via PayPal.
+
+For companies
+-------------
+
+If your company relies on psutil in production, consider becoming a sponsor.
+Benefits include:
+
+- Your logo displayed on the `psutil homepage <https://psutil.io>`_ and the
+  `GitHub repository <https://github.com/giampaolo/psutil>`_.
+- Priority response to bug reports and feature requests.
+- The assurance that the library you depend on is actively maintained.
+
+To discuss sponsorship options, contact the author at g.rodola@gmail.com.
+
+Current sponsors
+----------------
+
+.. raw:: html
+   :file: _sponsors.html
+
+Past donors are listed in the :doc:`credits` page.
diff --git a/docs/glossary.rst b/docs/glossary.rst
new file mode 100644
index 0000000000..e152076ae8
--- /dev/null
+++ b/docs/glossary.rst
@@ -0,0 +1,355 @@
+Glossary
+========
+
+.. glossary::
+   :sorted:
+
+   anonymous memory
+
+      RAM used by the program that is not associated with any file (unlike the
+      :term:`page cache`), such as the :term:`heap`, the stack, and other
+      memory allocated directly by the program (e.g. via ``malloc()``).
+      Anonymous pages have no on-disk counterpart and must be written to
+      :term:`swap memory` if evicted. Exposed by psutil via the :field:`rss_anon`
+      field of :meth:`Process.memory_extras` (total resident anonymous pages)
+      and the :field:`anonymous` field of :meth:`Process.memory_maps` (per
+      mapping). Anonymous regions are also visible in the :field:`path` column
+      of :meth:`Process.memory_maps` as ``"[heap]"``, ``"[stack]"``, or an
+      empty string.
+
+   available memory
+
+      The amount of RAM that can be given to processes without the system going
+      into :term:`swap <swap memory>`. This is the right field to watch for
+      memory pressure, not :field:`free`. :field:`free` is often deceptively low
+      because the OS keeps recently freed pages as reclaimable cache; those pages
+      are counted in :field:`available` but not in :field:`free`.
+      A monitoring alert should fire on :field:`available` (or :field:`percent`)
+      falling below a threshold, not on :field:`free`. See :func:`virtual_memory`.
+
+   buffers
+
+      Kernel memory used to cache filesystem metadata such as
+      superblocks, inodes, and directory entries. Distinct from the
+      :term:`page cache`, which caches file *contents*.
+      Like the page cache, buffer memory is reclaimable: the OS can
+      free it under memory pressure.
+      Reported as the :field:`buffers` field of :func:`virtual_memory`
+      (Linux, BSD).
+
+   busy_time
+
+      A :term:`cumulative counter` (milliseconds) tracking the time a disk
+      device spent actually performing I/O, as reported in the :field:`busy_time`
+      field of :func:`disk_io_counters` (Linux and FreeBSD only). To use it,
+      sample twice and divide the delta by elapsed time to get a utilization
+      percentage (analogous to CPU percent but for disks). A value close to
+      100% means the disk is saturated.
+
+      .. seealso:: :ref:`Real-time disk I/O percent recipe <recipe_disk_io_percent>`
+
+   CPU affinity
+
+      A property of a process (or thread) that restricts which
+      :term:`logical CPUs <logical CPU>` it is allowed to run on. For example,
+      pinning a process to CPU 0 and CPU 1 prevents the OS scheduler from
+      moving it to other cores. This could be useful, e.g., for benchmarking.
+      See :meth:`Process.cpu_affinity`.
+
+   context switch
+
+      Occurs when the CPU stops executing one process or thread for another.
+      Frequent switching can indicate high system
+      load or thread contention. See :meth:`Process.num_ctx_switches`
+      and :func:`cpu_stats` (:field:`ctx_switches` field).
+      A :field:`voluntary` context switch occurs when a process gives up the
+      CPU, usually because it's waiting for something (I/O, a sleep, a mutex
+      lock). High rates are normal for I/O-bound workloads (e.g. a web server)
+      and usually point to I/O or locking as the bottleneck.
+      An :field:`involuntary` context switch occurs when the OS forcibly takes
+      the CPU from the process. High rates mean the process has more work to do
+      but is being kicked off the core. This usually indicates too many active
+      threads/processes competing for too few CPU cores.
+
+   cumulative counter
+
+      A field whose value only increases over time (since boot or process
+      creation) and never resets. Examples include :func:`cpu_times`,
+      :func:`disk_io_counters`, :func:`net_io_counters`,
+      :meth:`Process.io_counters`, and :meth:`Process.num_ctx_switches`.
+      The raw value is rarely useful on its own; divide the delta between
+      two samples by the elapsed time to get a meaningful rate (e.g.
+      bytes per second, context switches per second).
+
+   file descriptor
+
+      An integer handle used by UNIX processes to reference open files,
+      sockets, pipes, and other I/O resources. On Windows the equivalent
+      are :term:`handles <handle>`. Leaking file descriptors (opening without
+      closing) eventually causes ``EMFILE`` / ``Too many open files`` errors.
+      See :meth:`Process.num_fds` and :meth:`Process.open_files`.
+
+   handle
+
+      On Windows, an opaque reference to a kernel object such as a file,
+      thread, process, event or mutex. Handles are the Windows equivalent of
+      UNIX :term:`file descriptors <file descriptor>`. Each open handle
+      consumes a small amount of kernel memory. Leaking / unclosed
+      handles eventually causes ``ERROR_NO_MORE_FILES`` or similar errors. See
+      :meth:`Process.num_handles`.
+
+   hardware interrupt
+
+      A signal sent by a hardware device (disk controller, :term:`NIC`, keyboard)
+      to the CPU to request attention. Each interrupt briefly preempts
+      whatever the CPU was doing. Reported as the :field:`interrupts` field of
+      :func:`cpu_stats` and :field:`irq` field of :func:`cpu_times`.
+      A very high rate may indicate a misbehaving device driver or a heavily
+      loaded :term:`NIC`. Also see :term:`soft interrupt`.
+
+   heap
+
+      The memory region managed by the platform's native C allocator
+      (e.g. glibc's ``malloc`` on Linux, ``jemalloc`` on FreeBSD,
+      ``HeapAlloc`` on Windows). When a C extension calls ``malloc()``
+      and never calls ``free()``, the leaked bytes show up here but
+      are not always visible to Python's memory tracking tools
+      (:mod:`tracemalloc`, :func:`sys.getsizeof`) or :term:`RSS` / :term:`VMS`.
+      :func:`heap_info` exposes the current state of the heap, and
+      :func:`heap_trim` asks the allocator to release unused portions
+      of it. Together they provide a way to detect memory leaks in C
+      extensions that standard process-level metrics would otherwise miss.
+
+   involuntary context switch
+
+      See :term:`context switch`.
+
+   iowait
+
+      A CPU time field (Linux, SunOS, AIX) measuring time spent by the CPU
+      waiting for I/O operations to complete. High iowait indicates a
+      disk or network bottleneck. It is reported as part of
+      :func:`cpu_times` but is *not* included in the idle counter.
+      To get it as a percentage: ``psutil.cpu_times_percent(interval=1).iowait``.
+      Note that this is a CPU metric, not a disk metric: it measures how much
+      CPU time is wasted waiting, not how busy the disk is. See also
+      :term:`busy_time` for actual disk utilization.
+
+   ionice
+
+      An I/O scheduling priority that controls how much disk bandwidth a
+      process receives. On Linux three scheduling classes are supported:
+      :data:`IOPRIO_CLASS_RT` (real-time), :data:`IOPRIO_CLASS_BE`
+      (best-effort, the default), and :data:`IOPRIO_CLASS_IDLE`. See
+      :meth:`Process.ionice`.
+
+   logical CPU
+
+      A CPU as seen by the operating system scheduler. On systems with
+      *hyper-threading* each physical core exposes two logical CPUs, so a
+      4-core hyper-threaded chip has 8 logical CPUs. This is the count
+      returned by :func:`cpu_count` (the default) and the number of
+      entries returned by ``cpu_percent(percpu=True)``. See also
+      :term:`physical CPU`.
+
+   mapped memory
+
+      A region of a process's virtual address space typically created via
+      ``mmap()``. Mappings can be file-backed (e.g. shared libraries,
+      memory-mapped files) or :term:`anonymous <anonymous memory>`.
+      Each mapping has its own permissions and memory accounting fields
+      (:term:`RSS`, :term:`PSS`, private / shared pages).
+      See :meth:`Process.memory_maps`.
+
+   NIC
+
+      *Network Interface Card*, a hardware or virtual network interface.
+      psutil uses this term when referring to per-interface network
+      statistics. See :func:`net_if_addrs` and :func:`net_if_stats`.
+
+   nice
+
+      A process priority value that influences how much CPU time the OS
+      scheduler gives to a process. Lower nice values mean higher priority. The
+      range is −20 (highest priority) to 19 (lowest) on UNIX; on Windows the
+      concept maps to :ref:`priority constants <const-proc-prio>`. See
+      :meth:`Process.nice`.
+
+   page cache
+
+      RAM used to cache data of regular files on disk.
+      When a process reads a file, the data stays in the page cache, and when
+      it writes, the data is first stored in the cache before being written to
+      disk. Subsequent reads or writes can be served from RAM without disk I/O,
+      making access fast. The OS reclaims page cache automatically under memory
+      pressure, so a large cache is healthy. Shown as the :field:`cached` field
+      of :func:`virtual_memory` on Linux/BSD.
+
+   page fault
+
+      An event that occurs when a process accesses a virtual memory page that
+      is not currently mapped in physical RAM. A :field:`minor` fault occurs
+      when a page is already in physical RAM (e.g., in the :term:`page cache`
+      or other :term:`shared memory`), but it's not yet mapped into the
+      process's virtual address space, so no disk I/O is required (fast). A
+      :field:`major` fault requires reading the page from disk, and is
+      significantly more expensive. Many major faults may indicate memory
+      pressure or excessive swapping. See :meth:`Process.page_faults`.
+
+   peak_rss
+
+      The highest :term:`RSS` value a process has ever reached since it
+      started (memory high-water mark). Available via
+      :meth:`Process.memory_info` (BSD, Windows) and
+      :meth:`Process.memory_extras` (Linux). Useful for capacity
+      planning and leak detection: if :field:`peak_rss` keeps growing across
+      successive runs or over time, the process is likely leaking memory.
+      See also :term:`peak_vms`.
+
+   peak_vms
+
+      The highest :term:`VMS` value a process has ever reached since it
+      started. Available via :meth:`Process.memory_extras` (Linux) and
+      :meth:`Process.memory_info` (Windows). On Windows this maps to
+      ``PeakPagefileUsage`` (peak :term:`private <private memory>` committed
+      memory), which is not the same as UNIX VMS. See also :term:`peak_rss`.
+
+   physical CPU
+
+      An actual hardware CPU core on the motherboard, as opposed to a
+      :term:`logical CPU`. A single physical core may appear as multiple
+      logical CPUs when hyper-threading is enabled. The physical count is
+      returned by ``cpu_count(logical=False)``.
+
+   private memory
+
+      Memory pages not shared with any other process, such as the
+      :term:`heap`, the stack, and other allocations made directly by the
+      program, e.g. via ``malloc()``.
+      :term:`USS`, returned by :meth:`Process.memory_footprint`, measures
+      exactly the private memory of a process, that is the bytes that would be
+      freed if the process exited. At a per-mapping level, the
+      :field:`private_clean` and :field:`private_dirty` fields of
+      :meth:`Process.memory_maps` (Linux) and the :field:`private` field (FreeBSD)
+      break it down further.
+
+   PSS
+
+      *Proportional Set Size*, the amount of RAM used by a process,
+      where :term:`shared memory` pages are divided proportionally among all
+      processes that map them. PSS gives a fairer per-process memory estimate
+      than :term:`RSS` when shared libraries are involved. Available on Linux
+      via :meth:`Process.memory_footprint`.
+
+   resource limit
+
+      A per-process cap on a system resource enforced by the kernel (POSIX
+      :data:`RLIMIT_* <psutil.RLIM_INFINITY>` constants).
+      Each limit has a *soft* value (the current enforcement threshold, which
+      the process may raise up to the hard limit) and a *hard* value
+      (the ceiling, settable only by root).
+      Common limits include :data:`RLIM_INFINITY` (open file descriptors),
+      :data:`RLIMIT_AS` (virtual address space), and :data:`RLIMIT_CPU`
+      (CPU time in seconds). See :meth:`Process.rlimit`.
+
+   RSS
+
+      *Resident Set Size*, the amount of physical RAM currently used by a
+      process. This includes :term:`shared memory` pages. It is the most
+      commonly reported memory metric (shown as ``RES`` in ``top``), but can be
+      misleading because :term:`shared memory` is counted in full for each
+      process that maps it.
+      See :meth:`Process.memory_info`.
+
+   soft interrupt
+
+      Deferred work scheduled by a :term:`hardware interrupt` handler to
+      run later in a less time-critical context (e.g. network packet
+      processing, block I/O completion). Using soft interrupts lets the
+      hardware interrupt return quickly while the heavier processing
+      happens shortly after. Reported as the :field:`soft_interrupts` field of
+      :func:`cpu_stats`. A high rate usually points to heavy network or
+      disk I/O throughput rather than a hardware problem.
+
+   shared memory
+
+      Memory pages mapped by more than one process at the same time. The most
+      common example is shared libraries (e.g. ``libc.so``): the OS loads them
+      once and lets every process that needs them map the same physical pages,
+      saving RAM. Shared pages are counted in full in :term:`RSS` for every
+      process that maps them. :term:`PSS` corrects for this by splitting each
+      shared page proportionally among the processes that use it.
+      See also :term:`private memory`.
+
+      Exposed by psutil as the :field:`shared` field of :func:`virtual_memory` and
+      :meth:`Process.memory_info` (Linux), the :field:`rss_shmem` field of
+      :meth:`Process.memory_extras` (Linux), and the :field:`shared_clean` /
+      :field:`shared_dirty` fields of :meth:`Process.memory_maps` (Linux).
+
+   swap-in
+
+      Memory moved from disk (:term:`swap <swap memory>`) back into RAM.
+      Reported as the :field:`sin` :term:`cumulative counter` of
+      :func:`swap_memory`. A non-zero :field:`sin` rate usually means the system
+      is bringing memory back into RAM for processes to use. See also
+      :term:`swap-out`.
+
+   swap-out
+
+      Memory moved from RAM to disk (:term:`swap <swap memory>`).
+      Reported as the :field:`sout` :term:`cumulative counter` of
+      :func:`swap_memory`.  A non-zero :field:`sout` rate indicates memory
+      pressure: the system is running low on RAM and must move data to disk,
+      which can slow performance. See also :term:`swap-in`.
+
+      .. seealso::
+         - :ref:`swap activity recipe <recipe_swap_activity>`
+         - :term:`thrashing`
+
+   swap memory
+
+      Disk space used as an extension of physical RAM. When the OS runs out of
+      RAM, it moves memory to disk to free space (:term:`swap-out`), and moves
+      it back into RAM (:term:`swap-in`) when a process needs it. If RAM is
+      full, the OS may first swap out other pages to make room. Swap prevents
+      out-of-memory crashes, but is much slower than RAM, so heavy swapping can
+      significantly degrade performance. See :func:`swap_memory` and
+      :ref:`swap activity recipe <recipe_swap_activity>`.
+
+   thrashing
+
+      A condition where the system spends more time moving memory between RAM
+      and disk (:term:`swap <swap memory>`) than doing actual work, because memory
+      demand exceeds available RAM. The symptom is high and sustained rates on
+      both :field:`sin` and :field:`sout` from :func:`swap_memory`.
+      As a result, the system becomes very slow or unresponsive. CPU utilization
+      may look low while everything is waiting on disk I/O.
+
+   USS
+
+      *Unique Set Size*, the :term:`private memory` of a process, that belongs
+      exclusively to it, and which would be freed if it exited. It excludes
+      :term:`shared memory` pages entirely, making it the most accurate
+      single-process memory metric. Available on Linux, macOS, and Windows via
+      :meth:`Process.memory_footprint`.
+
+   voluntary context switch
+
+      See :term:`context switch`.
+
+   VMS
+
+      *Virtual Memory Size*, the total virtual address space reserved by a
+      process, including mapped files, :term:`shared memory`, stack, and
+      :term:`heap`, regardless of whether those pages are currently in RAM or
+      in :term:`swap memory`. VMS is almost always much larger than :term:`RSS`
+      because most virtual pages are never actually loaded into RAM. See
+      :meth:`Process.memory_info`.
+
+   zombie process
+
+      A process that has exited but whose entry remains in the process
+      table until its parent calls ``wait()``. Zombies hold a PID but consume
+      no CPU or memory.
+
+      .. seealso:: :ref:`faq_zombie_process`
diff --git a/docs/index.rst b/docs/index.rst
index dbd1d329bc..3e96284fb2 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -1,1784 +1,304 @@
 .. module:: psutil
    :synopsis: psutil module
-.. moduleauthor:: Giampaolo Rodola' <grodola@gmail.com>
-
-psutil documentation
-====================
-
-Quick links
------------
-
-* `Home page <https://github.com/giampaolo/psutil>`__
-* `Install <https://github.com/giampaolo/psutil/blob/master/INSTALL.rst>`_
-* `Blog <http://grodola.blogspot.com/search/label/psutil>`__
-* `Forum <http://groups.google.com/group/psutil/topics>`__
-* `Download <https://pypi.python.org/pypi?:action=display&name=psutil#downloads>`__
-* `Development guide <https://github.com/giampaolo/psutil/blob/master/DEVGUIDE.rst>`_
-* `What's new <https://github.com/giampaolo/psutil/blob/master/HISTORY.rst>`__
-
-About
------
-
-psutil (python system and process utilities) is a cross-platform library for
-retrieving information on running
-**processes** and **system utilization** (CPU, memory, disks, network) in
-**Python**.
-It is useful mainly for **system monitoring**, **profiling** and **limiting
-process resources** and **management of running processes**.
-It implements many functionalities offered by command line tools
-such as: *ps, top, lsof, netstat, ifconfig, who, df, kill, free, nice,
-ionice, iostat, iotop, uptime, pidof, tty, taskset, pmap*.
-It currently supports **Linux, Windows, OSX, Sun Solaris, FreeBSD, OpenBSD**
-and **NetBSD**, both **32-bit** and **64-bit** architectures, with Python
-versions from **2.6 to 3.5** (users of Python 2.4 and 2.5 may use
-`2.1.3 <https://pypi.python.org/pypi?name=psutil&version=2.1.3&:action=files>`__ version).
-`PyPy <http://pypy.org/>`__ is also known to work.
-
-The psutil documentation you're reading is distributed as a single HTML page.
-
-System related functions
-========================
-
-CPU
----
-
-.. function:: cpu_times(percpu=False)
-
-  Return system CPU times as a namedtuple.
-  Every attribute represents the seconds the CPU has spent in the given mode.
-  The attributes availability varies depending on the platform:
-
-  - **user**
-  - **system**
-  - **idle**
-
-  Platform-specific fields:
-
-  - **nice** *(UNIX)*
-  - **iowait** *(Linux)*
-  - **irq** *(Linux, BSD)*
-  - **softirq** *(Linux)*
-  - **steal** *(Linux 2.6.11+)*
-  - **guest** *(Linux 2.6.24+)*
-  - **guest_nice** *(Linux 3.2.0+)*
-  - **interrupt** *(Windows)*
-  - **dpc** *(Windows)*
-
-  When *percpu* is ``True`` return a list of namedtuples for each logical CPU
-  on the system.
-  First element of the list refers to first CPU, second element to second CPU
-  and so on.
-  The order of the list is consistent across calls.
-  Example output on Linux:
-
-    >>> import psutil
-    >>> psutil.cpu_times()
-    scputimes(user=17411.7, nice=77.99, system=3797.02, idle=51266.57, iowait=732.58, irq=0.01, softirq=142.43, steal=0.0, guest=0.0, guest_nice=0.0)
-
-  .. versionchanged:: 4.1.0 added *interrupt* and *dpc* fields on Windows.
-
-.. function:: cpu_percent(interval=None, percpu=False)
-
-  Return a float representing the current system-wide CPU utilization as a
-  percentage. When *interval* is > ``0.0`` compares system CPU times elapsed
-  before and after the interval (blocking).
-  When *interval* is ``0.0`` or ``None`` compares system CPU times elapsed
-  since last call or module import, returning immediately.
-  That means the first time this is called it will return a meaningless ``0.0``
-  value which you are supposed to ignore.
-  In this case is recommended for accuracy that this function be called with at
-  least ``0.1`` seconds between calls.
-  When *percpu* is ``True`` returns a list of floats representing the
-  utilization as a percentage for each CPU.
-  First element of the list refers to first CPU, second element to second CPU
-  and so on. The order of the list is consistent across calls.
-
-    >>> import psutil
-    >>> # blocking
-    >>> psutil.cpu_percent(interval=1)
-    2.0
-    >>> # non-blocking (percentage since last call)
-    >>> psutil.cpu_percent(interval=None)
-    2.9
-    >>> # blocking, per-cpu
-    >>> psutil.cpu_percent(interval=1, percpu=True)
-    [2.0, 1.0]
-    >>>
-
-  .. warning::
-    the first time this function is called with *interval* = ``0.0`` or ``None``
-    it will return a meaningless ``0.0`` value which you are supposed to
-    ignore.
-
-.. function:: cpu_times_percent(interval=None, percpu=False)
-
-  Same as :func:`cpu_percent()` but provides utilization percentages for each
-  specific CPU time as is returned by
-  :func:`psutil.cpu_times(percpu=True)<cpu_times()>`.
-  *interval* and
-  *percpu* arguments have the same meaning as in :func:`cpu_percent()`.
-
-  .. warning::
-    the first time this function is called with *interval* = ``0.0`` or
-    ``None`` it will return a meaningless ``0.0`` value which you are supposed
-    to ignore.
-
-  .. versionchanged::
-    4.1.0 two new *interrupt* and *dpc* fields are returned on Windows.
-
-.. function:: cpu_count(logical=True)
-
-  Return the number of logical CPUs in the system (same as
-  `os.cpu_count() <http://docs.python.org/3/library/os.html#os.cpu_count>`__
-  in Python 3.4).
-  If *logical* is ``False`` return the number of physical cores only (hyper
-  thread CPUs are excluded). Return ``None`` if undetermined.
-
-    >>> import psutil
-    >>> psutil.cpu_count()
-    4
-    >>> psutil.cpu_count(logical=False)
-    2
-    >>>
-
-.. function:: cpu_stats()
-
-  Return various CPU statistics as a namedtuple:
-
-  - **ctx_switches**:
-    number of context switches (voluntary + involuntary) since boot.
-  - **interrupts**:
-    number of interrupts since boot.
-  - **soft_interrupts**:
-    number of software interrupts since boot. Always set to ``0`` on Windows
-    and SunOS.
-  - **syscalls**: number of system calls since boot. Always set to ``0`` on
-    Linux.
-
-  Example (Linux):
-
-  .. code-block:: python
-
-     >>> import psutil
-     >>> psutil.cpu_stats()
-     scpustats(ctx_switches=20455687, interrupts=6598984, soft_interrupts=2134212, syscalls=0)
-
-  .. versionadded:: 4.1.0
-
-
-Memory
-------
-
-.. function:: virtual_memory()
-
-  Return statistics about system memory usage as a namedtuple including the
-  following fields, expressed in bytes:
-
-  - **total**: total physical memory available.
-  - **available**: the actual amount of available memory that can be given
-    instantly to processes that request more memory in bytes; this is
-    calculated by summing different memory values depending on the platform
-    (e.g. free + buffers + cached on Linux) and it is supposed to be used to
-    monitor actual memory usage in a cross platform fashion.
-  - **percent**: the percentage usage calculated as
-    ``(total - available) / total * 100``.
-  - **used**: memory used, calculated differently depending on the platform and
-    designed for informational purposes only.
-  - **free**: memory not being used at all (zeroed) that is readily available;
-    note that this doesn't reflect the actual memory available (use 'available'
-    instead).
-
-  Platform-specific fields:
-
-  - **active** *(UNIX)*: memory currently in use or very recently used, and so
-    it is in RAM.
-  - **inactive** *(UNIX)*: memory that is marked as not used.
-  - **buffers** *(Linux, BSD)*: cache for things like file system metadata.
-  - **cached** *(Linux, BSD)*: cache for various things.
-  - **shared** *(Linux, BSD)*: memory that may be simultaneously accessed by
-    multiple processes.
-  - **wired** *(BSD, OSX)*: memory that is marked to always stay in RAM. It is
-    never moved to disk.
-
-  The sum of **used** and **available** does not necessarily equal **total**.
-  On Windows **available** and **free** are the same.
-  See `scripts/meminfo.py <https://github.com/giampaolo/psutil/blob/master/scripts/meminfo.py>`__
-  script providing an example on how to convert bytes in a human readable form.
-
-  .. note:: if you just want to know how much physical memory is left in a
-    cross platform fashion simply rely on the **available** field.
-
-  >>> import psutil
-  >>> mem = psutil.virtual_memory()
-  >>> mem
-  svmem(total=10367352832, available=6472179712, percent=37.6, used=8186245120, free=2181107712, active=4748992512, inactive=2758115328, buffers=790724608, cached=3500347392, shared=787554304)
-  >>>
-  >>> THRESHOLD = 100 * 1024 * 1024  # 100MB
-  >>> if mem.available <= THRESHOLD:
-  ...     print("warning")
-  ...
-  >>>
-
-  .. versionchanged:: 4.2.0 added *shared* metrics on Linux.
-
-.. function:: swap_memory()
-
-  Return system swap memory statistics as a namedtuple including the following
-  fields:
-
-  * **total**: total swap memory in bytes
-  * **used**: used swap memory in bytes
-  * **free**: free swap memory in bytes
-  * **percent**: the percentage usage calculated as ``(total - available) / total * 100``
-  * **sin**: the number of bytes the system has swapped in from disk
-    (cumulative)
-  * **sout**: the number of bytes the system has swapped out from disk
-    (cumulative)
-
-  **sin** and **sout** on Windows are always set to ``0``.
-  See `scripts/meminfo.py <https://github.com/giampaolo/psutil/blob/master/scripts/meminfo.py>`__
-  script providing an example on how to convert bytes in a human readable form.
-
-    >>> import psutil
-    >>> psutil.swap_memory()
-    sswap(total=2097147904L, used=886620160L, free=1210527744L, percent=42.3, sin=1050411008, sout=1906720768)
-
-Disks
------
-
-.. function:: disk_partitions(all=False)
-
-  Return all mounted disk partitions as a list of namedtuples including device,
-  mount point and filesystem type, similarly to "df" command on UNIX. If *all*
-  parameter is ``False`` return physical devices only (e.g. hard disks, cd-rom
-  drives, USB keys) and ignore all others (e.g. memory partitions such as
-  `/dev/shm <http://www.cyberciti.biz/tips/what-is-devshm-and-its-practical-usage.html>`__).
-  Namedtuple's **fstype** field is a string which varies depending on the
-  platform.
-  On Linux it can be one of the values found in /proc/filesystems (e.g.
-  ``'ext3'`` for an ext3 hard drive o ``'iso9660'`` for the CD-ROM drive).
-  On Windows it is determined via
-  `GetDriveType <http://msdn.microsoft.com/en-us/library/aa364939(v=vs.85).aspx>`__
-  and can be either ``"removable"``, ``"fixed"``, ``"remote"``, ``"cdrom"``,
-  ``"unmounted"`` or ``"ramdisk"``. On OSX and BSD it is retrieved via
-  `getfsstat(2) <http://www.manpagez.com/man/2/getfsstat/>`__. See
-  `disk_usage.py <https://github.com/giampaolo/psutil/blob/master/scripts/disk_usage.py>`__
-  script providing an example usage.
-
-    >>> import psutil
-    >>> psutil.disk_partitions()
-    [sdiskpart(device='/dev/sda3', mountpoint='/', fstype='ext4', opts='rw,errors=remount-ro'),
-     sdiskpart(device='/dev/sda7', mountpoint='/home', fstype='ext4', opts='rw')]
-
-.. function:: disk_usage(path)
-
-  Return disk usage statistics about the given *path* as a namedtuple including
-  **total**, **used** and **free** space expressed in bytes, plus the
-  **percentage** usage.
-  `OSError <http://docs.python.org/3/library/exceptions.html#OSError>`__ is
-  raised if *path* does not exist.
-  Starting from `Python 3.3 <http://bugs.python.org/issue12442>`__  this is
-  also available as
-  `shutil.disk_usage() <http://docs.python.org/3/library/shutil.html#shutil.disk_usage>`__.
-  See `disk_usage.py <https://github.com/giampaolo/psutil/blob/master/scripts/disk_usage.py>`__ script providing an example usage.
-
-    >>> import psutil
-    >>> psutil.disk_usage('/')
-    sdiskusage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)
-
-  .. note::
-    UNIX usually reserves 5% of the total disk space for the root user.
-    *total* and *used* fields on UNIX refer to the overall total and used
-    space, whereas *free* represents the space available for the **user** and
-    *percent* represents the **user** utilization (see
-    `source code <https://github.com/giampaolo/psutil/blob/3dea30d583b8c1275057edb1b3b720813b4d0f60/psutil/_psposix.py#L123>`__).
-    That is why *percent* value may look 5% bigger than what you would expect
-    it to be.
-    Also note that both 4 values match "df" cmdline utility.
-
-  .. versionchanged::
-    4.3.0 *percent* value takes root reserved space into account.
-
-.. function:: disk_io_counters(perdisk=False)
-
-  Return system-wide disk I/O statistics as a namedtuple including the
-  following fields:
-
-  - **read_count**: number of reads
-  - **write_count**: number of writes
-  - **read_bytes**: number of bytes read
-  - **write_bytes**: number of bytes written
-
-  Platform-specific fields:
-
-  - **read_time**: (all except *NetBSD* and *OpenBSD*) time spent reading from
-    disk (in milliseconds)
-  - **write_time**: (all except *NetBSD* and *OpenBSD*) time spent writing to disk
-    (in milliseconds)
-  - **busy_time**: (*Linux*, *FreeBSD*) time spent doing actual I/Os (in
-    milliseconds)
-  - **read_merged_count** (*Linux*): number of merged reads
-    (see `iostat doc <https://www.kernel.org/doc/Documentation/iostats.txt>`__)
-  - **write_merged_count** (*Linux*): number of merged writes
-    (see `iostats doc <https://www.kernel.org/doc/Documentation/iostats.txt>`__)
-
-  If *perdisk* is ``True`` return the same information for every physical disk
-  installed on the system as a dictionary with partition names as the keys and
-  the namedtuple described above as the values.
-  See `scripts/iotop.py <https://github.com/giampaolo/psutil/blob/master/scripts/iotop.py>`__
-  for an example application.
-
-    >>> import psutil
-    >>> psutil.disk_io_counters()
-    sdiskio(read_count=8141, write_count=2431, read_bytes=290203, write_bytes=537676, read_time=5868, write_time=94922)
-    >>>
-    >>> psutil.disk_io_counters(perdisk=True)
-    {'sda1': sdiskio(read_count=920, write_count=1, read_bytes=2933248, write_bytes=512, read_time=6016, write_time=4),
-     'sda2': sdiskio(read_count=18707, write_count=8830, read_bytes=6060, write_bytes=3443, read_time=24585, write_time=1572),
-     'sdb1': sdiskio(read_count=161, write_count=0, read_bytes=786432, write_bytes=0, read_time=44, write_time=0)}
-
-  .. warning::
-    on some systems such as Linux, on a very busy or long-lived system these
-    numbers may wrap (restart from zero), see
-    `issues #802 <https://github.com/giampaolo/psutil/issues/802>`__.
-    Applications should be prepared to deal with that.
-
-  .. versionchanged::
-    4.0.0 added *busy_time* (Linux, FreeBSD), *read_merged_count* and
-    *write_merged_count* (Linux) fields.
-
-  .. versionchanged::
-    4.0.0 NetBSD no longer has *read_time* and *write_time* fields.
-
-Network
--------
-
-.. function:: net_io_counters(pernic=False)
-
-  Return system-wide network I/O statistics as a namedtuple including the
-  following attributes:
-
-  - **bytes_sent**: number of bytes sent
-  - **bytes_recv**: number of bytes received
-  - **packets_sent**: number of packets sent
-  - **packets_recv**: number of packets received
-  - **errin**: total number of errors while receiving
-  - **errout**: total number of errors while sending
-  - **dropin**: total number of incoming packets which were dropped
-  - **dropout**: total number of outgoing packets which were dropped (always 0
-    on OSX and BSD)
-
-  If *pernic* is ``True`` return the same information for every network
-  interface installed on the system as a dictionary with network interface
-  names as the keys and the namedtuple described above as the values.
-  See `scripts/nettop.py <https://github.com/giampaolo/psutil/blob/master/scripts/nettop.py>`__
-  for an example application.
-
-    >>> import psutil
-    >>> psutil.net_io_counters()
-    snetio(bytes_sent=14508483, bytes_recv=62749361, packets_sent=84311, packets_recv=94888, errin=0, errout=0, dropin=0, dropout=0)
-    >>>
-    >>> psutil.net_io_counters(pernic=True)
-    {'lo': snetio(bytes_sent=547971, bytes_recv=547971, packets_sent=5075, packets_recv=5075, errin=0, errout=0, dropin=0, dropout=0),
-    'wlan0': snetio(bytes_sent=13921765, bytes_recv=62162574, packets_sent=79097, packets_recv=89648, errin=0, errout=0, dropin=0, dropout=0)}
-
-  .. warning::
-    on some systems such as Linux, on a very busy or long-lived system these
-    numbers may wrap (restart from zero), see
-    `issues #802 <https://github.com/giampaolo/psutil/issues/802>`__.
-    Applications should be prepared to deal with that.
-
-.. function:: net_connections(kind='inet')
-
-  Return system-wide socket connections as a list of namedtuples.
-  Every namedtuple provides 7 attributes:
-
-  - **fd**: the socket file descriptor, if retrievable, else ``-1``.
-    If the connection refers to the current process this may be passed to
-    `socket.fromfd() <http://docs.python.org/library/socket.html#socket.fromfd>`__
-    to obtain a usable socket object.
-  - **family**: the address family, either `AF_INET
-    <http://docs.python.org//library/socket.html#socket.AF_INET>`__,
-    `AF_INET6 <http://docs.python.org//library/socket.html#socket.AF_INET6>`__
-    or `AF_UNIX <http://docs.python.org//library/socket.html#socket.AF_UNIX>`__.
-  - **type**: the address type, either `SOCK_STREAM
-    <http://docs.python.org//library/socket.html#socket.SOCK_STREAM>`__ or
-    `SOCK_DGRAM
-    <http://docs.python.org//library/socket.html#socket.SOCK_DGRAM>`__.
-  - **laddr**: the local address as a ``(ip, port)`` tuple or a ``path``
-    in case of AF_UNIX sockets.
-  - **raddr**: the remote address as a ``(ip, port)`` tuple or an absolute
-    ``path`` in case of UNIX sockets.
-    When the remote endpoint is not connected you'll get an empty tuple
-    (AF_INET*) or ``None`` (AF_UNIX).
-    On Linux AF_UNIX sockets will always have this set to ``None``.
-  - **status**: represents the status of a TCP connection. The return value
-    is one of the :data:`psutil.CONN_* <psutil.CONN_ESTABLISHED>` constants
-    (a string).
-    For UDP and UNIX sockets this is always going to be
-    :const:`psutil.CONN_NONE`.
-  - **pid**: the PID of the process which opened the socket, if retrievable,
-    else ``None``. On some platforms (e.g. Linux) the availability of this
-    field changes depending on process privileges (root is needed).
-
-  The *kind* parameter is a string which filters for connections that fit the
-  following criteria:
-
-  .. table::
-
-   +----------------+-----------------------------------------------------+
-   | **Kind value** | **Connections using**                               |
-   +================+=====================================================+
-   | "inet"         | IPv4 and IPv6                                       |
-   +----------------+-----------------------------------------------------+
-   | "inet4"        | IPv4                                                |
-   +----------------+-----------------------------------------------------+
-   | "inet6"        | IPv6                                                |
-   +----------------+-----------------------------------------------------+
-   | "tcp"          | TCP                                                 |
-   +----------------+-----------------------------------------------------+
-   | "tcp4"         | TCP over IPv4                                       |
-   +----------------+-----------------------------------------------------+
-   | "tcp6"         | TCP over IPv6                                       |
-   +----------------+-----------------------------------------------------+
-   | "udp"          | UDP                                                 |
-   +----------------+-----------------------------------------------------+
-   | "udp4"         | UDP over IPv4                                       |
-   +----------------+-----------------------------------------------------+
-   | "udp6"         | UDP over IPv6                                       |
-   +----------------+-----------------------------------------------------+
-   | "unix"         | UNIX socket (both UDP and TCP protocols)            |
-   +----------------+-----------------------------------------------------+
-   | "all"          | the sum of all the possible families and protocols  |
-   +----------------+-----------------------------------------------------+
-
-  On OSX this function requires root privileges.
-  To get per-process connections use :meth:`Process.connections`.
-  Also, see
-  `netstat.py sample script <https://github.com/giampaolo/psutil/blob/master/scripts/netstat.py>`__.
-  Example:
-
-    >>> import psutil
-    >>> psutil.net_connections()
-    [pconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 48776), raddr=('93.186.135.91', 80), status='ESTABLISHED', pid=1254),
-     pconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 43761), raddr=('72.14.234.100', 80), status='CLOSING', pid=2987),
-     pconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 60759), raddr=('72.14.234.104', 80), status='ESTABLISHED', pid=None),
-     pconn(fd=-1, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 51314), raddr=('72.14.234.83', 443), status='SYN_SENT', pid=None)
-     ...]
-
-  .. note::
-    (OSX) :class:`psutil.AccessDenied` is always raised unless running as root
-    (lsof does the same).
-
-  .. note::
-    (Solaris) UNIX sockets are not supported.
-
-  .. versionadded:: 2.1.0
-
-.. function:: net_if_addrs()
-
-  Return the addresses associated to each NIC (network interface card)
-  installed on the system as a dictionary whose keys are the NIC names and
-  value is a list of namedtuples for each address assigned to the NIC.
-  Each namedtuple includes 5 fields:
-
-  - **family**
-  - **address**
-  - **netmask**
-  - **broadcast**
-  - **ptp**
-
-  *family* can be either
-  `AF_INET <http://docs.python.org//library/socket.html#socket.AF_INET>`__,
-  `AF_INET6 <http://docs.python.org//library/socket.html#socket.AF_INET6>`__
-  or :const:`psutil.AF_LINK`, which refers to a MAC address.
-  *address* is the primary address and it is always set.
-  *netmask*, *broadcast* and *ptp* may be ``None``.
-  *ptp* stands for "point to point" and references the destination address on a
-  point to point interface (typically a VPN).
-  *broadcast* and *ptp* are mutually exclusive.
-  *netmask*, *broadcast* and *ptp* are not supported on Windows and are set to
-  ``None``.
-
-  Example::
-
-    >>> import psutil
-    >>> psutil.net_if_addrs()
-    {'lo': [snic(family=<AddressFamily.AF_INET: 2>, address='127.0.0.1', netmask='255.0.0.0', broadcast='127.0.0.1', ptp=None),
-            snic(family=<AddressFamily.AF_INET6: 10>, address='::1', netmask='ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', broadcast=None, ptp=None),
-            snic(family=<AddressFamily.AF_LINK: 17>, address='00:00:00:00:00:00', netmask=None, broadcast='00:00:00:00:00:00', ptp=None)],
-     'wlan0': [snic(family=<AddressFamily.AF_INET: 2>, address='192.168.1.3', netmask='255.255.255.0', broadcast='192.168.1.255', ptp=None),
-               snic(family=<AddressFamily.AF_INET6: 10>, address='fe80::c685:8ff:fe45:641%wlan0', netmask='ffff:ffff:ffff:ffff::', broadcast=None, ptp=None),
-               snic(family=<AddressFamily.AF_LINK: 17>, address='c4:85:08:45:06:41', netmask=None, broadcast='ff:ff:ff:ff:ff:ff', ptp=None)]}
-    >>>
-
-  See also `scripts/ifconfig.py <https://github.com/giampaolo/psutil/blob/master/scripts/ifconfig.py>`__
-  for an example application.
-
-  .. note::
-    if you're interested in others families (e.g. AF_BLUETOOTH) you can use
-    the more powerful `netifaces <https://pypi.python.org/pypi/netifaces/>`__
-    extension.
-
-  .. note::
-    you can have more than one address of the same family associated with each
-    interface (that's why dict values are lists).
-
-  .. note::
-    *netmask*, *broadcast* and *ptp* are not supported on Windows and are set
-    to ``None``.
-
-  .. versionadded:: 3.0.0
-
-  .. versionchanged:: 3.2.0 *ptp* field was added.
-
-.. function:: net_if_stats()
-
-  Return information about each NIC (network interface card) installed on the
-  system as a dictionary whose keys are the NIC names and value is a namedtuple
-  with the following fields:
-
-  - **isup**: a bool indicating whether the NIC is up and running.
-  - **duplex**: the duplex communication type;
-    it can be either :const:`NIC_DUPLEX_FULL`, :const:`NIC_DUPLEX_HALF` or
-    :const:`NIC_DUPLEX_UNKNOWN`.
-  - **speed**: the NIC speed expressed in mega bits (MB), if it can't be
-    determined (e.g. 'localhost') it will be set to ``0``.
-  - **mtu**: NIC's maximum transmission unit expressed in bytes.
-
-  See also `scripts/ifconfig.py <https://github.com/giampaolo/psutil/blob/master/scripts/ifconfig.py>`__
-  for an example application.
-  Example:
-
-    >>> import psutil
-    >>> psutil.net_if_stats()
-    {'eth0': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_FULL: 2>, speed=100, mtu=1500),
-     'lo': snicstats(isup=True, duplex=<NicDuplex.NIC_DUPLEX_UNKNOWN: 0>, speed=0, mtu=65536)}
+.. moduleauthor:: Giampaolo Rodola <grodola@gmail.com>
+.. title:: Home
+
+.. ============================================================================
+.. Hero
+.. ============================================================================
+
+.. raw:: html
+
+   <script>document.body.classList.add('home-page');</script>
+
+   <div class="hero">
+     <h1 class="hero-title"><img src="_static/images/logo-psutil.svg" class="hero-logo" alt="psutil logo"><span>psutil</span></h1>
+     <div class="hero-subtitle">Process and System Utilities for Python</div>
+   </div>
+
+.. container:: home-intro
+
+   Psutil is a cross-platform library for retrieving information about running
+   processes and system utilization in Python. It is useful mainly for system
+   monitoring, profiling, limiting process resources, and managing running
+   processes. Psutil implements many functionalities offered by UNIX command
+   line tool such as *ps, top, free, iotop, netstat, ifconfig, lsof* and
+   others.
+
+.. ============================================================================
+.. Install one-liner
+.. ============================================================================
+
+.. raw:: html
+
+   <div class="home-install" role="group" aria-label="Install command">
+     <span class="home-install-prompt" aria-hidden="true">$</span>
+     <code class="home-install-cmd">pip install psutil</code>
+     <button type="button" class="home-install-copy" aria-label="Copy install command">
+       <svg class="home-install-icon-copy" viewBox="0 0 16 16" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.6" aria-hidden="true">
+         <rect x="4" y="4" width="9" height="9" rx="1.2"></rect>
+         <path d="M3 11V3a1 1 0 0 1 1-1h8"></path>
+       </svg>
+       <svg class="home-install-icon-check" viewBox="0 0 16 16" width="14" height="14" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+         <path d="M3 8.5l3.5 3.5L13 5"></path>
+       </svg>
+     </button>
+     <span class="home-install-toast" aria-hidden="true">Copied</span>
+   </div>
+
+.. ============================================================================
+.. Platform pills
+.. ============================================================================
+
+.. raw:: html
+
+   <div class="home-platforms">
+     <a class="home-platforms-label" href="platform/">Runs on</a>
+     <div class="home-platforms-pills">
+       <a class="home-platform-pill" href="platform/">Linux</a>
+       <a class="home-platform-pill" href="platform/">Windows</a>
+       <a class="home-platform-pill" href="platform/">macOS</a>
+       <a class="home-platform-pill" href="platform/">FreeBSD</a>
+       <a class="home-platform-pill" href="platform/">OpenBSD</a>
+       <a class="home-platform-pill" href="platform/">NetBSD</a>
+       <a class="home-platform-pill" href="platform/">Solaris</a>
+       <a class="home-platform-pill" href="platform/">AIX</a>
+     </div>
+   </div>
+
+.. ============================================================================
+.. Feature cards
+.. ============================================================================
+
+.. raw:: html
+
+   <div class="home-section-label">Explore the API</div>
+   <div class="home-feature-cards">
+     <a class="home-feature-card" href="api/#cpu">
+       <img class="home-icon-svg" src="_static/images/icon-cpu.svg" alt="">
+       <div class="home-feature-title">CPU</div>
+     </a>
+     <a class="home-feature-card" href="api/#memory">
+       <img class="home-icon-svg" src="_static/images/icon-memory.svg" alt="">
+       <div class="home-feature-title">Memory</div>
+     </a>
+     <a class="home-feature-card" href="api/#disks">
+       <img class="home-icon-svg" src="_static/images/icon-disks.svg" alt="">
+       <div class="home-feature-title">Disks</div>
+     </a>
+     <a class="home-feature-card" href="api/#network">
+       <img class="home-icon-svg" src="_static/images/icon-network.svg" alt="">
+       <div class="home-feature-title">Network</div>
+     </a>
+     <a class="home-feature-card" href="api/#sensors">
+       <img class="home-icon-svg" src="_static/images/icon-sensors.svg" alt="">
+       <div class="home-feature-title">Sensors</div>
+     </a>
+     <a class="home-feature-card" href="api/#processes">
+       <img class="home-icon-svg" src="_static/images/icon-processes.svg" alt="">
+       <div class="home-feature-title">Processes</div>
+     </a>
+   </div>
+
+.. ============================================================================
+.. Quickstart code preview (tabs by category)
+.. ============================================================================
+
+.. raw:: html
+
+   <div class="home-section-label">Try it</div>
+
+.. container:: home-quickstart
+
+   .. tab-set::
+
+      .. tab-item:: CPU
+
+         .. code-block:: pycon
+
+            >>> import psutil
+            >>> psutil.cpu_times()
+            scputimes(user=3961.46, nice=169.72, system=2150.65, idle=16900.54, iowait=629.59, ...)
+            >>> psutil.cpu_percent(interval=1)
+            4.0
+            >>> psutil.cpu_count(logical=False)
+            2
+            >>> psutil.cpu_freq()
+            scpufreq(current=931.42, min=800.0, max=3500.0)
+
+         .. container:: home-tab-more
+
+            :ref:`See more → <api-overview-cpu>`
+
+      .. tab-item:: Memory
+
+         .. code-block:: pycon
+
+            >>> import psutil
+            >>> psutil.virtual_memory()
+            svmem(total=10367352832, available=6472179712, percent=37.6, used=8186245120, free=2181107712, ...)
+            >>> psutil.swap_memory()
+            sswap(total=2097147904, used=296128512, free=1801019392, percent=14.1, sin=304193536, sout=677842944)
+
+         .. container:: home-tab-more
+
+            :ref:`See more → <api-overview-memory>`
+
+      .. tab-item:: Disks
+
+         .. code-block:: pycon
+
+            >>> import psutil
+            >>> psutil.disk_partitions()
+            [sdiskpart(device='/dev/sda1', mountpoint='/',     fstype='ext4', opts='rw,nosuid'),
+             sdiskpart(device='/dev/sda2', mountpoint='/home', fstype='ext4', opts='rw')]
+            >>> psutil.disk_usage('/')
+            sdiskusage(total=21378641920, used=4809781248, free=15482871808, percent=22.5)
+            >>> psutil.disk_io_counters()
+            sdiskio(read_count=719566, write_count=1082197, read_bytes=18626220, write_bytes=24081764, ...)
+
+         .. container:: home-tab-more
+
+            :ref:`See more → <api-overview-disks>`
+
+      .. tab-item:: Network
+
+         .. code-block:: pycon
+
+            >>> import psutil
+            >>> psutil.net_io_counters(pernic=True)
+            {'eth0': netio(bytes_sent=485291293, bytes_recv=6004858642, ...),
+             'lo':   netio(bytes_sent=2838627,   bytes_recv=2838627,   ...)}
+            >>> psutil.net_connections(kind='tcp')
+            [sconn(family=2, type=1, laddr=addr('10.0.0.1', 48776), raddr=addr('93.186.135.91', 80), status='ESTABLISHED', pid=1254), ...]
+            >>> psutil.net_if_addrs()['wlan0']
+            [snicaddr(family=2,  address='192.168.1.3', netmask='255.255.255.0', ...), ...]
+            >>> psutil.net_if_stats()['wlan0']
+            snicstats(isup=True, duplex=2, speed=100, mtu=1500, flags='up,broadcast,running')
+
+         .. container:: home-tab-more
+
+            :ref:`See more → <api-overview-network>`
+
+      .. tab-item:: Sensors
+
+         .. code-block:: pycon
 
-  .. versionadded:: 3.0.0
+            >>> import psutil
+            >>> psutil.sensors_temperatures()
+            {'coretemp': [shwtemp(label='Physical id 0', current=52.0, high=100.0, critical=100.0),
+                          shwtemp(label='Core 0',        current=45.0, high=100.0, critical=100.0)],
+             'acpitz':   [shwtemp(label='',              current=47.0, high=103.0, critical=103.0)]}
+            >>> psutil.sensors_fans()
+            {'asus': [sfan(label='cpu_fan', current=3200)]}
+            >>> psutil.sensors_battery()
+            sbattery(percent=93, secsleft=16628, power_plugged=False)
 
+         .. container:: home-tab-more
 
-Other system info
------------------
-
-.. function:: boot_time()
+            :ref:`See more → <api-overview-sensors>`
 
-  Return the system boot time expressed in seconds since the epoch.
-  Example:
+      .. tab-item:: Processes
 
-  .. code-block:: python
+         .. code-block:: pycon
 
-     >>> import psutil, datetime
-     >>> psutil.boot_time()
-     1389563460.0
-     >>> datetime.datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M:%S")
-     '2014-01-12 22:51:00'
+            >>> import psutil
+            >>> p = psutil.Process(7055)
+            >>> p.name(), p.exe(), p.cmdline()
+            ('python3', '/usr/bin/python3', ['/usr/bin/python3', 'main.py'])
+            >>> p.status()
+            <ProcessStatus.STATUS_RUNNING: 'running'>
+            >>> p.cpu_percent(interval=1.0)
+            12.1
+            >>> p.memory_info()
+            pmem(rss=3164160, vms=4410163, shared=897433, text=302694, data=2422374)
+            >>> p.parent(), p.children(recursive=True)
+            (psutil.Process(pid=4699, name='bash'), [psutil.Process(pid=29835, name='python3'), ...])
+
+         .. container:: home-tab-more
+
+            :ref:`See more → <api-overview-processes>`
+
+.. ============================================================================
+.. Adoption stats. Numbers kept in sync with adoption.rst and README.rst
+.. by scripts/internal/docs/refresh_adoption_stats.py.
+.. ============================================================================
 
-.. function:: users()
+.. raw:: html
 
-  Return users currently connected on the system as a list of namedtuples
-  including the following fields:
-
-  - **user**: the name of the user.
-  - **terminal**: the tty or pseudo-tty associated with the user, if any,
-    else ``None``.
-  - **host**: the host name associated with the entry, if any.
-  - **started**: the creation time as a floating point number expressed in
-    seconds since the epoch.
-
-  Example::
-
-    >>> import psutil
-    >>> psutil.users()
-    [suser(name='giampaolo', terminal='pts/2', host='localhost', started=1340737536.0),
-     suser(name='giampaolo', terminal='pts/3', host='localhost', started=1340737792.0)]
-
-Processes
-=========
-
-Functions
----------
-
-.. function:: pids()
-
-  Return a list of current running PIDs. To iterate over all processes
-  :func:`process_iter()` should be preferred.
-
-.. function:: pid_exists(pid)
-
-  Check whether the given PID exists in the current process list. This is
-  faster than doing ``"pid in psutil.pids()"`` and should be preferred.
-
-.. function:: process_iter()
-
-  Return an iterator yielding a :class:`Process` class instance for all running
-  processes on the local machine.
-  Every instance is only created once and then cached into an internal table
-  which is updated every time an element is yielded.
-  Cached :class:`Process` instances are checked for identity so that you're
-  safe in case a PID has been reused by another process, in which case the
-  cached instance is updated.
-  This is should be preferred over :func:`psutil.pids()` for iterating over
-  processes.
-  Sorting order in which processes are returned is
-  based on their PID. Example usage::
-
-    import psutil
-
-    for proc in psutil.process_iter():
-        try:
-            pinfo = proc.as_dict(attrs=['pid', 'name'])
-        except psutil.NoSuchProcess:
-            pass
-        else:
-            print(pinfo)
-
-.. function:: wait_procs(procs, timeout=None, callback=None)
-
-  Convenience function which waits for a list of :class:`Process` instances to
-  terminate. Return a ``(gone, alive)`` tuple indicating which processes are
-  gone and which ones are still alive. The *gone* ones will have a new
-  *returncode* attribute indicating process exit status (it may be ``None``).
-  ``callback`` is a function which gets called every time a process terminates
-  (a :class:`Process` instance is passed as callback argument). Function will
-  return as soon as all processes terminate or when timeout occurs. Typical use
-  case is:
-
-  - send SIGTERM to a list of processes
-  - give them some time to terminate
-  - send SIGKILL to those ones which are still alive
-
-  Example::
-
-    import psutil
-
-    def on_terminate(proc):
-        print("process {} terminated with exit code {}".format(proc, proc.returncode))
-
-    procs = [...]  # a list of Process instances
-    for p in procs:
-        p.terminate()
-    gone, alive = psutil.wait_procs(procs, timeout=3, callback=on_terminate)
-    for p in alive:
-        p.kill()
-
-Exceptions
-----------
-
-.. class:: Error()
-
-  Base exception class. All other exceptions inherit from this one.
-
-.. class:: NoSuchProcess(pid, name=None, msg=None)
-
-  Raised by :class:`Process` class methods when no process with the given
-  pid* is found in the current process list or when a process no longer
-  exists. "name" is the name the process had before disappearing
-  and gets set only if :meth:`Process.name()` was previously called.
-
-.. class:: ZombieProcess(pid, name=None, ppid=None, msg=None)
-
-  This may be raised by :class:`Process` class methods when querying a zombie
-  process on UNIX (Windows doesn't have zombie processes). Depending on the
-  method called the OS may be able to succeed in retrieving the process
-  information or not.
-  Note: this is a subclass of :class:`NoSuchProcess` so if you're not
-  interested in retrieving zombies (e.g. when using :func:`process_iter()`)
-  you can ignore this exception and just catch :class:`NoSuchProcess`.
-
-  .. versionadded:: 3.0.0
-
-.. class:: AccessDenied(pid=None, name=None, msg=None)
-
-  Raised by :class:`Process` class methods when permission to perform an
-  action is denied. "name" is the name of the process (may be ``None``).
-
-.. class:: TimeoutExpired(seconds, pid=None, name=None, msg=None)
-
-  Raised by :meth:`Process.wait` if timeout expires and process is still
-  alive.
-
-Process class
--------------
-
-.. class:: Process(pid=None)
-
-  Represents an OS process with the given *pid*. If *pid* is omitted current
-  process *pid* (`os.getpid() <http://docs.python.org/library/os.html#os.getpid>`__)
-  is used.
-  Raise :class:`NoSuchProcess` if *pid* does not exist.
-  When accessing methods of this class always be  prepared to catch
-  :class:`NoSuchProcess`, :class:`ZombieProcess` and :class:`AccessDenied`
-  exceptions.
-  `hash() <http://docs.python.org/2/library/functions.html#hash>`__ builtin can
-  be used against instances of this class in order to identify a process
-  univocally over time (the hash is determined by mixing process PID
-  and creation time). As such it can also be used with
-  `set()s <http://docs.python.org/2/library/stdtypes.html#types-set>`__.
-
-  .. warning::
-
-    the way this class is bound to a process is via its **PID**.
-    That means that if the :class:`Process` instance is old enough and
-    the PID has been reused in the meantime you might end up interacting
-    with another process.
-    The only exceptions for which process identity is preemptively checked
-    (via PID + creation time) and guaranteed are for
-    :meth:`nice` (set),
-    :meth:`ionice`  (set),
-    :meth:`cpu_affinity` (set),
-    :meth:`rlimit` (set),
-    :meth:`children`,
-    :meth:`parent`,
-    :meth:`suspend`
-    :meth:`resume`,
-    :meth:`send_signal`,
-    :meth:`terminate`, and
-    :meth:`kill`
-    methods.
-    To prevent this problem for all other methods you can use
-    :meth:`is_running()` before querying the process or use
-    :func:`process_iter()` in case you're iterating over all processes.
-
-  .. attribute:: pid
-
-    The process PID.
-
-  .. method:: ppid()
-
-    The process parent pid.  On Windows the return value is cached after first
-    call.
-
-  .. method:: name()
-
-    The process name.
-
-  .. method:: exe()
-
-    The process executable as an absolute path.
-    On some systems this may also be an empty string.
-    The return value is cached after first call.
-
-  .. method:: cmdline()
-
-    The command line this process has been called with.
-
-  .. method:: environ()
-
-    The environment variables of the process as a dict.  Note: this might not
-    reflect changes made after the process started.
-
-    Availability: Linux, OSX, Windows
-
-    .. versionadded:: 4.0.0
-
-  .. method:: create_time()
-
-    The process creation time as a floating point number expressed in seconds
-    since the epoch, in
-    `UTC <http://en.wikipedia.org/wiki/Coordinated_universal_time>`__.
-    The return value is cached after first call.
-
-      >>> import psutil, datetime
-      >>> p = psutil.Process()
-      >>> p.create_time()
-      1307289803.47
-      >>> datetime.datetime.fromtimestamp(p.create_time()).strftime("%Y-%m-%d %H:%M:%S")
-      '2011-03-05 18:03:52'
-
-  .. method:: as_dict(attrs=None, ad_value=None)
-
-    Utility method retrieving multiple process information as a dictionary.
-    If *attrs* is specified it must be a list of strings reflecting available
-    :class:`Process` class's attribute names (e.g. ``['cpu_times', 'name']``),
-    else all public (read only) attributes are assumed. *ad_value* is the
-    value which gets assigned to a dict key in case :class:`AccessDenied`
-    or :class:`ZombieProcess` exception is raised when retrieving that
-    particular process information.
-
-      >>> import psutil
-      >>> p = psutil.Process()
-      >>> p.as_dict(attrs=['pid', 'name', 'username'])
-      {'username': 'giampaolo', 'pid': 12366, 'name': 'python'}
-
-    .. versionchanged::
-      3.0.0 *ad_value* is used also when incurring into
-      :class:`ZombieProcess` exception, not only :class:`AccessDenied`
-
-  .. method:: parent()
-
-    Utility method which returns the parent process as a :class:`Process`
-    object preemptively checking whether PID has been reused. If no parent
-    PID is known return ``None``.
-
-  .. method:: status()
-
-    The current process status as a string. The returned string is one of the
-    :data:`psutil.STATUS_*<psutil.STATUS_RUNNING>` constants.
-
-  .. method:: cwd()
-
-    The process current working directory as an absolute path.
-
-  .. method:: username()
-
-    The name of the user that owns the process. On UNIX this is calculated by
-    using real process uid.
-
-  .. method:: uids()
-
-    The real, effective and saved user ids of this process as a
-    namedtuple. This is the same as
-    `os.getresuid() <http://docs.python.org//library/os.html#os.getresuid>`__
-    but can be used for any process PID.
-
-    Availability: UNIX
-
-  .. method:: gids()
-
-    The real, effective and saved group ids of this process as a
-    namedtuple. This is the same as
-    `os.getresgid() <http://docs.python.org//library/os.html#os.getresgid>`__
-    but can be used for any process PID.
-
-    Availability: UNIX
-
-  .. method:: terminal()
-
-    The terminal associated with this process, if any, else ``None``. This is
-    similar to "tty" command but can be used for any process PID.
-
-    Availability: UNIX
-
-  .. method:: nice(value=None)
-
-    Get or set process
-    `niceness <blogs.techrepublic.com.com/opensource/?p=140>`__ (priority).
-    On UNIX this is a number which usually goes from ``-20`` to ``20``.
-    The higher the nice value, the lower the priority of the process.
-
-      >>> import psutil
-      >>> p = psutil.Process()
-      >>> p.nice(10)  # set
-      >>> p.nice()  # get
-      10
-      >>>
-
-    Starting from `Python 3.3 <http://bugs.python.org/issue10784>`__ this
-    functionality is also available as
-    `os.getpriority() <http://docs.python.org/3/library/os.html#os.getpriority>`__
-    and
-    `os.setpriority() <http://docs.python.org/3/library/os.html#os.setpriority>`__
-    (UNIX only).
-    On Windows this is implemented via
-    `GetPriorityClass <http://msdn.microsoft.com/en-us/library/ms683211(v=vs.85).aspx>`__
-    and `SetPriorityClass <http://msdn.microsoft.com/en-us/library/ms686219(v=vs.85).aspx>`__
-    Windows APIs and *value* is one of the
-    :data:`psutil.*_PRIORITY_CLASS <psutil.ABOVE_NORMAL_PRIORITY_CLASS>`
-    constants reflecting the MSDN documentation.
-    Example which increases process priority on Windows:
-
-      >>> p.nice(psutil.HIGH_PRIORITY_CLASS)
-
-  .. method:: ionice(ioclass=None, value=None)
-
-    Get or set
-    `process I/O niceness <http://friedcpu.wordpress.com/2007/07/17/why-arent-you-using-ionice-yet/>`__ (priority).
-    On Linux *ioclass* is one of the
-    :data:`psutil.IOPRIO_CLASS_*<psutil.IOPRIO_CLASS_NONE>` constants.
-    *value* is a number which goes from  ``0`` to ``7``. The higher the value,
-    the lower the I/O priority of the process. On Windows only *ioclass* is
-    used and it can be set to ``2`` (normal), ``1`` (low) or ``0`` (very low).
-    The example below sets IDLE priority class for the current process,
-    meaning it will only get I/O time when no other process needs the disk:
-
-      >>> import psutil
-      >>> p = psutil.Process()
-      >>> p.ionice(psutil.IOPRIO_CLASS_IDLE)  # set
-      >>> p.ionice()  # get
-      pionice(ioclass=<IOPriority.IOPRIO_CLASS_IDLE: 3>, value=0)
-      >>>
-
-    On Windows only *ioclass* is used and it can be set to ``2`` (normal),
-    ``1`` (low) or ``0`` (very low).
-
-    Availability: Linux and Windows > Vista
-
-    .. versionchanged::
-      3.0.0 on Python >= 3.4 the returned ``ioclass`` constant is an
-      `enum <https://docs.python.org/3/library/enum.html#module-enum>`__
-      instead of a plain integer.
-
-  .. method:: rlimit(resource, limits=None)
-
-    Get or set process resource limits (see
-    `man prlimit <http://linux.die.net/man/2/prlimit>`__). *resource* is one
-    of the :data:`psutil.RLIMIT_* <psutil.RLIMIT_INFINITY>` constants.
-    *limits* is a ``(soft, hard)`` tuple.
-    This is the same as `resource.getrlimit() <http://docs.python.org/library/resource.html#resource.getrlimit>`__
-    and `resource.setrlimit() <http://docs.python.org/library/resource.html#resource.setrlimit>`__
-    but can be used for any process PID, not only
-    `os.getpid() <http://docs.python.org/library/os.html#os.getpid>`__.
-    Example:
-
-      >>> import psutil
-      >>> p = psutil.Process()
-      >>> # process may open no more than 128 file descriptors
-      >>> p.rlimit(psutil.RLIMIT_NOFILE, (128, 128))
-      >>> # process may create files no bigger than 1024 bytes
-      >>> p.rlimit(psutil.RLIMIT_FSIZE, (1024, 1024))
-      >>> # get
-      >>> p.rlimit(psutil.RLIMIT_FSIZE)
-      (1024, 1024)
-      >>>
-
-    Availability: Linux
-
-  .. method:: io_counters()
-
-    Return process I/O statistics as a namedtuple including the number of read
-    and write operations performed by the process and the amount of bytes read
-    and written. For Linux refer to
-    `/proc filesysem documentation <https://www.kernel.org/doc/Documentation/filesystems/proc.txt>`__.
-    On BSD there's apparently no way to retrieve bytes counters, hence ``-1``
-    is returned for **read_bytes** and **write_bytes** fields. OSX is not
-    supported.
-
-      >>> import psutil
-      >>> p = psutil.Process()
-      >>> p.io_counters()
-      pio(read_count=454556, write_count=3456, read_bytes=110592, write_bytes=0)
-
-    Availability: all platforms except OSX and Solaris
-
-  .. method:: num_ctx_switches()
-
-    The number voluntary and involuntary context switches performed by
-    this process.
-
-  .. method:: num_fds()
-
-    The number of file descriptors used by this process.
-
-    Availability: UNIX
-
-  .. method:: num_handles()
-
-    The number of handles used by this process.
-
-    Availability: Windows
-
-  .. method:: num_threads()
-
-    The number of threads used by this process.
-
-  .. method:: threads()
-
-    Return threads opened by process as a list of namedtuples including thread
-    id and thread CPU times (user/system). On OpenBSD this method requires
-    root access.
-
-  .. method:: cpu_times()
-
-    Return a `(user, system, children_user, children_system)` namedtuple
-    representing the accumulated process time, in seconds (see
-    `explanation <http://stackoverflow.com/questions/556405/>`__).
-    On Windows and OSX only *user* and *system* are filled, the others are
-    set to ``0``.
-    This is similar to
-    `os.times() <http://docs.python.org//library/os.html#os.times>`__
-    but can be used for any process PID.
-
-    .. versionchanged::
-      4.1.0 return two extra fields: *children_user* and *children_system*.
-
-  .. method:: cpu_percent(interval=None)
-
-    Return a float representing the process CPU utilization as a percentage.
-    The returned value refers to the utilization of a single CPU, i.e. it is
-    not evenly split between the number of available CPU cores.
-    When *interval* is > ``0.0`` compares process times to system CPU times
-    elapsed before and after the interval (blocking). When interval is ``0.0``
-    or ``None`` compares process times to system CPU times elapsed since last
-    call, returning immediately. That means the first time this is called it
-    will return a meaningless ``0.0`` value which you are supposed to ignore.
-    In this case is recommended for accuracy that this function be called a
-    second time with at least ``0.1`` seconds between calls.
-    Example:
-
-      >>> import psutil
-      >>> p = psutil.Process()
-      >>>
-      >>> # blocking
-      >>> p.cpu_percent(interval=1)
-      2.0
-      >>> # non-blocking (percentage since last call)
-      >>> p.cpu_percent(interval=None)
-      2.9
-      >>>
-
-    .. note::
-      a percentage > 100 is legitimate as it can result from a process with
-      multiple threads running on different CPU cores.
-
-    .. note::
-      the returned value is explcitly **not** split evenly between all CPUs
-      cores (differently from :func:`psutil.cpu_percent()`).
-      This means that a busy loop process running on a system with 2 CPU
-      cores will be reported as having 100% CPU utilization instead of 50%.
-      This was done in order to be consistent with UNIX's "top" utility
-      and also to make it easier to identify processes hogging CPU resources
-      (independently from the number of CPU cores).
-      It must be noted that in the example above taskmgr.exe on Windows will
-      report 50% usage instead.
-      To emulate Windows's taskmgr.exe behavior you can do:
-      ``p.cpu_percent() / psutil.cpu_count()``.
-
-    .. warning::
-      the first time this method is called with interval = ``0.0`` or
-      ``None`` it will return a meaningless ``0.0`` value which you are
-      supposed to ignore.
-
-  .. method:: cpu_affinity(cpus=None)
-
-    Get or set process current
-    `CPU affinity <http://www.linuxjournal.com/article/6799?page=0,0>`__.
-    CPU affinity consists in telling the OS to run a certain process on a
-    limited set of CPUs only. The number of eligible CPUs can be obtained with
-    ``list(range(psutil.cpu_count()))``. ``ValueError`` will be raise on set
-    in case an invalid CPU number is specified.
-
-      >>> import psutil
-      >>> psutil.cpu_count()
-      4
-      >>> p = psutil.Process()
-      >>> p.cpu_affinity()  # get
-      [0, 1, 2, 3]
-      >>> p.cpu_affinity([0])  # set; from now on, process will run on CPU #0 only
-      >>> p.cpu_affinity()
-      [0]
-      >>>
-      >>> # reset affinity against all CPUs
-      >>> all_cpus = list(range(psutil.cpu_count()))
-      >>> p.cpu_affinity(all_cpus)
-      >>>
-
-    Availability: Linux, Windows, FreeBSD
-
-    .. versionchanged:: 2.2.0 added support for FreeBSD
-
-  .. method:: memory_info()
-
-    Return a namedtuple with variable fields depending on the platform
-    representing memory information about the process.
-    The "portable" fields available on all plaforms are `rss` and `vms`.
-    All numbers are expressed in bytes.
-
-    +---------+---------+-------+---------+------------------------------+
-    | Linux   | OSX     | BSD   | Solaris | Windows                      |
-    +=========+=========+=======+=========+==============================+
-    | rss     | rss     | rss   | rss     | rss (alias for ``wset``)     |
-    +---------+---------+-------+---------+------------------------------+
-    | vms     | vms     | vms   | vms     | vms (alias for ``pagefile``) |
-    +---------+---------+-------+---------+------------------------------+
-    | shared  | pfaults | text  |         | num_page_faults              |
-    +---------+---------+-------+---------+------------------------------+
-    | text    | pageins | data  |         | peak_wset                    |
-    +---------+---------+-------+---------+------------------------------+
-    | lib     |         | stack |         | wset                         |
-    +---------+---------+-------+---------+------------------------------+
-    | data    |         |       |         | peak_paged_pool              |
-    +---------+---------+-------+---------+------------------------------+
-    | dirty   |         |       |         | paged_pool                   |
-    +---------+---------+-------+---------+------------------------------+
-    |         |         |       |         | peak_nonpaged_pool           |
-    +---------+---------+-------+---------+------------------------------+
-    |         |         |       |         | nonpaged_pool                |
-    +---------+---------+-------+---------+------------------------------+
-    |         |         |       |         | pagefile                     |
-    +---------+---------+-------+---------+------------------------------+
-    |         |         |       |         | peak_pagefile                |
-    +---------+---------+-------+---------+------------------------------+
-    |         |         |       |         | private                      |
-    +---------+---------+-------+---------+------------------------------+
-
-    - **rss**: aka "Resident Set Size", this is the non-swapped physical
-      memory a process has used.
-      On UNIX it matches "top"'s RES column
-      (see `doc <http://linux.die.net/man/1/top>`__).
-      On Windows this is an alias for `wset` field and it matches "Mem Usage"
-      column of taskmgr.exe.
-
-    - **vms**: aka "Virtual Memory Size", this is the total amount of virtual
-      memory used by the process.
-      On UNIX it matches "top"'s VIRT column
-      (see `doc <http://linux.die.net/man/1/top>`__).
-      On Windows this is an alias for `pagefile` field and it matches
-      "Mem Usage" "VM Size" column of taskmgr.exe.
-
-    - **shared**: *(Linux)*
-      memory that could be potentially shared with other processes.
-      This matches "top"'s SHR column
-      (see `doc <http://linux.die.net/man/1/top>`__).
-
-    - **text** *(Linux, BSD)*:
-      aka TRS (text resident set) the amount of memory devoted to
-      executable code. This matches "top"'s CODE column
-      (see `doc <http://linux.die.net/man/1/top>`__).
-
-    - **data** *(Linux, BSD)*:
-      aka DRS (data resident set) the amount of physical memory devoted to
-      other than executable code. It matches "top"'s DATA column
-      (see `doc <http://linux.die.net/man/1/top>`__).
-
-    - **lib** *(Linux)*: the memory used by shared libraries.
-
-    - **dirty** *(Linux)*: the number of dirty pages.
-
-    For Windows fields rely on
-    `PROCESS_MEMORY_COUNTERS_EX <http://msdn.microsoft.com/en-us/library/windows/desktop/ms684874(v=vs.85).aspx>`__ structure doc.
-    Example on Linux:
-
-      >>> import psutil
-      >>> p = psutil.Process()
-      >>> p.memory_info()
-      pmem(rss=15491072, vms=84025344, shared=5206016, text=2555904, lib=0, data=9891840, dirty=0)
-
-    .. versionchanged::
-      4.0.0 mutiple fields are returned, not only `rss` and `vms`.
-
-  .. method:: memory_info_ex()
-
-    Same as :meth:`memory_info` (deprecated).
-
-    .. warning::
-      deprecated in version 4.0.0; use :meth:`memory_info` instead.
-
-  .. method:: memory_full_info()
-
-    This method returns the same information as :meth:`memory_info`, plus, on
-    some platform (Linux, OSX, Windows), also provides additional metrics
-    (USS, PSS and swap).
-    The additional metrics provide a better representation of "effective"
-    process memory consumption (in case of USS) as explained in detail
-    `here <http://grodola.blogspot.com/2016/02/psutil-4-real-process-memory-and-environ.html>`__.
-    It does so by passing through the whole process address.
-    As such it usually requires higher user privileges than
-    :meth:`memory_info` and is considerably slower.
-    On platforms where extra fields are not implented this simply returns the
-    same metrics as :meth:`memory_info`.
-
-    - **uss** *(Linux, OSX, Windows)*:
-      aka "Unique Set Size", this is the memory which is unique to a process
-      and which would be freed if the process was terminated right now.
-
-    - **pss** *(Linux)*: aka "Proportional Set Size", is the amount of memory
-      shared with other processes, accounted in a way that the amount is
-      divided evenly between the processes that share it.
-      I.e. if a process has 10 MBs all to itself and 10 MBs shared with
-      another process its PSS will be 15 MBs.
-
-    - **swap** *(Linux)*: amount of memory that has been swapped out to disk.
-
-    .. note::
-      `uss` is probably the most representative metric for determining how
-      much memory is actually being used by a process.
-      It represents the amount of memory that would be freed if the process
-      was terminated right now.
-
-    Example on Linux:
-
-      >>> import psutil
-      >>> p = psutil.Process()
-      >>> p.memory_full_info()
-      pfullmem(rss=10199040, vms=52133888, shared=3887104, text=2867200, lib=0, data=5967872, dirty=0, uss=6545408, pss=6872064, swap=0)
-      >>>
-
-    See also `scripts/procsmem.py <https://github.com/giampaolo/psutil/blob/master/scripts/procsmem.py>`__
-    for an example application.
-
-    .. versionadded:: 4.0.0
-
-  .. method:: memory_percent(memtype="rss")
-
-    Compare process memory to total physical system memory and calculate
-    process memory utilization as a percentage.
-    *memtype* argument is a string that dictates what type of process memory
-    you want to compare against. You can choose between the namedtuple field
-    names returned by :meth:`memory_info` and :meth:`memory_full_info`
-    (defaults to ``"rss"``).
-
-    .. versionchanged:: 4.0.0 added `memtype` parameter.
-
-  .. method:: memory_maps(grouped=True)
-
-    Return process's mapped memory regions as a list of namedtuples whose
-    fields are variable depending on the platform.
-    This method is useful to obtain a detailed representation of process
-    memory usage as explained
-    `here <http://bmaurer.blogspot.it/2006/03/memory-usage-with-smaps.html>`__
-    (the most important value is "private" memory).
-    If *grouped* is ``True`` the mapped regions with the same *path* are
-    grouped together and the different memory fields are summed.  If *grouped*
-    is ``False`` each mapped region is shown as a single entity and the
-    namedtuple will also include the mapped region's address space (*addr*)
-    and permission set (*perms*).
-    See `scripts/pmap.py <https://github.com/giampaolo/psutil/blob/master/scripts/pmap.py>`__
-    for an example application.
-
-    +---------------+--------------+---------+-----------+--------------+
-    | Linux         |  OSX         | Windows | Solaris   | FreeBSD      |
-    +===============+==============+=========+===========+==============+
-    | rss           | rss          | rss     | rss       | rss          |
-    +---------------+--------------+---------+-----------+--------------+
-    | size          | private      |         | anonymous | private      |
-    +---------------+--------------+---------+-----------+--------------+
-    | pss           | swapped      |         | locked    | ref_count    |
-    +---------------+--------------+---------+-----------+--------------+
-    | shared_clean  | dirtied      |         |           | shadow_count |
-    +---------------+--------------+---------+-----------+--------------+
-    | shared_dirty  | ref_count    |         |           |              |
-    +---------------+--------------+---------+-----------+--------------+
-    | private_clean | shadow_depth |         |           |              |
-    +---------------+--------------+---------+-----------+--------------+
-    | private_dirty |              |         |           |              |
-    +---------------+--------------+---------+-----------+--------------+
-    | referenced    |              |         |           |              |
-    +---------------+--------------+---------+-----------+--------------+
-    | anonymous     |              |         |           |              |
-    +---------------+--------------+---------+-----------+--------------+
-    | swap          |              |         |           |              |
-    +---------------+--------------+---------+-----------+--------------+
-
-      >>> import psutil
-      >>> p = psutil.Process()
-      >>> p.memory_maps()
-      [pmmap_grouped(path='/lib/x8664-linux-gnu/libutil-2.15.so', rss=32768, size=2125824, pss=32768, shared_clean=0, shared_dirty=0, private_clean=20480, private_dirty=12288, referenced=32768, anonymous=12288, swap=0),
-       pmmap_grouped(path='/lib/x8664-linux-gnu/libc-2.15.so', rss=3821568, size=3842048, pss=3821568, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=3821568, referenced=3575808, anonymous=3821568, swap=0),
-       pmmap_grouped(path='/lib/x8664-linux-gnu/libcrypto.so.0.1', rss=34124, rss=32768, size=2134016, pss=15360, shared_clean=24576, shared_dirty=0, private_clean=0, private_dirty=8192, referenced=24576, anonymous=8192, swap=0),
-       pmmap_grouped(path='[heap]',  rss=32768, size=139264, pss=32768, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=32768, referenced=32768, anonymous=32768, swap=0),
-       pmmap_grouped(path='[stack]', rss=2465792, size=2494464, pss=2465792, shared_clean=0, shared_dirty=0, private_clean=0, private_dirty=2465792, referenced=2277376, anonymous=2465792, swap=0),
-       ...]
-      >>>
-
-    Availability: All platforms except OpenBSD and NetBSD.
-
-  .. method:: children(recursive=False)
-
-    Return the children of this process as a list of :Class:`Process` objects,
-    preemptively checking whether PID has been reused. If recursive is `True`
-    return all the parent descendants.
-    Example assuming *A == this process*:
-    ::
-
-      A ─�
-         │
-         ├─ B (child) ─�
-         │             └─ X (grandchild) ─�
-         │                                └─ Y (great grandchild)
-         ├─ C (child)
-         └─ D (child)
-
-      >>> p.children()
-      B, C, D
-      >>> p.children(recursive=True)
-      B, X, Y, C, D
-
-    Note that in the example above if process X disappears process Y won't be
-    returned either as the reference to process A is lost.
-
-  .. method:: open_files()
-
-    Return regular files opened by process as a list of namedtuples including
-    the following fields:
-
-    - **path**: the absolute file name.
-    - **fd**: the file descriptor number; on Windows this is always ``-1``.
-    - **position** (*Linux*): the file (offset) position.
-    - **mode** (*Linux*): a string indicating how the file was opened, similarly
-      `open <https://docs.python.org/3/library/functions.html#open>`__'s
-      ``mode`` argument. Possible values are ``'r'``, ``'w'``, ``'a'``,
-      ``'r+'`` and ``'a+'``. There's no distinction between files opened in
-      bynary or text mode (``"b"`` or ``"t"``).
-    - **flags** (*Linux*): the flags which were passed to the underlying
-      `os.open <https://docs.python.org/2/library/os.html#os.open>`__ C call
-      when the file was opened (e.g.
-      `os.O_RDONLY <https://docs.python.org/3/library/os.html#os.O_RDONLY>`__,
-      `os.O_TRUNC <https://docs.python.org/3/library/os.html#os.O_TRUNC>`__,
-      etc).
-
-    >>> import psutil
-    >>> f = open('file.ext', 'w')
-    >>> p = psutil.Process()
-    >>> p.open_files()
-    [popenfile(path='/home/giampaolo/svn/psutil/setup.py', fd=3, position=0, mode='r', flags=32768),
-    popenfile(path='/var/log/monitd', fd=4, position=235542, mode='a', flags=33793)]
-
-    .. warning::
-      on Windows this is not fully reliable as due to some limitations of the
-      Windows API the underlying implementation may hang when retrieving
-      certain file handles.
-      In order to work around that psutil on Windows Vista (and higher) spawns
-      a thread and kills it if it's not responding after 100ms.
-      That implies that on Windows this method is not guaranteed to enumerate
-      all regular file handles (see full
-      `discussion <https://github.com/giampaolo/psutil/pull/597>`_).
-
-    .. warning::
-      on BSD this method can return files with a 'null' path due to a kernel
-      bug hence it's not reliable
-      (see `issue 595 <https://github.com/giampaolo/psutil/pull/595>`_).
-
-    .. versionchanged::
-      3.1.0 no longer hangs on Windows.
-
-    .. versionchanged::
-      4.1.0 new *position*, *mode* and *flags* fields on Linux.
-
-  .. method:: connections(kind="inet")
-
-    Return socket connections opened by process as a list of namedtuples.
-    To get system-wide connections use :func:`psutil.net_connections()`.
-    Every namedtuple provides 6 attributes:
-
-    - **fd**: the socket file descriptor. This can be passed to
-      `socket.fromfd() <http://docs.python.org/library/socket.html#socket.fromfd>`__
-      to obtain a usable socket object.
-      This is only available on UNIX; on Windows ``-1`` is always returned.
-    - **family**: the address family, either `AF_INET
-      <http://docs.python.org//library/socket.html#socket.AF_INET>`__,
-      `AF_INET6 <http://docs.python.org//library/socket.html#socket.AF_INET6>`__
-      or `AF_UNIX <http://docs.python.org//library/socket.html#socket.AF_UNIX>`__.
-    - **type**: the address type, either `SOCK_STREAM
-      <http://docs.python.org//library/socket.html#socket.SOCK_STREAM>`__ or
-      `SOCK_DGRAM
-      <http://docs.python.org//library/socket.html#socket.SOCK_DGRAM>`__.
-    - **laddr**: the local address as a ``(ip, port)`` tuple or a ``path``
-      in case of AF_UNIX sockets.
-    - **raddr**: the remote address as a ``(ip, port)`` tuple or an absolute
-      ``path`` in case of UNIX sockets.
-      When the remote endpoint is not connected you'll get an empty tuple
-      (AF_INET) or ``None`` (AF_UNIX).
-      On Linux AF_UNIX sockets will always have this set to ``None``.
-    - **status**: represents the status of a TCP connection. The return value
-      is one of the :data:`psutil.CONN_* <psutil.CONN_ESTABLISHED>` constants.
-      For UDP and UNIX sockets this is always going to be
-      :const:`psutil.CONN_NONE`.
-
-    The *kind* parameter is a string which filters for connections that fit the
-    following criteria:
-
-    +----------------+-----------------------------------------------------+
-    | **Kind value** | **Connections using**                               |
-    +================+=====================================================+
-    | "inet"         | IPv4 and IPv6                                       |
-    +----------------+-----------------------------------------------------+
-    | "inet4"        | IPv4                                                |
-    +----------------+-----------------------------------------------------+
-    | "inet6"        | IPv6                                                |
-    +----------------+-----------------------------------------------------+
-    | "tcp"          | TCP                                                 |
-    +----------------+-----------------------------------------------------+
-    | "tcp4"         | TCP over IPv4                                       |
-    +----------------+-----------------------------------------------------+
-    | "tcp6"         | TCP over IPv6                                       |
-    +----------------+-----------------------------------------------------+
-    | "udp"          | UDP                                                 |
-    +----------------+-----------------------------------------------------+
-    | "udp4"         | UDP over IPv4                                       |
-    +----------------+-----------------------------------------------------+
-    | "udp6"         | UDP over IPv6                                       |
-    +----------------+-----------------------------------------------------+
-    | "unix"         | UNIX socket (both UDP and TCP protocols)            |
-    +----------------+-----------------------------------------------------+
-    | "all"          | the sum of all the possible families and protocols  |
-    +----------------+-----------------------------------------------------+
-
-    Example:
-
-      >>> import psutil
-      >>> p = psutil.Process(1694)
-      >>> p.name()
-      'firefox'
-      >>> p.connections()
-      [pconn(fd=115, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 48776), raddr=('93.186.135.91', 80), status='ESTABLISHED'),
-       pconn(fd=117, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 43761), raddr=('72.14.234.100', 80), status='CLOSING'),
-       pconn(fd=119, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 60759), raddr=('72.14.234.104', 80), status='ESTABLISHED'),
-       pconn(fd=123, family=<AddressFamily.AF_INET: 2>, type=<SocketType.SOCK_STREAM: 1>, laddr=('10.0.0.1', 51314), raddr=('72.14.234.83', 443), status='SYN_SENT')]
-
-  .. method:: is_running()
-
-    Return whether the current process is running in the current process list.
-    This is reliable also in case the process is gone and its PID reused by
-    another process, therefore it must be preferred over doing
-    ``psutil.pid_exists(p.pid)``.
-
-    .. note::
-      this will return ``True`` also if the process is a zombie
-      (``p.status() == psutil.STATUS_ZOMBIE``).
-
-  .. method:: send_signal(signal)
-
-    Send a signal to process (see
-    `signal module <http://docs.python.org//library/signal.html>`__
-    constants) preemptively checking whether PID has been reused.
-    On UNIX this is the same as ``os.kill(pid, sig)``.
-    On Windows only **SIGTERM**, **CTRL_C_EVENT** and **CTRL_BREAK_EVENT**
-    signals are supported and **SIGTERM** is treated as an alias for
-    :meth:`kill()`.
-
-    .. versionchanged::
-      3.2.0 support for CTRL_C_EVENT and CTRL_BREAK_EVENT signals on Windows
-      was added.
-
-  .. method:: suspend()
-
-    Suspend process execution with **SIGSTOP** signal preemptively checking
-    whether PID has been reused.
-    On UNIX this is the same as ``os.kill(pid, signal.SIGSTOP)``.
-    On Windows this is done by suspending all process threads execution.
-
-  .. method:: resume()
-
-    Resume process execution with **SIGCONT** signal preemptively checking
-    whether PID has been reused.
-    On UNIX this is the same as ``os.kill(pid, signal.SIGCONT)``.
-    On Windows this is done by resuming all process threads execution.
-
-  .. method:: terminate()
-
-    Terminate the process with **SIGTERM** signal preemptively checking
-    whether PID has been reused.
-    On UNIX this is the same as ``os.kill(pid, signal.SIGTERM)``.
-    On Windows this is an alias for :meth:`kill`.
-
-  .. method:: kill()
-
-     Kill the current process by using **SIGKILL** signal preemptively
-     checking whether PID has been reused.
-     On UNIX this is the same as ``os.kill(pid, signal.SIGKILL)``.
-     On Windows this is done by using
-     `TerminateProcess <http://msdn.microsoft.com/en-us/library/windows/desktop/ms686714(v=vs.85).aspx>`__.
-
-  .. method:: wait(timeout=None)
-
-    Wait for process termination and if the process is a children of the
-    current one also return the exit code, else ``None``. On Windows there's
-    no such limitation (exit code is always returned). If the process is
-    already terminated immediately return ``None`` instead of raising
-    :class:`NoSuchProcess`. If *timeout* is specified and process is still
-    alive raise :class:`TimeoutExpired` exception. It can also be used in a
-    non-blocking fashion by specifying ``timeout=0`` in which case it will
-    either return immediately or raise :class:`TimeoutExpired`.
-    To wait for multiple processes use :func:`psutil.wait_procs()`.
-
-
-Popen class
------------
-
-.. class:: Popen(*args, **kwargs)
-
-  A more convenient interface to stdlib
-  `subprocess.Popen <http://docs.python.org/library/subprocess.html#subprocess.Popen>`__.
-  It starts a sub process and deals with it exactly as when using
-  `subprocess.Popen <http://docs.python.org/library/subprocess.html#subprocess.Popen>`__
-  but in addition it also provides all the methods of
-  :class:`psutil.Process` class in a single interface.
-  For method names common to both classes such as
-  :meth:`send_signal() <psutil.Process.send_signal()>`,
-  :meth:`terminate() <psutil.Process.terminate()>` and
-  :meth:`kill() <psutil.Process.kill()>`
-  :class:`psutil.Process` implementation takes precedence.
-  For a complete documentation refer to
-  `subprocess module documentation <http://docs.python.org/library/subprocess.html>`__.
-
-  .. note::
-
-    Unlike `subprocess.Popen <http://docs.python.org/library/subprocess.html#subprocess.Popen>`__
-    this class preemptively checks whether PID has been reused on
-    :meth:`send_signal() <psutil.Process.send_signal()>`,
-    :meth:`terminate() <psutil.Process.terminate()>` and
-    :meth:`kill() <psutil.Process.kill()>`
-    so that you can't accidentally terminate another process, fixing
-    http://bugs.python.org/issue6973.
-
-  >>> import psutil
-  >>> from subprocess import PIPE
-  >>>
-  >>> p = psutil.Popen(["/usr/bin/python", "-c", "print('hello')"], stdout=PIPE)
-  >>> p.name()
-  'python'
-  >>> p.username()
-  'giampaolo'
-  >>> p.communicate()
-  ('hello\n', None)
-  >>> p.wait(timeout=2)
-  0
-  >>>
-
-Windows services
-================
-
-.. function:: win_service_iter()
-
-  Return an iterator yielding a :class:`WindowsService` class instance for all
-  Windows services installed.
-
-  .. versionadded:: 4.2.0
-
-  Availability: Windows
-
-.. function:: win_service_get(name)
-
-  Get a Windows service by name, returning a :class:`WindowsService` instance.
-  Raise :class:`psutil.NoSuchProcess` if no service with such name exists.
-
-  .. versionadded:: 4.2.0
-
-  Availability: Windows
-
-.. class:: WindowsService
-
-  Represents a Windows service with the given *name*. This class is returned
-  by :func:`win_service_iter` and :func:`win_service_get` functions and it is
-  not supposed to be instantiated directly.
-
-  .. method:: name()
-
-    The service name. This string is how a service is referenced and can be
-    passed to :func:`win_service_get` to get a new :class:`WindowsService`
-    instance.
-
-  .. method:: display_name()
-
-    The service display name. The value is cached when this class is
-    instantiated.
-
-  .. method:: binpath()
-
-    The fully qualified path to the service binary/exe file as a string,
-    including command line arguments.
-
-  .. method:: username()
-
-    The name of the user that owns this service.
-
-  .. method:: start_type()
-
-    A string which can either be `"automatic"`, `"manual"` or `"disabled"`.
-
-  .. method:: pid()
-
-    The process PID, if any, else `None`. This can be passed to
-    :class:`Process` class to control the service's process.
-
-  .. method:: status()
-
-    Service status as a string, which may be either `"running"`, `"paused"`,
-    `"start_pending"`, `"pause_pending"`, `"continue_pending"`,
-    `"stop_pending"` or `"stopped"`.
-
-  .. method:: description()
-
-    Service long description.
-
-  .. method:: as_dict()
-
-    Utility method retrieving all the information above as a dictionary.
-
-  .. versionadded:: 4.2.0
-
-  Availability: Windows
-
-Example code:
-
-  >>> import psutil
-  >>> list(psutil.win_service_iter())
-  [<WindowsService(name='AeLookupSvc', display_name='Application Experience') at 38850096>,
-   <WindowsService(name='ALG', display_name='Application Layer Gateway Service') at 38850128>,
-   <WindowsService(name='APNMCP', display_name='Ask Update Service') at 38850160>,
-   <WindowsService(name='AppIDSvc', display_name='Application Identity') at 38850192>,
-   ...]
-  >>> s = psutil.win_service_get('alg')
-  >>> s.as_dict()
-  {'binpath': 'C:\\Windows\\System32\\alg.exe',
-   'description': 'Provides support for 3rd party protocol plug-ins for Internet Connection Sharing',
-   'display_name': 'Application Layer Gateway Service',
-   'name': 'alg',
-   'pid': None,
-   'start_type': 'manual',
-   'status': 'stopped',
-   'username': 'NT AUTHORITY\\LocalService'}
-
-Constants
-=========
-
-.. _const-oses:
-.. data:: POSIX
-          WINDOWS
-          LINUX
-          OSX
-          FREEBSD
-          NETBSD
-          OPENBSD
-          BSD
-          SUNOS
-
-  ``bool`` constants which define what platform you're on. E.g. if on Windows,
-  *WINDOWS* constant will be ``True``, all others will be ``False``.
-
-  .. versionadded:: 4.0.0
-
-.. _const-procfs_path:
-.. data:: PROCFS_PATH
-
-  The path of the /proc filesystem on Linux and Solaris (defaults to "/proc").
-  You may want to re-set this constant right after importing psutil in case
-  your /proc filesystem is mounted elsewhere.
-
-  Availability: Linux, Solaris
-
-  .. versionadded:: 3.2.3
-  .. versionchanged:: 3.4.2 also available on Solaris.
-
-.. _const-pstatus:
-.. data:: STATUS_RUNNING
-          STATUS_SLEEPING
-          STATUS_DISK_SLEEP
-          STATUS_STOPPED
-          STATUS_TRACING_STOP
-          STATUS_ZOMBIE
-          STATUS_DEAD
-          STATUS_WAKE_KILL
-          STATUS_WAKING
-          STATUS_IDLE (OSX, FreeBSD)
-          STATUS_LOCKED (FreeBSD)
-          STATUS_WAITING (FreeBSD)
-          STATUS_SUSPENDED (NetBSD)
-
-  A set of strings representing the status of a process.
-  Returned by :meth:`psutil.Process.status()`.
-
-  .. versionadded:: 3.4.1 STATUS_SUSPENDED (NetBSD)
-
-.. _const-conn:
-.. data:: CONN_ESTABLISHED
-          CONN_SYN_SENT
-          CONN_SYN_RECV
-          CONN_FIN_WAIT1
-          CONN_FIN_WAIT2
-          CONN_TIME_WAIT
-          CONN_CLOSE
-          CONN_CLOSE_WAIT
-          CONN_LAST_ACK
-          CONN_LISTEN
-          CONN_CLOSING
-          CONN_NONE
-          CONN_DELETE_TCB (Windows)
-          CONN_IDLE (Solaris)
-          CONN_BOUND (Solaris)
-
-  A set of strings representing the status of a TCP connection.
-  Returned by :meth:`psutil.Process.connections()` (`status` field).
-
-.. _const-prio:
-.. data:: ABOVE_NORMAL_PRIORITY_CLASS
-          BELOW_NORMAL_PRIORITY_CLASS
-          HIGH_PRIORITY_CLASS
-          IDLE_PRIORITY_CLASS
-          NORMAL_PRIORITY_CLASS
-          REALTIME_PRIORITY_CLASS
-
-  A set of integers representing the priority of a process on Windows (see
-  `MSDN documentation <http://msdn.microsoft.com/en-us/library/ms686219(v=vs.85).aspx>`__).
-  They can be used in conjunction with
-  :meth:`psutil.Process.nice()` to get or set process priority.
-
-  Availability: Windows
-
-  .. versionchanged::
-    3.0.0 on Python >= 3.4 these constants are
-    `enums <https://docs.python.org/3/library/enum.html#module-enum>`__
-    instead of a plain integer.
-
-.. _const-ioprio:
-.. data:: IOPRIO_CLASS_NONE
-          IOPRIO_CLASS_RT
-          IOPRIO_CLASS_BE
-          IOPRIO_CLASS_IDLE
-
-  A set of integers representing the I/O priority of a process on Linux. They
-  can be used in conjunction with :meth:`psutil.Process.ionice()` to get or set
-  process I/O priority.
-  *IOPRIO_CLASS_NONE* and *IOPRIO_CLASS_BE* (best effort) is the default for
-  any process that hasn't set a specific I/O priority.
-  *IOPRIO_CLASS_RT* (real time) means the process is given first access to the
-  disk, regardless of what else is going on in the system.
-  *IOPRIO_CLASS_IDLE* means the process will get I/O time when no-one else
-  needs the disk.
-  For further information refer to manuals of
-  `ionice <http://linux.die.net/man/1/ionice>`__
-  command line utility or
-  `ioprio_get <http://linux.die.net/man/2/ioprio_get>`__
-  system call.
-
-  Availability: Linux
-
-  .. versionchanged::
-    3.0.0 on Python >= 3.4 thse constants are
-    `enums <https://docs.python.org/3/library/enum.html#module-enum>`__
-    instead of a plain integer.
-
-.. _const-rlimit:
-.. data:: RLIMIT_INFINITY
-          RLIMIT_AS
-          RLIMIT_CORE
-          RLIMIT_CPU
-          RLIMIT_DATA
-          RLIMIT_FSIZE
-          RLIMIT_LOCKS
-          RLIMIT_MEMLOCK
-          RLIMIT_MSGQUEUE
-          RLIMIT_NICE
-          RLIMIT_NOFILE
-          RLIMIT_NPROC
-          RLIMIT_RSS
-          RLIMIT_RTPRIO
-          RLIMIT_RTTIME
-          RLIMIT_RTPRIO
-          RLIMIT_SIGPENDING
-          RLIMIT_STACK
-
-  Constants used for getting and setting process resource limits to be used in
-  conjunction with :meth:`psutil.Process.rlimit()`. See
-  `man prlimit <http://linux.die.net/man/2/prlimit>`__ for further information.
-
-  Availability: Linux
-
-.. _const-aflink:
-.. data:: AF_LINK
-
-  Constant which identifies a MAC address associated with a network interface.
-  To be used in conjunction with :func:`psutil.net_if_addrs()`.
-
-  .. versionadded:: 3.0.0
-
-.. _const-duplex:
-.. data:: NIC_DUPLEX_FULL
-          NIC_DUPLEX_HALF
-          NIC_DUPLEX_UNKNOWN
-
-  Constants which identifies whether a NIC (network interface card) has full or
-  half mode speed.  NIC_DUPLEX_FULL means the NIC is able to send and receive
-  data (files) simultaneously, NIC_DUPLEX_FULL means the NIC can either send or
-  receive data at a time.
-  To be used in conjunction with :func:`psutil.net_if_stats()`.
-
-  .. versionadded:: 3.0.0
-
-Development guide
-=================
-
-If you plan on hacking on psutil (e.g. want to add a new feature or fix a bug)
-take a look at the
-`development guide <https://github.com/giampaolo/psutil/blob/master/DEVGUIDE.rst>`_.
+   <div class="home-section-label">Stats</div>
+   <div class="home-stats">
+     <a class="home-stat" href="https://clickpy.clickhouse.com/dashboard/psutil">
+       <span class="home-stat-num">390+ million</span>
+       <span class="home-stat-label">downloads per month</span>
+     </a>
+     <a class="home-stat" href="https://github.com/giampaolo/psutil/network/dependents">
+       <span class="home-stat-num">780,000+</span>
+       <span class="home-stat-label">GitHub repositories</span>
+     </a>
+     <a class="home-stat" href="timeline/">
+       <span class="home-stat-num">{{years_in_development}} years</span>
+       <span class="home-stat-label">in active development</span>
+     </a>
+   </div>
+
+.. ============================================================================
+.. Sponsors
+.. ============================================================================
+
+.. raw:: html
+
+   <div id="sponsors">
+     <div class="home-section-label">Sponsors</div>
+
+.. raw:: html
+   :file: _sponsors.html
+
+.. raw:: html
+
+   </div>
+
+.. ============================================================================
+.. TOC: hidden via CSS, needed by Sphinx for sidebar nav
+.. ============================================================================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Documentation
+
+   Install <install>
+   API overview <api-overview>
+   API Reference <api>
+   FAQ <faq>
+   Performance <performance>
+   Recipes <recipes>
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Reference
+
+   Shell equivalents <shell-equivalents>
+   Stdlib equivalents <stdlib-equivalents>
+   Glossary <glossary>
+   Platform support <platform>
+   Migration <migration>
+
+.. toctree::
+   :maxdepth: 2
+   :caption: About
+
+   Who uses psutil <adoption>
+   Alternatives <alternatives>
+   Funding <funding>
+   Credits <credits>
+
+.. toctree::
+   :maxdepth: 2
+   :titlesonly:
+   :caption: Project
+
+   Blog <blog>
+   Changelog <changelog>
+   Timeline <timeline>
+   Development guide <devguide>
+   General Index <genindex>
diff --git a/docs/install.rst b/docs/install.rst
new file mode 100644
index 0000000000..6927dde566
--- /dev/null
+++ b/docs/install.rst
@@ -0,0 +1,199 @@
+Install psutil
+==============
+
+Linux, Windows, macOS (wheels)
+------------------------------
+
+Prebuilt wheels are distributed for these platforms, so a C compiler is not
+required. Install psutil with:
+
+.. code-block:: none
+
+    pip install psutil
+
+Inside a virtual environment you can also use
+`uv <https://docs.astral.sh/uv/>`_:
+
+.. code-block:: none
+
+    uv pip install psutil
+
+If no wheel is available for your platform or architecture, pip will build
+psutil from source (see below).
+
+.. _install_from_source:
+
+Build psutil from source
+------------------------
+
+Building psutil from source requires a C compiler and the Python development
+headers. On Linux, FreeBSD, NetBSD, OpenBSD and Solaris, the
+`install-sysdeps.sh`_ script can install them for you:
+
+.. code-block:: none
+
+    curl -fsSL https://raw.githubusercontent.com/giampaolo/psutil/master/scripts/internal/install-sysdeps.sh | sh
+
+Alternatively, install them manually as described below.
+
+Linux
+^^^^^
+
+Debian / Ubuntu:
+
+.. code-block:: none
+
+    sudo apt-get install gcc python3-dev
+
+Red Hat / CentOS:
+
+.. code-block:: none
+
+    sudo yum install gcc python3-devel
+
+Fedora:
+
+.. code-block:: none
+
+    sudo dnf install gcc python3-devel
+
+Arch:
+
+.. code-block:: none
+
+    sudo pacman -S gcc python
+
+Alpine:
+
+.. code-block:: none
+
+    sudo apk add gcc python3-dev musl-dev linux-headers
+
+.. _install_windows:
+
+Windows
+^^^^^^^
+
+- To build psutil from source, install
+  `Microsoft C++ Build Tools <https://visualstudio.microsoft.com/visual-cpp-build-tools/>`_
+  with the **Desktop development with C++** option selected.
+- MinGW is not supported.
+- To clone psutil's Git repository and build or develop it locally, first
+  install `Git for Windows`_ and GNU Make. To install GNU Make, open PowerShell
+  and run:
+
+  .. code-block:: none
+
+      winget install --exact --id ezwinports.make
+
+- Close and reopen Git Bash, then follow :ref:`build_and_install`.
+
+macOS
+^^^^^
+
+Install the Xcode command line tools:
+
+.. code-block:: none
+
+    xcode-select --install
+
+FreeBSD
+^^^^^^^
+
+.. code-block:: none
+
+    pkg install python3
+
+OpenBSD
+^^^^^^^
+
+.. code-block:: none
+
+    export PKG_PATH=https://cdn.openbsd.org/pub/OpenBSD/`uname -r`/packages/`uname -m`/
+    pkg_add -v python%3
+
+NetBSD
+^^^^^^
+
+pkgsrc has no version-agnostic python3 package, so choose one of the available
+Python 3 versions. For example:
+
+.. code-block:: none
+
+    export PKG_PATH="https://cdn.netbsd.org/pub/pkgsrc/packages/NetBSD/`uname -m`/`uname -r`/All"
+    pkg_add -v pkgin
+    pkgin update
+    pkgin install python314
+
+Solaris
+^^^^^^^
+
+.. code-block:: none
+
+    pkg install developer/gcc
+
+If ``cc`` is unavailable, set ``CC=gcc`` when running the commands in
+:ref:`build_and_install`.
+
+AIX
+^^^
+
+``install-sysdeps.sh`` has no AIX branch. Install a C compiler and the Python
+development headers from the `AIX Toolbox`_.
+
+.. _build_and_install:
+
+Build and install
+-----------------
+
+To build and install psutil from a Git checkout:
+
+.. code-block:: none
+
+    git clone https://github.com/giampaolo/psutil.git
+    cd psutil
+    make install-sysdeps
+    make build
+    make install
+
+.. note::
+
+   By default C source files are compiled in parallel, one job per CPU, which
+   makes building from source 2x to 3.6x faster. Use
+   :envvar:`PSUTIL_BUILD_JOBS` to change the number of jobs.
+
+Troubleshooting
+---------------
+
+Install pip
+^^^^^^^^^^^
+
+Python installations normally include pip. If it is missing, first try:
+
+.. code-block:: none
+
+    python3 -m ensurepip --upgrade
+
+Some OS-packaged Python installations do not include ``ensurepip``. There,
+either install the pip package or download `get-pip.py`_ and run:
+
+.. code-block:: none
+
+    python3 get-pip.py
+
+Permission errors
+^^^^^^^^^^^^^^^^^
+
+If you encounter permission errors, install psutil inside a virtual environment
+instead of modifying the system Python installation:
+
+.. code-block:: none
+
+    python3 -m venv .venv
+    source .venv/bin/activate
+    python -m pip install psutil
+
+.. _`AIX Toolbox`: https://www.ibm.com/support/pages/aix-toolbox-open-source-software-downloads-alpha
+.. _`get-pip.py`: https://bootstrap.pypa.io/get-pip.py
+.. _`Git for Windows`: https://git-scm.com/install/windows
+.. _`install-sysdeps.sh`: https://github.com/giampaolo/psutil/blob/master/scripts/internal/install-sysdeps.sh
diff --git a/docs/make.bat b/docs/make.bat
deleted file mode 100644
index 9bc67515c6..0000000000
--- a/docs/make.bat
+++ /dev/null
@@ -1,242 +0,0 @@
-@ECHO OFF
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=sphinx-build
-)
-set BUILDDIR=_build
-set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% .
-set I18NSPHINXOPTS=%SPHINXOPTS% .
-if NOT "%PAPER%" == "" (
-	set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS%
-	set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS%
-)
-
-if "%1" == "" goto help
-
-if "%1" == "help" (
-	:help
-	echo.Please use `make ^<target^>` where ^<target^> is one of
-	echo.  html       to make standalone HTML files
-	echo.  dirhtml    to make HTML files named index.html in directories
-	echo.  singlehtml to make a single large HTML file
-	echo.  pickle     to make pickle files
-	echo.  json       to make JSON files
-	echo.  htmlhelp   to make HTML files and a HTML help project
-	echo.  qthelp     to make HTML files and a qthelp project
-	echo.  devhelp    to make HTML files and a Devhelp project
-	echo.  epub       to make an epub
-	echo.  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter
-	echo.  text       to make text files
-	echo.  man        to make manual pages
-	echo.  texinfo    to make Texinfo files
-	echo.  gettext    to make PO message catalogs
-	echo.  changes    to make an overview over all changed/added/deprecated items
-	echo.  xml        to make Docutils-native XML files
-	echo.  pseudoxml  to make pseudoxml-XML files for display purposes
-	echo.  linkcheck  to check all external links for integrity
-	echo.  doctest    to run all doctests embedded in the documentation if enabled
-	goto end
-)
-
-if "%1" == "clean" (
-	for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i
-	del /q /s %BUILDDIR%\*
-	goto end
-)
-
-
-%SPHINXBUILD% 2> nul
-if errorlevel 9009 (
-	echo.
-	echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
-	echo.installed, then set the SPHINXBUILD environment variable to point
-	echo.to the full path of the 'sphinx-build' executable. Alternatively you
-	echo.may add the Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.http://sphinx-doc.org/
-	exit /b 1
-)
-
-if "%1" == "html" (
-	%SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished. The HTML pages are in %BUILDDIR%/html.
-	goto end
-)
-
-if "%1" == "dirhtml" (
-	%SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml.
-	goto end
-)
-
-if "%1" == "singlehtml" (
-	%SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml.
-	goto end
-)
-
-if "%1" == "pickle" (
-	%SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished; now you can process the pickle files.
-	goto end
-)
-
-if "%1" == "json" (
-	%SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished; now you can process the JSON files.
-	goto end
-)
-
-if "%1" == "htmlhelp" (
-	%SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished; now you can run HTML Help Workshop with the ^
-.hhp project file in %BUILDDIR%/htmlhelp.
-	goto end
-)
-
-if "%1" == "qthelp" (
-	%SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished; now you can run "qcollectiongenerator" with the ^
-.qhcp project file in %BUILDDIR%/qthelp, like this:
-	echo.^> qcollectiongenerator %BUILDDIR%\qthelp\psutil.qhcp
-	echo.To view the help file:
-	echo.^> assistant -collectionFile %BUILDDIR%\qthelp\psutil.ghc
-	goto end
-)
-
-if "%1" == "devhelp" (
-	%SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished.
-	goto end
-)
-
-if "%1" == "epub" (
-	%SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished. The epub file is in %BUILDDIR%/epub.
-	goto end
-)
-
-if "%1" == "latex" (
-	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished; the LaTeX files are in %BUILDDIR%/latex.
-	goto end
-)
-
-if "%1" == "latexpdf" (
-	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
-	cd %BUILDDIR%/latex
-	make all-pdf
-	cd %BUILDDIR%/..
-	echo.
-	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
-	goto end
-)
-
-if "%1" == "latexpdfja" (
-	%SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex
-	cd %BUILDDIR%/latex
-	make all-pdf-ja
-	cd %BUILDDIR%/..
-	echo.
-	echo.Build finished; the PDF files are in %BUILDDIR%/latex.
-	goto end
-)
-
-if "%1" == "text" (
-	%SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished. The text files are in %BUILDDIR%/text.
-	goto end
-)
-
-if "%1" == "man" (
-	%SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished. The manual pages are in %BUILDDIR%/man.
-	goto end
-)
-
-if "%1" == "texinfo" (
-	%SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo.
-	goto end
-)
-
-if "%1" == "gettext" (
-	%SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished. The message catalogs are in %BUILDDIR%/locale.
-	goto end
-)
-
-if "%1" == "changes" (
-	%SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.The overview file is in %BUILDDIR%/changes.
-	goto end
-)
-
-if "%1" == "linkcheck" (
-	%SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Link check complete; look for any errors in the above output ^
-or in %BUILDDIR%/linkcheck/output.txt.
-	goto end
-)
-
-if "%1" == "doctest" (
-	%SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Testing of doctests in the sources finished, look at the ^
-results in %BUILDDIR%/doctest/output.txt.
-	goto end
-)
-
-if "%1" == "xml" (
-	%SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished. The XML files are in %BUILDDIR%/xml.
-	goto end
-)
-
-if "%1" == "pseudoxml" (
-	%SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml
-	if errorlevel 1 exit /b 1
-	echo.
-	echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml.
-	goto end
-)
-
-:end
diff --git a/docs/migration.rst b/docs/migration.rst
new file mode 100644
index 0000000000..745abbcf7a
--- /dev/null
+++ b/docs/migration.rst
@@ -0,0 +1,312 @@
+Migration guide
+===============
+
+This page summarises the breaking changes introduced in each major release and
+shows the code changes required to upgrade.
+
+.. note::
+  Minor and patch releases (e.g. 6.1.x, 7.1.x) do not contain breaking changes.
+  Only major releases are listed here.
+
+.. _migration-8.0:
+
+Migrating to 8.0
+-----------------
+
+Key breaking changes in 8.0:
+
+- :func:`process_iter` now pre-fetches values.
+- :attr:`Process.info` is deprecated: use direct methods instead.
+- Named tuple field order changed: use attribute access instead of positional
+  unpacking.
+- Some return types are now enums instead of strings.
+- :meth:`Process.memory_full_info` is deprecated: use
+  :meth:`Process.memory_footprint`.
+- New :meth:`Process.memory_extras` method, returning extra platform-specific
+  memory metrics.
+- New :attr:`Process.attrs`: :class:`frozenset` of valid attribute names;
+  ``process_iter(attrs=[])`` is deprecated.
+- Python 3.6 and 3.7 dropped.
+- Windows < 10 dropped.
+- macOS 10.7 and 10.8 dropped.
+
+.. important::
+
+  Do not rely on positional unpacking of named tuples. Always use attribute
+  access (e.g. ``t.rss``).
+
+.. _migration-8.0-process-iter:
+
+process_iter(): p.info is deprecated
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:func:`process_iter` now caches pre-fetched values internally, so normal method
+calls can return them without using the :attr:`Process.info` dict. ``p.info``
+still works, but raises :exc:`DeprecationWarning`.
+
+.. code-block:: python
+
+  import psutil
+
+  # before
+  for p in psutil.process_iter(attrs=["name", "status"]):
+      print(p.info["name"], p.info["status"])
+
+  # after
+  for p in psutil.process_iter(attrs=["name", "status"]):
+      print(p.name(), p.status())  # return cached values, never raise
+
+When ``attrs`` are specified, the corresponding method calls return cached
+values without extra syscalls. :exc:`AccessDenied` / :exc:`ZombieProcess` are
+handled transparently by returning ``ad_value``.
+
+If you need a dict, use :meth:`Process.as_dict` instead of
+:attr:`Process.info`.
+
+.. code-block:: python
+
+  import psutil
+
+  # before
+  for p in psutil.process_iter(attrs=["name", "status"]):
+      print(p.info)
+
+  # after
+  attrs = ["name", "status"]
+  for p in psutil.process_iter(attrs=attrs):
+      print(p.as_dict(attrs))  # return cached values, never raise
+
+.. note::
+  If ``"name"`` was pre-fetched via ``attrs``, ``p.name()`` returns
+  ``ad_value`` instead of raising :exc:`AccessDenied`. If you need the
+  exception, do not include the method in ``attrs``.
+
+.. _migration-8.0-namedtuples:
+
+Named tuple field order changed
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+- :func:`cpu_times`: :field:`user`, :field:`system`, :field:`idle` fields
+  changed order on Linux, macOS and BSD. They are now always the first 3 fields
+  on all platforms, with platform-specific fields (e.g. :field:`nice`)
+  following. Positional access (e.g. ``cpu_times()[3]``) silently returns the
+  wrong field.
+
+  .. code-block:: python
+
+    # before
+    user, nice, system, idle = psutil.cpu_times()
+
+    # after
+    t = psutil.cpu_times()
+    user, system, idle = t.user, t.system, t.idle
+
+- :meth:`Process.memory_info`: the returned named tuple changed size and field
+  order.
+
+  - Linux: :field:`lib` and :field:`dirty` fields removed (they were always 0
+    since Linux 2.6). Aliases returning 0 and emitting
+    :exc:`DeprecationWarning` are kept.
+  - macOS: :field:`pfaults` and :field:`pageins` removed with **no aliases**.
+    Use :meth:`Process.page_faults` instead.
+  - Windows: old fields were renamed: :field:`wset` → :field:`rss`,
+    :field:`peak_wset` → :field:`peak_rss`, :field:`pagefile` and
+    :field:`private` → :field:`vms`, :field:`peak_pagefile` →
+    :field:`peak_vms`, :field:`num_page_faults` → :meth:`Process.page_faults`.
+    The old names still work but raise :exc:`DeprecationWarning`.
+    :field:`paged_pool`, :field:`nonpaged_pool`, :field:`peak_paged_pool`,
+    :field:`peak_nonpaged_pool` moved to :meth:`Process.memory_extras`.
+  - BSD: a new :field:`peak_rss` field was added.
+
+- :func:`virtual_memory`: on Windows, new :field:`cached` and :field:`wired`
+  fields were added.
+
+cpu_times() interrupt renamed to irq on Windows
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The :field:`interrupt` field of :func:`cpu_times` on Windows was renamed to
+:field:`irq` to match Linux and BSD. The old name still works but raises
+:exc:`DeprecationWarning`.
+
+.. _migration-8.0-enums:
+
+Constants and fields are now enums
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+These now yield enum members instead of plain ``str`` / ``int``, and the
+matching module constants are members of the same enums:
+
+- :meth:`Process.status` → :class:`ProcessStatus`
+- :field:`status` field of :meth:`Process.net_connections` and
+  :func:`net_connections` → :class:`ConnectionStatus`
+- :meth:`Process.nice` on Windows → :class:`ProcessPriority`
+- :field:`ioclass` field of :meth:`Process.ionice` → :class:`ProcessIOPriority`
+- :data:`RLIMIT_* <psutil.RLIMIT_NOFILE>` of :meth:`Process.rlimit` →
+  :class:`ProcessRlimit`
+
+They subclass :class:`enum.StrEnum` / :class:`enum.IntEnum`, so they compare
+equal to the values they replace: ``p.status() == psutil.STATUS_RUNNING`` keeps
+working. Only code inspecting :func:`repr` or :class:`type` needs updating.
+
+.. _migration-8.0-memory-full-info:
+
+memory_full_info() is deprecated
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:meth:`Process.memory_full_info` is deprecated. Use
+:meth:`Process.memory_footprint` instead; it returns the same fields
+(:field:`uss`, :field:`pss` and :field:`swap`).
+
+.. _migration-8.0-memory-extras:
+
+New memory_extras() method
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+8.0 introduces a new :meth:`Process.memory_extras` method, returning extra
+platform-specific memory metrics which complement :meth:`Process.memory_info`:
+
+- Linux: :field:`peak_rss`, :field:`peak_vms`, :field:`rss_anon`,
+  :field:`rss_file`, :field:`rss_shmem`, :field:`swap_anon`, :field:`hugetlb`.
+- macOS: :field:`phys_footprint`, :field:`peak_footprint`.
+- Windows: :field:`virtual`, :field:`peak_virtual`, :field:`paged_pool`,
+  :field:`nonpaged_pool`, :field:`peak_paged_pool`,
+  :field:`peak_nonpaged_pool`.
+
+.. _migration-8.0-attrs:
+
+New Process.attrs class attribute
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:attr:`Process.attrs` is a new :class:`frozenset` containing the valid
+attribute names accepted by :meth:`Process.as_dict` and :func:`process_iter`.
+It avoids creating a throwaway process just to discover them:
+
+.. code-block:: python
+
+  # before
+  attrs = list(psutil.Process().as_dict().keys())
+
+  # after
+  attrs = psutil.Process.attrs
+
+It also makes it easy to pass all or a subset of attributes.
+``process_iter(attrs=[])`` (empty list meaning "all") is now deprecated; use
+:attr:`Process.attrs` instead:
+
+.. code-block:: python
+
+  # all attrs
+  psutil.process_iter(attrs=psutil.Process.attrs)
+
+  # all except connections
+  psutil.process_iter(attrs=psutil.Process.attrs - {"net_connections"})
+
+Python 3.6 and 3.7 dropped
+^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The minimum version is now Python 3.8.
+
+.. _migration-8.0-windows:
+
+Windows < 10 dropped
+^^^^^^^^^^^^^^^^^^^^^
+
+Support for Windows Vista, 7, 8, 8.1 and their server counterparts (Server 2008
+to 2012 R2) was removed. The minimum version is now Windows 10 / Windows Server
+2016. The last release supporting older versions is the 7.2.x series. See
+:gh:`2893`.
+
+.. _migration-8.0-git-tags:
+
+Git tags renamed
+^^^^^^^^^^^^^^^^^
+
+Git tags were renamed from ``release-X.Y.Z`` to ``vX.Y.Z`` (e.g.
+``release-7.2.2`` → ``v7.2.2``). Old tags remain for backward compatibility. If
+your scripts or URLs reference psutil tags, update them to the new format. See
+:gh:`2788`.
+
+-------------------------------------------------------------------------------
+
+.. _migration-7.0:
+
+Migrating to 7.0
+-----------------
+
+Process.memory_info_ex() removed
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``Process.memory_info_ex()``, deprecated since 4.0.0 in 2016, was removed. Use
+:meth:`Process.memory_full_info` instead.
+
+.. code-block:: python
+
+  # before
+  p.memory_info_ex()
+
+  # after
+  p.memory_full_info()
+
+Python 2.7 dropped
+^^^^^^^^^^^^^^^^^^^^
+
+Python 2.7 is no longer supported. The last release supporting it is psutil
+6.1.x:
+
+.. code-block:: bash
+
+  pip2 install "psutil==6.1.*"
+
+-------------------------------------------------------------------------------
+
+.. _migration-6.0:
+
+Migrating to 6.0
+-----------------
+
+Process.connections() renamed
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:meth:`Process.connections` was renamed to :meth:`Process.net_connections` for
+consistency with the system-level :func:`net_connections`. The old name raises
+:exc:`DeprecationWarning` and will be removed in a future release:
+
+.. code-block:: python
+
+  # before
+  p.connections()
+  p.connections(kind="tcp")
+
+  # after
+  p.net_connections()
+  p.net_connections(kind="tcp")
+
+disk_partitions() lost two fields
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+The :field:`maxfile` and :field:`maxpath` fields were removed from the named
+tuple returned by :func:`disk_partitions`. Positional unpacking will break:
+
+.. code-block:: python
+
+  # before (broken)
+  device, mountpoint, fstype, opts, maxfile, maxpath = part
+
+  # after
+  device, mountpoint, fstype, opts = (
+      part.device, part.mountpoint, part.fstype, part.opts
+  )
+
+process_iter() no longer checks for PID reuse
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+:func:`process_iter` no longer preemptively checks whether yielded PIDs have
+been reused, making it ~20× faster. To verify that a process object is still
+alive and refers to the same process, use :meth:`Process.is_running`
+explicitly:
+
+.. code-block:: python
+
+  for p in psutil.process_iter(["name"]):
+      if p.is_running():
+          print(p.pid, p.name())
diff --git a/docs/performance.rst b/docs/performance.rst
new file mode 100644
index 0000000000..3cb4af6302
--- /dev/null
+++ b/docs/performance.rst
@@ -0,0 +1,278 @@
+Performance
+===========
+
+This page describes how to use psutil efficiently.
+
+.. _perf-oneshot:
+
+Use oneshot() when reading multiple process attributes
+------------------------------------------------------
+
+If you're dealing with a single :class:`Process` instance and need to retrieve
+multiple process attributes, use :meth:`Process.oneshot`. Each method call
+issues a separate system call, but the OS often returns multiple attributes at
+once, which :meth:`Process.oneshot` caches for subsequent calls.
+
+Slow:
+
+.. code-block:: python
+
+  import psutil
+
+  p = psutil.Process()
+  p.name()           # syscall
+  p.cpu_times()      # syscall
+  p.memory_info()    # syscall
+  p.status()         # syscall
+
+Fast:
+
+.. code-block:: python
+
+  import psutil
+
+  p = psutil.Process()
+  with p.oneshot():
+      p.name()         # one syscall, result cached
+      p.cpu_times()    # from cache
+      p.memory_info()  # from cache
+      p.status()       # from cache
+
+The speed improvement depends on the platform and on how many attributes you
+read. On Linux the gain is typically around 1.5x–2x; on Windows it can be much
+higher. As a rule of thumb: if you read more than one attribute from the same
+process, use :meth:`Process.oneshot`.
+
+.. _perf-process-iter:
+
+Use process_iter() with an attrs list
+--------------------------------------
+
+If you iterate over multiple PIDs, always use :func:`process_iter`. It accepts
+an ``attrs`` argument that pre-fetches only the requested attributes in a
+single pass, minimizing system calls by fetching multiple attributes at once.
+This is faster than calling individual methods in a loop.
+
+Slow:
+
+.. code-block:: python
+
+  import psutil
+
+  for p in psutil.process_iter():
+      try:
+          print(p.pid, p.name(), p.status())
+      except (psutil.NoSuchProcess, psutil.AccessDenied):
+          pass
+
+Fast:
+
+.. code-block:: python
+
+  import psutil
+
+  for p in psutil.process_iter(["name", "status"]):
+      print(p.pid, p.name(), p.status())  # return cached values, never raise
+
+:func:`process_iter(attrs=...) <psutil.process_iter>` is effectively equivalent
+to using :meth:`Process.oneshot` on each process. Using :func:`process_iter`
+also saves you from **race conditions** (e.g. if a process disappears while
+iterating), since :exc:`NoSuchProcess` and :exc:`AccessDenied` exceptions are
+handled internally. A typical use case is to fetch all process attrs except the
+slow ones (see :ref:`perf-api-speed` table below):
+
+.. code-block:: python
+
+  import psutil
+
+  for p in psutil.process_iter(psutil.Process.attrs - {"memory_footprint", "memory_maps"}):
+      ...
+
+.. _perf-oneshot-methods:
+
+Methods sped up by oneshot()
+----------------------------
+
+Here's a list of method groups for each platform which can benefit from
+:meth:`Process.oneshot`. Methods in each group (in the same comma-separated
+list) share the same underlying system call.
+
+The *speedup* represents the estimated gain when all listed methods are called
+together (best case), as measured by :src:`scripts/internal/bench_oneshot.py`.
+
+Additionally, some methods are computed from other methods, so on every
+platform :meth:`Process.oneshot` also speeds up :meth:`~Process.cpu_percent`
+(from :meth:`~Process.cpu_times`), :meth:`~Process.memory_percent` (from
+:meth:`~Process.memory_info`), :meth:`~Process.parent` and
+:meth:`~Process.parents` (from :meth:`~Process.ppid`) and, on POSIX,
+:meth:`~Process.username` (from :meth:`~Process.uids`).
+
+Linux
+"""""
+
+*   :meth:`~Process.cpu_num`, :meth:`~Process.cpu_times`,
+    :meth:`~Process.create_time`, :meth:`~Process.name`,
+    :meth:`~Process.page_faults`, :meth:`~Process.ppid`,
+    :meth:`~Process.status`, :meth:`~Process.terminal`
+
+*   :meth:`~Process.gids`, :meth:`~Process.memory_extras`,
+    :meth:`~Process.num_ctx_switches`, :meth:`~Process.num_threads`,
+    :meth:`~Process.uids`
+
+*   :meth:`~Process.memory_footprint`, :meth:`~Process.memory_maps`
+
+*Speedup: +1.7×*
+
+Windows
+"""""""
+
+*  :meth:`~Process.cpu_times`, :meth:`~Process.io_counters`,
+   :meth:`~Process.memory_info`, :meth:`~Process.memory_extras`,
+   :meth:`~Process.num_ctx_switches`, :meth:`~Process.num_handles`,
+   :meth:`~Process.num_threads`, :meth:`~Process.page_faults`,
+   :meth:`~Process.status`
+
+*  :meth:`~Process.exe`, :meth:`~Process.name`
+
+Some of these first try a faster dedicated call, and only use the shared one if
+it raises :exc:`AccessDenied`. The second figure is for such processes.
+
+*Speedup: +1.8× / +6.5×*
+
+macOS
+"""""
+
+*  :meth:`~Process.cpu_times`, :meth:`~Process.memory_info`,
+   :meth:`~Process.num_ctx_switches`, :meth:`~Process.num_threads`,
+   :meth:`~Process.page_faults`
+
+*  :meth:`~Process.create_time`, :meth:`~Process.gids`, :meth:`~Process.name`,
+   :meth:`~Process.ppid`, :meth:`~Process.status`, :meth:`~Process.terminal`,
+   :meth:`~Process.uids`
+
+*Speedup: +1.6×*
+
+BSD
+"""
+
+*  :meth:`~Process.cpu_num`, :meth:`~Process.cpu_times`,
+   :meth:`~Process.create_time`, :meth:`~Process.gids`,
+   :meth:`~Process.io_counters`, :meth:`~Process.memory_info`,
+   :meth:`~Process.name`, :meth:`~Process.nice`,
+   :meth:`~Process.num_ctx_switches`, :meth:`~Process.page_faults`,
+   :meth:`~Process.ppid`, :meth:`~Process.status`, :meth:`~Process.terminal`,
+   :meth:`~Process.uids`
+
+*Speedup: +2.7×*
+
+.. _perf-oneshot-bench:
+
+Measuring oneshot() speedup
+---------------------------
+
+:src:`scripts/internal/bench_oneshot.py` measures :meth:`Process.oneshot`
+speedup. It also shows which APIs share the same internal kernel routines. E.g.
+on Linux:
+
+.. code-block:: none
+
+  $ python3 scripts/internal/bench_oneshot.py --times 10000
+  17 methods pre-fetched by oneshot() on platform 'linux' (10,000 times, psutil 8.0.0):
+
+    cpu_num
+    cpu_percent
+    cpu_times
+    gids
+    memory_extras
+    memory_info
+    memory_percent
+    name
+    num_ctx_switches
+    num_threads
+    page_faults
+    parent
+    ppid
+    status
+    terminal
+    uids
+    username
+
+  regular:  2.600 secs
+  oneshot:  1.499 secs
+  speedup:  +1.73x
+
+.. _perf-api-speed:
+
+Measuring APIs speed
+--------------------
+
+:src:`scripts/internal/print_api_speed.py` shows the relative cost of each API
+call. This helps you understand which operations are more expensive. E.g. on
+Linux:
+
+.. code-block:: none
+
+  $ python3 scripts/internal/print_api_speed.py
+  SYSTEM APIS                NUM CALLS      SECONDS
+  -------------------------------------------------
+  getloadavg                       300      0.00013
+  heap_info                        300      0.00028
+  heap_trim                        300      0.00039
+  cpu_count                        300      0.00061
+  disk_usage                       300      0.00066
+  pid_exists                       300      0.00235
+  users                            300      0.00455
+  net_io_counters                  300      0.00550
+  cpu_times                        300      0.00667
+  boot_time                        300      0.00700
+  cpu_percent                      300      0.00766
+  net_if_stats                     300      0.00783
+  virtual_memory                   300      0.00834
+  cpu_times_percent                300      0.00885
+  net_if_addrs                     300      0.01157
+  cpu_stats                        300      0.01208
+  swap_memory                      300      0.01558
+  disk_partitions                  300      0.01664
+  disk_io_counters                 300      0.02204
+  sensors_battery                  300      0.02995
+  pids                             300      0.05295
+  cpu_count (cores)                300      0.06943
+  process_iter (all)               300      0.08486
+  cpu_freq                         300      0.18987
+  sensors_fans                     300      0.74027
+  net_connections                  161      2.00690
+  sensors_temperatures             100      2.00742
+
+  PROCESS APIS               NUM CALLS      SECONDS
+  -------------------------------------------------
+  exe                              300      0.00017
+  create_time                      300      0.00020
+  nice                             300      0.00025
+  ionice                           300      0.00041
+  cwd                              300      0.00052
+  cpu_affinity                     300      0.00059
+  num_fds                          300      0.00097
+  memory_info                      300      0.00201
+  cmdline                          300      0.00222
+  io_counters                      300      0.00226
+  cpu_num                          300      0.00242
+  status                           300      0.00242
+  terminal                         300      0.00243
+  name                             300      0.00249
+  page_faults                      300      0.00258
+  memory_percent                   300      0.00259
+  cpu_times                        300      0.00272
+  threads                          300      0.00278
+  num_threads                      300      0.00278
+  gids                             300      0.00296
+  num_ctx_switches                 300      0.00299
+  uids                             300      0.00311
+  cpu_percent                      300      0.00346
+  net_connections                  300      0.00373
+  open_files                       300      0.00378
+  memory_extras                    300      0.00398
+  username                         300      0.00500
+  ppid                             300      0.00556
+  environ                          300      0.01176
+  memory_footprint                 300      0.02218
+  memory_maps                      300      0.27158
diff --git a/docs/platform.rst b/docs/platform.rst
new file mode 100644
index 0000000000..cb6676aaf6
--- /dev/null
+++ b/docs/platform.rst
@@ -0,0 +1,243 @@
+Platform support
+================
+
+Python
+^^^^^^
+
+.. list-table::
+   :class: wide-table
+   :header-rows: 1
+
+   * - Feature
+     - Support
+     - Notes
+   * - Minimum Python version
+     - 3.8
+     - last version supporting 3.6 / 3.7 is
+       `psutil 7.2.2 <https://pypi.org/project/psutil/7.2.2/>`_ (Jan 2026)
+   * - PyPy
+     - yes
+     - not tested on CI
+   * - Free-threaded Python
+     - yes
+     - ``cp314t`` wheels are published
+   * - Stable ABI (abi3)
+     - yes
+     - ``cp38-abi3`` wheels support CPython 3.8+
+   * - Inline type hints
+     - yes
+     -
+   * - Sub-interpreters
+     - partial
+     - legacy shared-GIL sub-interpreters work; ``concurrent.interpreters``
+       does not (:gh:`2576`)
+   * - PEP 561 (``py.typed``)
+     - no
+     -
+   * - Python 2.7
+     - no
+     - last version supporting it is
+       `psutil 6.1.1 <https://pypi.org/project/psutil/6.1.1/>`_ (Dec 2024)
+
+Operating systems
+^^^^^^^^^^^^^^^^^
+
+.. list-table::
+   :class: wide-table
+   :header-rows: 1
+
+   * - Platform
+     - Minimum version
+     - Released
+     - Enforcement
+     - CI coverage
+   * - Linux
+     - 2.6.13 (soft)
+     - 2005
+     - graceful fallbacks; no hard check
+     - yes
+   * - Windows
+     - 10
+     - 2015
+     - hard check at import and build time
+     - yes
+   * - macOS
+     - 10.9 (Mavericks)
+     - 2013
+     - graceful fallbacks; no hard check
+     - yes
+   * - FreeBSD
+     - 12.0
+     - 2018
+     - graceful fallbacks via ``#if __FreeBSD_version``
+     - yes
+   * - NetBSD
+     - 5.0
+     - 2009
+     - graceful fallbacks via ``#if __NetBSD_Version__``
+     - yes
+   * - OpenBSD
+     - unknown
+     -
+     -
+     - yes
+   * - SunOS / Solaris
+     - 11
+     - 2011
+     -
+     - memleak tests only
+   * - AIX
+     - unknown
+     -
+     -
+     - no
+
+Except where a hard minimum is enforced, older releases may also work but are
+not guaranteed to be supported.
+
+The minimum above is what the source builds against. Prebuilt macOS wheels
+target 10.15, so 10.9 to 10.14 need to build from source.
+
+Architectures
+^^^^^^^^^^^^^
+
+.. list-table::
+   :class: wide-table
+   :header-rows: 1
+
+   * - Architecture
+     - CI coverage
+     - Prebuilt wheels
+     - Manual testing
+   * - x86_64
+     - Linux, Windows, macOS
+     - Linux, Windows, macOS
+     -
+   * - aarch64 / ARM64
+     - Linux, Windows, macOS
+     - Linux, Windows, macOS
+     -
+   * - ppc64le
+     -
+     - Linux
+     - Debian 13
+   * - s390x
+     -
+     - Linux
+     -
+   * - i686
+     -
+     -
+     - Debian 13
+   * - ppc64 (big endian)
+     -
+     -
+     - Debian 14
+   * - riscv64
+     -
+     -
+     - Debian 13
+   * - sparc64
+     -
+     -
+     - Debian 14
+
+Occasional manual testing is done on the
+`GCC compile farm <https://portal.cfarm.net/>`_, which provides free shell
+access to uncommon hardware.
+
+On architectures without prebuilt wheels, psutil can be installed from source
+(see :ref:`install_from_source`):
+
+.. code-block:: bash
+
+   pip install psutil --no-binary psutil
+
+Linux wheels are published for both glibc (manylinux) and musl. The musl ones
+cover x86_64 and aarch64 only.
+
+Support history
+^^^^^^^^^^^^^^^
+
+.. list-table::
+   :class: wide-table
+   :header-rows: 1
+
+   * - Version
+     - Date
+     - Change
+   * - :pypi:`8.0.0`
+     -
+     - add wheels for Linux ppc64le and s390x architectures
+   * - :pypi:`8.0.0`
+     -
+     - drop Python 3.6 and 3.7
+   * - :pypi:`8.0.0`
+     -
+     - drop PyPy older than 7.3.14 on Windows
+   * - :pypi:`8.0.0`
+     -
+     - drop Windows Vista, 7, 8 and 8.1 (+ Server 2008 to 2012 R2)
+   * - :pypi:`8.0.0`
+     -
+     - drop Intel wheel support for macOS < 10.15
+   * - :pypi:`8.0.0`
+     -
+     - drop wheels for free-threaded Python 3.13
+   * - :pypi:`7.2.0`
+     - 2025-12
+     - drop wheels for Linux musl
+   * - :pypi:`7.1.2`
+     - 2025-10
+     - drop wheels for free-threaded Python
+   * - :pypi:`7.1.2`
+     - 2025-10
+     - drop wheels for 32-bit Python (Linux and Windows)
+   * - :pypi:`7.1.1`
+     - 2025-10
+     - drop SunOS 10
+   * - :pypi:`7.1.0`
+     - 2025-09
+     - drop FreeBSD 8
+   * - :pypi:`7.0.0`
+     - 2025-02
+     - drop Python 2.7
+   * - :pypi:`5.9.6`
+     - 2023-10
+     - drop Python 3.4 and 3.5
+   * - :pypi:`5.9.1`
+     - 2022-05
+     - drop Python 2.6
+   * - :pypi:`5.9.0`
+     - 2021-12
+     - add MidnightBSD
+   * - :pypi:`5.8.0`
+     - 2020-12
+     - add PyPy2 on Windows
+   * - :pypi:`5.7.1`
+     - 2020-07
+     - add Windows Nano
+   * - :pypi:`5.7.0`
+     - 2020-02
+     - drop Windows XP & Windows Server 2003
+   * - :pypi:`5.7.0`
+     - 2020-02
+     - add PyPy3 on Windows
+   * - :pypi:`5.4.0`
+     - 2017-11
+     - add AIX
+   * - :pypi:`3.4.1`
+     - 2016-01
+     - add NetBSD
+   * - :pypi:`3.3.0`
+     - 2015-11
+     - add OpenBSD
+   * - :pypi:`1.0.0`
+     - 2013-07
+     - add Solaris
+   * - :pypi:`0.1.1`
+     - 2009-03
+     - add FreeBSD
+   * - :pypi:`0.1.0`
+     - 2009-01
+     - add Linux, Windows, macOS
diff --git a/docs/recipes.rst b/docs/recipes.rst
new file mode 100644
index 0000000000..249e370d46
--- /dev/null
+++ b/docs/recipes.rst
@@ -0,0 +1,550 @@
+Recipes
+=======
+
+A collection of standalone, copy-paste solutions to specific problems. Each
+recipe focuses on a single problem and provides a minimal solution which can be
+adapted to real-world code. The examples are intentionally short and avoid
+unnecessary abstractions so that the underlying psutil APIs are easy to
+understand. Most of them are not meant to be used in production.
+
+Processes
+---------
+
+Finding processes
+^^^^^^^^^^^^^^^^^
+
+.. _recipe_find_process_by_name:
+
+Find process by name:
+
+.. code-block:: python
+
+  import psutil
+
+  def find_procs_by_name(name):
+      ls = []
+      for p in psutil.process_iter(["name"]):
+          if p.name() == name:
+              ls.append(p)
+      return ls
+
+-------------------------------------------------------------------------------
+
+A bit more advanced, check string against :meth:`Process.name`,
+:meth:`Process.exe` and :meth:`Process.cmdline`:
+
+.. code-block:: python
+
+  import os, psutil
+
+  def find_procs_by_name_ex(name):
+      ls = []
+      for p in psutil.process_iter(["name", "exe", "cmdline"]):
+          if (
+              name == p.name()
+              or (p.exe() and os.path.basename(p.exe()) == name)
+              or (p.cmdline() and p.cmdline()[0] == name)
+          ):
+              ls.append(p)
+      return ls
+
+-------------------------------------------------------------------------------
+
+Find the process listening on a given TCP port:
+
+.. code-block:: python
+
+  import psutil
+
+  def find_proc_by_port(port):
+      for proc in psutil.process_iter():
+          try:
+              cons = proc.net_connections(kind="tcp")
+          except psutil.Error:
+              pass
+          else:
+              for conn in cons:
+                  if conn.laddr.port == port and conn.status == psutil.CONN_LISTEN:
+                      return proc
+      return None
+
+-------------------------------------------------------------------------------
+
+Find all processes that have an active connection to a given remote IP:
+
+.. code-block:: python
+
+  import psutil
+
+  def find_procs_by_remote_host(host):
+      ls = []
+      for proc in psutil.process_iter():
+          try:
+              cons = proc.net_connections(kind="inet")
+          except psutil.Error:
+              pass
+          else:
+              for conn in cons:
+                  if conn.raddr and conn.raddr.ip == host:
+                      ls.append(proc)
+      return ls
+
+-------------------------------------------------------------------------------
+
+Find all processes that have a given file open (useful on Windows):
+
+.. code-block:: python
+
+  import psutil
+
+  def find_procs_using_file(path):
+      ls = []
+      for p in psutil.process_iter(["open_files"]):
+          for f in p.open_files() or []:
+              if f.path == path:
+                  ls.append(p)
+                  break
+      return ls
+
+Filtering and sorting processes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Processes owned by user:
+
+.. code-block:: python
+
+  import getpass, psutil
+
+  def procs_by_user(user=None):
+      if user is None:
+          user = getpass.getuser()
+      return [
+          (p.pid, p.name())
+          for p in psutil.process_iter(["name", "username"])
+          if p.username() == user
+      ]
+
+-------------------------------------------------------------------------------
+
+Processes using log files:
+
+.. code-block:: pycon
+
+  >>> for p in psutil.process_iter(["name", "open_files"]):
+  ...      for file in p.open_files() or []:
+  ...          if file.path.endswith(".log"):
+  ...               print("{:<5} {:<10} {}".format(p.pid, p.name()[:10], file.path))
+  ...
+  1510  upstart    /home/giampaolo/.cache/upstart/unity-settings-daemon.log
+  2174  nautilus   /home/giampaolo/.local/share/gvfs-metadata/home-ce08efac.log
+  2650  chrome     /home/giampaolo/.config/google-chrome/Default/data_reduction_proxy_leveldb/000003.log
+
+-------------------------------------------------------------------------------
+
+Processes consuming more than 500M of memory:
+
+.. code-block:: python
+
+  import psutil
+
+  def procs_by_memory(min_bytes=500 * 1024 * 1024):
+      return [
+          (p.pid, p.name(), p.memory_info().rss)
+          for p in psutil.process_iter(["name", "memory_info"])
+          if p.memory_info().rss > min_bytes
+      ]
+
+-------------------------------------------------------------------------------
+
+Top N processes by :term:`cumulative <cumulative counter>` CPU time:
+
+.. code-block:: python
+
+  import psutil
+
+  def top_cpu_procs(n=3):
+      procs = sorted(
+          psutil.process_iter(["name", "cpu_times"]),
+          key=lambda p: sum(p.cpu_times()[:2]),
+      )
+      return [(p.pid, p.name(), sum(p.cpu_times())) for p in procs[-n:]]
+
+-------------------------------------------------------------------------------
+
+Top N processes by :term:`cumulative <cumulative counter>` disk read + write
+bytes (similar to ``iotop``):
+
+.. code-block:: python
+
+  import psutil
+
+  def top_io_procs(n=5):
+      procs = []
+      for p in psutil.process_iter(["io_counters"]):
+          io = p.io_counters()
+          procs.append((io.read_bytes + io.write_bytes, p))
+      procs.sort(key=lambda x: x[0], reverse=True)
+      return procs[:n]
+
+-------------------------------------------------------------------------------
+
+Top N processes by open file descriptors (useful for diagnosing fd leaks):
+
+.. code-block:: python
+
+  import psutil
+
+  def top_open_files(n=5):
+      procs = []
+      for p in psutil.process_iter(["num_fds"]):
+          procs.append((p.num_fds(), p))
+      procs.sort(key=lambda x: x[0], reverse=True)
+      return procs[:n]
+
+Monitoring processes
+^^^^^^^^^^^^^^^^^^^^
+
+Periodically monitor CPU and memory usage of a process using
+:meth:`Process.oneshot` for efficiency:
+
+.. code-block:: python
+
+  import time, psutil
+
+  def monitor(pid, interval=1):
+      p = psutil.Process(pid)
+      while p.is_running():
+          with p.oneshot():
+              cpu = p.cpu_percent()
+              mem = p.memory_info().rss
+              print("cpu={:<6} mem={}".format(str(cpu) + "%", mem / 1024 / 1024))
+          time.sleep(interval)
+
+.. code-block:: none
+
+  cpu=4.2%   mem=23.4M
+  cpu=3.1%   mem=23.5M
+
+Controlling processes
+^^^^^^^^^^^^^^^^^^^^^
+
+.. _recipe_kill_proc_tree:
+
+Kill a process tree (including grandchildren):
+
+.. code-block:: python
+
+  import os, signal, psutil
+
+  def kill_proc_tree(
+      pid,
+      sig=signal.SIGTERM,
+      include_parent=True,
+      timeout=None,
+      on_terminate=None,
+  ):
+      """Kill a process tree (including grandchildren) with signal
+      "sig" and return a (gone, still_alive) tuple.
+      "on_terminate", if specified, is a callback function which is
+      called as soon as a child terminates.
+      """
+      assert pid != os.getpid(), "I won't kill myself!"
+      parent = psutil.Process(pid)
+      children = parent.children(recursive=True)
+      # Reverse the list so that descendants are killed before
+      # their ancestors (bottom-up order). ``children()`` returns
+      # processes in top-down order; reversing ensures a grandchild
+      # is terminated before its parent.
+      children.reverse()
+      if include_parent:
+          children.append(parent)
+      for p in children:
+          try:
+              p.send_signal(sig)
+          except psutil.NoSuchProcess:
+              pass
+      gone, alive = psutil.wait_procs(
+          children, timeout=timeout, callback=on_terminate
+      )
+      return (gone, alive)
+
+On Unix, if you started the subprocess with ``subprocess.Popen`` you can often
+use the stdlib ``os.killpg()`` instead of this recipe. Create the process with
+``process_group=0`` so that it gets its own process group, then call
+``os.killpg(pgid, sig)``. This is simpler, does not require psutil, and still
+cleans up all descendants even when an intermediate process has exited::
+
+    import os
+    import signal
+    import subprocess
+
+    proc = subprocess.Popen(["cmd", "arg1"], process_group=0)
+    # ... later:
+    os.killpg(proc.pid, signal.SIGTERM)
+
+This approach does not work on Windows (``os.killpg`` is not available) and it
+only works for PIDs that you started yourself as a new process group. For
+arbitrary PIDs, use the psutil recipe above.
+
+-------------------------------------------------------------------------------
+
+Terminate a process gracefully, falling back to ``SIGKILL`` if it does not exit
+within the timeout:
+
+.. code-block:: python
+
+  import psutil
+
+  def graceful_kill(pid, timeout=3):
+      p = psutil.Process(pid)
+      p.terminate()
+      try:
+          p.wait(timeout=timeout)
+      except psutil.TimeoutExpired:
+          p.kill()
+
+-------------------------------------------------------------------------------
+
+Temporarily pause and resume a process using a context manager:
+
+.. code-block:: python
+
+  import contextlib, psutil
+
+  @contextlib.contextmanager
+  def suspended(pid):
+      p = psutil.Process(pid)
+      p.suspend()
+      try:
+          yield p
+      finally:
+          p.resume()
+
+  # usage
+  with suspended(pid):
+      pass  # process is paused here
+
+-------------------------------------------------------------------------------
+
+CPU throttle: limit a process's CPU usage to a target percentage by alternating
+:meth:`Process.suspend` and :meth:`Process.resume`:
+
+.. code-block:: python
+
+  import time, psutil
+
+  def throttle(pid, max_cpu_percent=50, interval=0.1):
+      """Slow down a process so it uses at most max_cpu_percent% CPU."""
+      p = psutil.Process(pid)
+      while p.is_running():
+          cpu = p.cpu_percent(interval=interval)
+          if cpu > max_cpu_percent:
+              p.suspend()
+              time.sleep(interval * cpu / max_cpu_percent)
+              p.resume()
+
+-------------------------------------------------------------------------------
+
+Restart a process automatically if it dies:
+
+.. code-block:: python
+
+  import subprocess, time, psutil
+
+  def watchdog(cmd, max_restarts=None, interval=1):
+      """Run cmd as a persistent process. Restart on failure, optionally
+      with a max restarts. Logs start, exit, and restart events.
+      """
+      restarts = 0
+      while True:
+          proc = subprocess.Popen(cmd)
+          p = psutil.Process(proc.pid)
+          print(f"started PID {p.pid}")
+          proc.wait()
+
+          if proc.returncode == 0:
+              # success
+              print(f"PID {p.pid} exited cleanly")
+              break
+
+          # failure
+          restarts += 1
+          print(f"PID {p.pid} died, restarting ({restarts})")
+
+          if max_restarts is not None and restarts > max_restarts:
+              print("max restarts reached, giving up")
+              break
+
+          time.sleep(interval)
+
+
+  if __name__ == "__main__":
+      watchdog(["python3", "script.py"])
+
+System
+------
+
+All APIs returning amounts (memory, disk, network I/O) express them in bytes.
+The examples below use :func:`psutil.bytes2human` to convert them to a
+human-readable string.
+
+CPU
+^^^
+
+Print real-time CPU usage percentage:
+
+.. code-block:: python
+
+  import psutil
+
+  while True:
+      print("CPU: {}%".format(psutil.cpu_percent(interval=1)))
+
+.. code-block:: none
+
+  CPU: 2.1%
+  CPU: 1.4%
+  CPU: 0.9%
+
+Memory
+^^^^^^
+
+.. _recipe_swap_activity:
+
+Show real-time swap activity *(Linux, BSD)*. ``sout`` (:term:`swap-out`) is the
+key metric: a non-zero and growing rate means the OS is moving memory from RAM
+to disk because RAM is full. ``sin`` (:term:`swap-in`) alone is not alarming;
+it just means the system is moving previously evicted pages back into RAM. High
+``sin`` and ``sout`` together may indicate heavy swapping (:term:`thrashing`).
+
+.. code-block:: python
+
+  import psutil, time
+
+  def swap_activity(interval=1):
+      before = psutil.swap_memory()
+      while True:
+          time.sleep(interval)
+          after = psutil.swap_memory()
+          sin  = after.sin  - before.sin
+          sout = after.sout - before.sout
+          print("swap-in={}/s  swap-out={}/s  used={}%".format(
+              psutil.bytes2human(sin), psutil.bytes2human(sout), after.percent))
+          before = after
+
+.. code-block:: none
+
+  swap-in=0.0B/s  swap-out=0.0B/s  used=23%
+  swap-in=0.0B/s  swap-out=1.2M/s  used=24%
+
+Disks
+^^^^^
+
+.. _recipe_disk_io:
+
+Show real-time disk I/O:
+
+.. code-block:: python
+
+  import psutil, time
+
+  def disk_io():
+      while True:
+          before = psutil.disk_io_counters()
+          time.sleep(1)
+          after = psutil.disk_io_counters()
+          r = after.read_bytes - before.read_bytes
+          w = after.write_bytes - before.write_bytes
+          print("Read: {}/s, Write: {}/s".format(
+              psutil.bytes2human(r),
+              psutil.bytes2human(w))
+          )
+
+.. code-block:: none
+
+  Read: 1.2M/s, Write: 256.0K/s
+  Read: 0.0B/s, Write: 128.0K/s
+
+-------------------------------------------------------------------------------
+
+.. _recipe_disk_io_percent:
+
+Show real-time disk utilization percentage *(Linux, FreeBSD)*:
+
+.. code-block:: python
+
+  import psutil, time
+
+  def disk_io_percent(interval=1):
+      while True:
+          before = psutil.disk_io_counters()
+          time.sleep(interval)
+          after = psutil.disk_io_counters()
+          busy_ms = after.busy_time - before.busy_time
+          util = min(busy_ms / (interval * 1000) * 100, 100)
+          print("Disk: {:.1f}%".format(util))
+
+.. code-block:: none
+
+  Disk: 3.2%
+  Disk: 78.5%
+
+Network
+^^^^^^^
+
+Show real-time network I/O per interface:
+
+.. code-block:: python
+
+  import psutil, time
+
+  def net_io():
+      while True:
+          before = psutil.net_io_counters(pernic=True)
+          time.sleep(1)
+          after = psutil.net_io_counters(pernic=True)
+          for iface in after:
+              s = after[iface].bytes_sent - before[iface].bytes_sent
+              r = after[iface].bytes_recv - before[iface].bytes_recv
+              print(
+                  "{:<10} sent={:<10} recv={}".format(
+                      iface,
+                      psutil.bytes2human(s) + "/s",
+                      psutil.bytes2human(r) + "/s"
+                  )
+              )
+          print()
+
+.. code-block:: none
+
+  lo         sent=0.0B/s    recv=0.0B/s
+  eth0       sent=12.3K/s   recv=45.6K/s
+
+-------------------------------------------------------------------------------
+
+List all active TCP connections with their status:
+
+.. code-block:: python
+
+  import psutil
+
+  def netstat():
+      templ = "{:<20} {:<20} {:<13} {:<6}"
+      print(templ.format("Local", "Remote", "Status", "PID"))
+      for conn in psutil.net_connections(kind="tcp"):
+          laddr = "{}:{}".format(conn.laddr.ip, conn.laddr.port)
+          raddr = (
+              "{}:{}".format(conn.raddr.ip, conn.raddr.port)
+              if conn.raddr
+              else "-"
+          )
+          print(templ.format(laddr, raddr, conn.status, conn.pid or ""))
+
+.. code-block:: none
+
+  Local             Remote              Status        PID
+  :::1716           -                   LISTEN        223441
+  127.0.0.1:631     -                   LISTEN
+  10.0.0.4:45278    20.222.111.74:443   ESTABLISHED   437213
+  10.0.0.4:40130    172.14.148.135:443  ESTABLISHED
+  0.0.0.0:22        -                   LISTEN        723345
diff --git a/docs/shell-equivalents.rst b/docs/shell-equivalents.rst
new file mode 100644
index 0000000000..d3ad4bbd8c
--- /dev/null
+++ b/docs/shell-equivalents.rst
@@ -0,0 +1,580 @@
+Shell equivalents
+=================
+
+This page maps psutil's Python API to the equivalent native terminal commands
+on each platform. This is useful for understanding what psutil replaces and for
+cross-checking results.
+
+.. seealso::
+   - :doc:`stdlib-equivalents`
+   - :doc:`alternatives`
+
+System-wide functions
+---------------------
+
+CPU
+~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil function
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :func:`cpu_percent`
+     - ``top``
+     - same
+     - same
+     -
+   * - :func:`cpu_count(logical=True) <cpu_count>`
+     - ``nproc``
+     - ``sysctl hw.logicalcpu``
+     - ``sysctl hw.ncpu``
+     -
+   * - :func:`cpu_count(logical=False) <cpu_count>`
+     - ``lscpu | grep '^Core(s)'``
+     - ``sysctl hw.physicalcpu``
+     -
+     -
+   * - :func:`cpu_times(percpu=False) <cpu_times>`
+     - ``cat /proc/stat | grep '^cpu\s'``
+     -
+     - ``systat -vmstat``
+     -
+   * - :func:`cpu_times(percpu=True) <cpu_times>`
+     - ``cat /proc/stat | grep '^cpu'``
+     -
+     - ``systat -vmstat``
+     -
+   * - :func:`cpu_times_percent(percpu=False) <cpu_times_percent>`
+     - ``mpstat``
+     -
+     -
+     -
+   * - :func:`cpu_times_percent(percpu=True) <cpu_times_percent>`
+     - ``mpstat -P ALL``
+     -
+     -
+     -
+   * - :func:`cpu_freq`
+     - ``cpufreq-info``, ``lscpu | grep "MHz"``
+     - ``sysctl hw.cpufrequency``
+     - ``sysctl dev.cpu.0.freq``
+     - ``systeminfo``
+   * - :func:`cpu_stats`
+     -
+     -
+     - ``vmstat -s``, ``sysctl vm.stats.sys``
+     -
+   * - :func:`getloadavg`
+     - ``uptime``
+     - same
+     - same
+     -
+
+Memory
+~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil function
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :func:`virtual_memory`
+     - ``free``, ``vmstat``, ``cat /proc/meminfo``
+     - ``vm_stat``
+     - ``vmstat -s``, ``sysctl vm.stats``
+     - ``systeminfo``
+   * - :func:`swap_memory`
+     - ``free``, ``vmstat``, ``swapon``
+     - ``sysctl vm.swapusage``
+     - ``vmstat -s``, ``swapinfo``
+     -
+   * - :func:`heap_info`
+     -
+     -
+     -
+     -
+   * - :func:`heap_trim`
+     -
+     -
+     -
+     -
+
+Disks
+~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil function
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :func:`disk_usage`
+     - ``df``
+     - same
+     - same
+     - ``fsutil volume diskfree C:\``
+   * - :func:`disk_partitions`
+     - ``mount``, ``findmnt``
+     - ``mount``
+     - ``mount``
+     -
+   * - :func:`disk_io_counters`
+     - ``iostat -dx``
+     - ``iostat``
+     - ``iostat -x``
+     -
+
+Network
+~~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil function
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :func:`net_connections`
+     - ``netstat -anp``, ``ss``, ``lsof -nP -i -U``
+     - ``netstat -anp``
+     - ``netstat -an``
+     - ``netstat -an``
+   * - :func:`net_if_addrs`
+     - ``ifconfig``, ``ip addr``
+     - ``ifconfig``
+     - ``ifconfig``
+     - ``ipconfig``, ``systeminfo``
+   * - :func:`net_io_counters`
+     - ``netstat -i``, ``ifconfig``, ``ip -s link``
+     - ``netstat -i``
+     - ``netstat -i``
+     - ``netstat -e``
+   * - :func:`net_if_stats`
+     - ``ifconfig``, ``ip -br link``, ``ip link``
+     - ``ifconfig``
+     - ``ifconfig``
+     - ``netsh interface show interface``
+
+Sensors
+~~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil function
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :func:`sensors_temperatures`
+     - ``sensors``
+     -
+     - ``sysctl dev.cpu.*.temperature``
+     -
+   * - :func:`sensors_fans`
+     - ``sensors``
+     -
+     - ``sysctl dev.cpu.*.fan``
+     -
+   * - :func:`sensors_battery`
+     - ``acpi -b``
+     - ``pmset -g batt``
+     - ``apm -b``
+     -
+
+Other
+~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil function
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :func:`boot_time`
+     - ``uptime``, ``who -b``
+     - ``sysctl kern.boottime``
+     - ``sysctl kern.boottime``
+     - ``systeminfo``
+   * - :func:`users`
+     - ``who -a``, ``w``
+     - same
+     - same
+     -
+   * - :func:`pids`
+     - ``ps -A -eo pid``
+     - same
+     - same
+     - ``tasklist``
+   * - :func:`pid_exists`
+     - ``kill -0 PID``
+     - same
+     - same
+     -
+
+Process methods
+---------------
+
+Assuming ``p = psutil.Process()``.
+
+Identity
+~~~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil method
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :meth:`p.name() <Process.name>`
+     - ``ps -o comm -p PID``
+     - same
+     - ``procstat -b PID``
+     -
+   * - :meth:`p.exe() <Process.exe>`
+     - ``readlink /proc/pid/exe``
+     - ``lsof -p PID``
+     - ``procstat -b PID``
+     -
+   * - :meth:`p.cmdline() <Process.cmdline>`
+     - ``ps -o args -p PID``
+     - same
+     - ``procstat -c PID``
+     -
+   * - :meth:`p.status() <Process.status>`
+     - ``ps -o stat -p PID``
+     - same
+     - same
+     -
+   * - :meth:`p.create_time() <Process.create_time>`
+     - ``ps -o lstart -p PID``
+     - same
+     - same
+     -
+   * - :meth:`p.is_running() <Process.is_running>`
+     - ``kill -0 PID``
+     - same
+     - same
+     -
+   * - :meth:`p.environ() <Process.environ>`
+     - ``xargs -0 -a /proc/pid/environ``
+     -
+     - ``procstat -e PID``
+     -
+   * - :meth:`p.cwd() <Process.cwd>`
+     - ``pwdx PID``
+     - ``lsof -p PID -a -d cwd``
+     -
+     -
+
+Process tree
+~~~~~~~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil method
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :meth:`p.ppid() <Process.ppid>`
+     - ``ps -o ppid= -p PID``
+     - same
+     - same
+     -
+   * - :meth:`p.parent() <Process.parent>`
+     - ``ps -p $(ps -o ppid= -p PID)``
+     - same
+     - same
+     -
+   * - :meth:`p.parents() <Process.parents>`
+     - ``pstree -s PID``
+     - same
+     - same
+     -
+   * - :meth:`p.children(recursive=False) <Process.children>`
+     - ``pgrep -P PID``
+     - same
+     - same
+     -
+   * - :meth:`p.children(recursive=True) <Process.children>`
+     - ``pstree -p PID``
+     - same
+     - same
+     -
+
+Credentials
+~~~~~~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil method
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :meth:`p.uids() <Process.uids>`
+     - ``ps -o uid,ruid,suid -p PID``
+     - same
+     - ``procstat -s PID``
+     -
+   * - :meth:`p.gids() <Process.gids>`
+     - ``ps -o gid,rgid,sgid -p PID``
+     - same
+     - ``procstat -s PID``
+     -
+   * - :meth:`p.username() <Process.username>`
+     - ``ps -o user -p PID``
+     - same
+     - same
+     -
+   * - :meth:`p.terminal() <Process.terminal>`
+     - ``ps -o tty -p PID``
+     - same
+     - same
+     -
+
+CPU / scheduling
+~~~~~~~~~~~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil method
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :meth:`p.cpu_percent() <Process.cpu_percent>`
+     - ``ps -o %cpu -p PID``
+     - same
+     - same
+     -
+   * - :meth:`p.cpu_times() <Process.cpu_times>`
+     - ``ps -o cputime -p PID``
+     - same
+     - ``procstat -r PID``
+     -
+   * - :meth:`p.cpu_num() <Process.cpu_num>`
+     - ``ps -o psr -p PID``
+     -
+     -
+     -
+   * - :meth:`p.num_ctx_switches() <Process.num_ctx_switches>`
+     - ``pidstat -w -p PID``
+     -
+     - ``procstat -r PID``
+     -
+   * - :meth:`p.cpu_affinity() <Process.cpu_affinity>`
+     - ``taskset -p PID``
+     -
+     - ``cpuset -g -p PID``
+     -
+   * - :meth:`p.cpu_affinity(CPUS) <Process.cpu_affinity>`
+     - ``taskset -p MASK PID``
+     -
+     - ``cpuset -s -p PID -l CPUS``
+     -
+   * - :meth:`p.ionice() <Process.ionice>`
+     - ``ionice -p PID``
+     -
+     -
+     -
+   * - :meth:`p.ionice(CLASS) <Process.ionice>`
+     - ``ionice -c CLASS -p PID``
+     -
+     -
+     -
+   * - :meth:`p.nice() <Process.nice>`
+     - ``ps -o nice -p PID``
+     - same
+     - same
+     -
+   * - :meth:`p.nice(VALUE) <Process.nice>`
+     - ``renice -n VALUE -p PID``
+     - same
+     - same
+     -
+   * - :meth:`p.rlimit(RES) <Process.rlimit>`
+     - ``prlimit --pid PID``
+     -
+     - ``procstat rlimit PID``
+     -
+   * - :meth:`p.rlimit(RES, LIMITS) <Process.rlimit>`
+     - ``prlimit --pid PID --RES=SOFT:HARD``
+     -
+     -
+     -
+
+Memory
+~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil method
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :meth:`p.memory_info() <Process.memory_info>`
+     - ``ps -o rss,vsz -p PID``
+     - same
+     - same
+     -
+   * - :meth:`p.memory_extras() <Process.memory_extras>`
+     - ``cat /proc/pid/status``
+     -
+     -
+     -
+   * - :meth:`p.memory_percent() <Process.memory_percent>`
+     - ``ps -o %mem -p PID``
+     - same
+     - same
+     -
+   * - :meth:`p.memory_maps() <Process.memory_maps>`
+     - ``pmap PID``
+     - ``vmmap PID``
+     - ``procstat -v PID``
+     -
+   * - :meth:`p.memory_footprint() <Process.memory_footprint>`
+     - ``smem``, ``smemstat``
+     -
+     -
+     -
+   * - :meth:`p.page_faults() <Process.page_faults>`
+     - ``ps -o maj_flt,min_flt -p PID``
+     - ``ps -o faults -p PID``
+     - ``procstat -r PID``
+     -
+
+Threads
+~~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil method
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :meth:`p.num_threads() <Process.num_threads>`
+     - ``ps -o nlwp -p PID``
+     - same
+     - same
+     -
+   * - :meth:`p.threads() <Process.threads>`
+     - ``ps -T -p PID``
+     -
+     -
+     -
+
+Files and connections
+~~~~~~~~~~~~~~~~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil method
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :meth:`p.net_connections() <Process.net_connections>`
+     - ``ss -p``, ``lsof -p PID -i``
+     - ``lsof -p PID -i``
+     -
+     - ``netstat -ano | findstr PID``
+   * - :meth:`p.open_files() <Process.open_files>`
+     - ``lsof -p PID``
+     - same
+     - ``procstat -f PID``, ``fstat``
+     - ``handle.exe -p PID``
+   * - :meth:`p.io_counters() <Process.io_counters>`
+     - ``cat /proc/pid/io``
+     -
+     -
+     -
+   * - :meth:`p.num_fds() <Process.num_fds>`
+     - ``ls /proc/pid/fd | wc -l``
+     -
+     -
+     -
+   * - :meth:`p.num_handles() <Process.num_handles>`
+     -
+     -
+     -
+     -
+
+Signals
+~~~~~~~
+
+.. list-table::
+   :header-rows: 1
+   :class: wide-table
+
+   * - psutil method
+     - Linux
+     - macOS
+     - BSD
+     - Windows
+   * - :meth:`p.send_signal() <Process.send_signal>`
+     - ``kill -SIG PID``
+     - same
+     - same
+     -
+   * - :meth:`p.suspend() <Process.suspend>`
+     - ``kill -STOP PID``
+     - same
+     - same
+     -
+   * - :meth:`p.resume() <Process.resume>`
+     - ``kill -CONT PID``
+     - same
+     - same
+     -
+   * - :meth:`p.terminate() <Process.terminate>`
+     - ``kill -TERM PID``
+     - same
+     - same
+     - ``taskkill /PID PID``
+   * - :meth:`p.kill() <Process.kill>`
+     - ``kill -KILL PID``
+     - same
+     - same
+     - ``taskkill /F /PID PID``
+   * - :meth:`p.wait() <Process.wait>`
+     - ``tail --pid=PID -f /dev/null``
+     - ``lsof -p PID +r 1``
+     - ``pwait PID``
+     -
diff --git a/docs/stdlib-equivalents.rst b/docs/stdlib-equivalents.rst
new file mode 100644
index 0000000000..24cc9ac3a7
--- /dev/null
+++ b/docs/stdlib-equivalents.rst
@@ -0,0 +1,289 @@
+Stdlib equivalents
+==================
+
+This page maps psutil's Python API to the closest equivalent in the Python
+standard library. This is useful for understanding what psutil replaces and how
+the two APIs differ. The most common difference is that stdlib functions only
+operate on the **current process**, while psutil works on **any process**
+(PID).
+
+.. seealso::
+   - :doc:`shell-equivalents`
+   - :doc:`alternatives`
+
+System-wide functions
+---------------------
+
+CPU
+~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 30 60 100
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :func:`cpu_count`
+     - :func:`os.cpu_count`,
+       :func:`multiprocessing.cpu_count`
+     - Same as ``cpu_count(logical=True)``; no support for
+       physical cores (``logical=False``). See :ref:`FAQ <faq_cpu_count>`.
+   * - :func:`cpu_count`
+     - :func:`os.process_cpu_count`
+     - CPUs the process is allowed to use (Python 3.13+).
+       Equivalent to ``len(psutil.Process().cpu_affinity())``.
+       See :ref:`FAQ <faq_cpu_count>`.
+   * - :func:`getloadavg`
+     - :func:`os.getloadavg`
+     - Same on POSIX; psutil also supports Windows.
+
+Disk
+~~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 45 45 100
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :func:`disk_usage`
+     - :func:`shutil.disk_usage`
+     - Same as :func:`shutil.disk_usage`; psutil also adds
+       :field:`percent`. Added to CPython 3.3 (:bpo:`12442`).
+   * - :func:`disk_partitions`
+     - :func:`os.listdrives`,
+       :func:`os.listmounts`,
+       :func:`os.listvolumes`
+     - Windows only (Python 3.12+). Low-level APIs:
+       drive letters, volume GUIDs, mount points. psutil
+       combines them in one cross-platform call.
+
+Network
+~~~~~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 45 45 100
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :func:`net_if_addrs`
+     - :func:`socket.if_nameindex`
+     - Stdlib returns :term:`NIC` names only; psutil also returns
+       addresses, netmasks, broadcast, and PTP.
+
+Process
+~~~~~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 45 45 100
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :func:`pid_exists`
+     - ``os.kill(pid, 0)``
+     - Common POSIX idiom; psutil also supports Windows.
+
+Process methods
+---------------
+
+Assuming ``p = psutil.Process()``.
+
+Identity
+~~~~~~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 45 45 100
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :meth:`p.pid <Process.pid>`
+
+     - :func:`os.getpid`
+     -
+   * - :meth:`p.ppid() <Process.ppid>`
+     - :func:`os.getppid`
+     -
+   * - :meth:`p.cwd() <Process.cwd>`
+     - :func:`os.getcwd`
+     -
+   * - :meth:`p.environ() <Process.environ>`
+     - :data:`os.environ`
+     - Will differ from launch environment if modified at runtime.
+   * - :meth:`p.exe() <Process.exe>`
+     - :data:`sys.executable`
+     - Python interpreter path only.
+   * - :meth:`p.cmdline() <Process.cmdline>`
+     - :data:`sys.argv`
+     - Python process only.
+
+Credentials
+~~~~~~~~~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 30 65 50
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :meth:`p.uids() <Process.uids>`
+     - :func:`os.getuid`,
+       :func:`os.geteuid`,
+       :func:`os.getresuid`
+     -
+   * - :meth:`p.gids() <Process.gids>`
+     - :func:`os.getgid`,
+       :func:`os.getegid`,
+       :func:`os.getresgid`
+     -
+   * - :meth:`p.username() <Process.username>`
+     - :func:`os.getlogin`, :func:`getpass.getuser`
+     - Rough equivalent; not per-process.
+
+CPU / scheduling
+~~~~~~~~~~~~~~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 60 60 100
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :meth:`p.cpu_times() <Process.cpu_times>`
+     - :func:`os.times`
+     - :func:`os.times` also has ``elapsed``; psutil adds
+       :field:`iowait` (Linux).
+   * - :meth:`p.cpu_times() <Process.cpu_times>`
+     - :func:`resource.getrusage`
+     - ``ru_utime`` / ``ru_stime`` match; have higher precision.
+   * - :meth:`p.num_ctx_switches() <Process.num_ctx_switches>`
+     - :func:`resource.getrusage`
+     - Current process only; psutil works for any PID.
+   * - :meth:`p.nice() <Process.nice>`
+     - :func:`os.getpriority`,
+       :func:`os.setpriority`
+     - POSIX only; psutil also supports Windows.
+       Added to CPython 3.3 (:bpo:`10784`).
+   * - :meth:`p.nice() <Process.nice>`
+     - :func:`os.nice`
+     - POSIX only; psutil also supports Windows.
+   * - *no equivalent*
+     - :func:`os.sched_getscheduler`,
+       :func:`os.sched_setscheduler`
+     - Sets scheduling *policy* (``SCHED_*``). Unlike nice,
+       which sets priority within ``SCHED_OTHER``. Real-time
+       policies preempt normal processes.
+   * - :meth:`p.cpu_affinity() <Process.cpu_affinity>`
+     - :func:`os.sched_getaffinity`,
+       :func:`os.sched_setaffinity`
+     - Nearly equivalent; both accept a PID. Stdlib is
+       Linux/BSD; psutil also supports Windows.
+   * - :meth:`p.rlimit() <Process.rlimit>`
+     - :func:`resource.getrlimit`,
+       :func:`resource.setrlimit`
+     - Same interface; psutil works for any PID (Linux only).
+
+Memory
+~~~~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 45 45 100
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :meth:`p.memory_info() <Process.memory_info>`
+     - :func:`resource.getrusage`
+     - Only :term:`peak_rss` (``ru_maxrss``); psutil returns :term:`RSS`, :term:`VMS`, and more.
+   * - :meth:`p.page_faults() <Process.page_faults>`
+     - :func:`resource.getrusage`
+     - Current process only.
+
+I/O
+~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 45 45 100
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :meth:`p.io_counters() <Process.io_counters>`
+     - :func:`resource.getrusage`
+     - Block I/O only (``ru_inblock`` / ``ru_oublock``),
+       current process. psutil returns bytes and counts for any PID.
+
+Threads
+~~~~~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 50 55 100
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :meth:`p.num_threads() <Process.num_threads>`
+     - :func:`threading.active_count`
+     - Stdlib counts Python threads only; psutil counts all OS threads.
+   * - :meth:`p.threads() <Process.threads>`
+     - :func:`threading.enumerate`
+     - Stdlib returns :class:`threading.Thread` objects; psutil
+       returns OS thread IDs with CPU times.
+
+Signals
+~~~~~~~
+
+.. list-table::
+   :class: longtable wide-table
+   :header-rows: 1
+   :widths: 45 55 100
+
+   * - psutil
+     - stdlib
+     - notes
+   * - :meth:`p.send_signal() <Process.send_signal>`
+     - :func:`os.kill`
+     - Same on POSIX; limited on Windows. psutil adds
+       :exc:`NoSuchProcess` / :exc:`AccessDenied` and avoids
+       killing reused PIDs.
+   * - :meth:`p.suspend() <Process.suspend>`
+     - :func:`os.kill` + :data:`signal.SIGSTOP`
+     - Same as above.
+   * - :meth:`p.resume() <Process.resume>`
+     - :func:`os.kill` + :data:`signal.SIGCONT`
+     - Same as above.
+   * - :meth:`p.terminate() <Process.terminate>`
+     - :func:`os.kill` + :data:`signal.SIGTERM`
+     - Same as above. On Windows uses ``TerminateProcess()``.
+   * - :meth:`p.kill() <Process.kill>`
+     - :func:`os.kill` + :data:`signal.SIGKILL`
+     - Same as above. On Windows uses ``TerminateProcess()``.
+   * - :meth:`p.wait() <Process.wait>`
+     - :func:`os.waitpid`
+     - Child processes only; psutil works for any PID.
+   * - :meth:`p.wait() <Process.wait>`
+     - :meth:`subprocess.Popen.wait`
+     - Equivalent; psutil uses efficient OS-level waiting on
+       Linux/BSD. Added to CPython 3.15 (:cpy-pr:`144047`).
diff --git a/docs/test_docs.py b/docs/test_docs.py
new file mode 100644
index 0000000000..0eaea664ed
--- /dev/null
+++ b/docs/test_docs.py
@@ -0,0 +1,1040 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Sanity checks for the Sphinx docs and blog posts."""
+
+import importlib.util
+import pathlib
+import re
+import shutil
+import subprocess
+import sys
+import tempfile
+import xml.etree.ElementTree as ET
+import zlib
+from datetime import datetime
+from datetime import timezone
+
+import pytest
+
+HERE = pathlib.Path(__file__).resolve().parent
+ROOT = HERE.parent
+DOCS = ROOT / "docs"
+BLOG = DOCS / "blog"
+
+VALID_BLOG_TAGS = frozenset({
+    # platforms
+    "bsd",
+    "linux",
+    "macos",
+    "sunos",
+    "windows",
+    # API / compatibility
+    "api-design",
+    "compatibility",
+    "new-api",
+    "new-platform",
+    # editorial
+    "featured",
+    # topics
+    "c",
+    "community",
+    "memory",
+    "performance",
+    "personal",
+    "python-core",
+    "release",
+    "tests",
+    "wheels",
+})
+
+sys.path.insert(0, str(HERE))  # so that "import conf" wins
+import conf  # noqa: E402
+import label_role  # noqa: E402
+import substitutions  # noqa: E402
+from testutil import feed_urls  # noqa: E402
+from testutil import find_canonical  # noqa: E402
+from testutil import og_value  # noqa: E402
+
+pytestmark = pytest.mark.skipif(
+    sys.platform == "win32", reason="docs are built on Linux only"
+)
+
+HTML_DIR = None
+
+PAST_RELEASE_DIRS = frozenset(
+    entry["url"].strip("/")
+    for entry in conf.VERSIONS["versions"]
+    if entry.get("ref")
+)
+
+
+def _under(path):
+    return HTML_DIR in path.parents or path == HTML_DIR
+
+
+@pytest.fixture(scope="module")
+def build_html():
+    """Build the site once. `make html` already turns warnings into
+    errors by default.
+    """
+    global HTML_DIR
+
+    tmp = tempfile.mkdtemp()
+    subprocess.check_call([
+        "make",
+        "-C",
+        str(DOCS),
+        "html",
+        f"BUILDDIR={tmp}",
+        f"PYTHON={sys.executable}",
+    ])
+    HTML_DIR = pathlib.Path(tmp) / "html"
+    yield
+    shutil.rmtree(tmp)
+    HTML_DIR = None
+
+
+def blog_posts():
+    return sorted(BLOG.rglob("*.rst"))
+
+
+def read_html(*parts):
+    # dirhtml writes each page as <slug>/index.html; only the root
+    # index.html stays flat. Translate the historical "<slug>.html".
+    rel = pathlib.Path(*parts)
+    if rel.name == "index.html":
+        path = HTML_DIR / rel
+    else:
+        path = HTML_DIR / rel.with_suffix("") / "index.html"
+    return path.read_text()
+
+
+def post_title(rst):
+    """First H1 in a .rst file (the line above a `===` underline)."""
+    lines = rst.read_text().splitlines()
+    for i in range(1, len(lines)):
+        if re.fullmatch(r"=+", lines[i].strip()):
+            return lines[i - 1].strip()
+    raise ValueError(f"no RST H1 found in {rst}")
+
+
+def post_tags(rst):
+    """Tags from a blog post's `:tags:` line, or [] if absent."""
+    m = re.search(r":tags:\s*(.+)", rst.read_text())
+    if not m:
+        return []
+    return [t.strip() for t in m.group(1).split(",")]
+
+
+def blog_html(rst):
+    """Read the built HTML for a blog post given its source .rst."""
+    rel = rst.relative_to(BLOG).with_suffix("")
+    return (HTML_DIR / "blog" / rel / "index.html").read_text()
+
+
+def source_rst_for(html_path):
+    """Return the .rst source for a built page, or None for pages
+    generated without a source (ablog archives, sphinx auto-pages
+    like genindex/search/py-modindex).
+    """
+    rel = html_path.relative_to(HTML_DIR)
+    if rel.name != "index.html":
+        return None
+    if rel.parent == pathlib.Path("."):
+        slug = "index"  # root home page
+    else:
+        slug = rel.parent.as_posix()
+    src = DOCS / (slug + ".rst")
+    return src if src.is_file() else None
+
+
+def all_html_pages():
+    """Every "real content" HTML page in the build."""
+    for p in sorted(HTML_DIR.rglob("*.html")):
+        rel_parts = p.relative_to(HTML_DIR).parts
+        if any(part.startswith("_") for part in rel_parts):
+            continue
+        if source_rst_for(p) is None:
+            continue
+        yield p
+
+
+class TestSourceRefs:
+    """Checks on the .rst sources, no build needed."""
+
+    def test_src_role_targets_exist(self, subtests):
+        # :src:`path` links to the file on GitHub. Nothing validates
+        # the path: rename or move the file and the link 404s, with
+        # no build warning. Both the bare and the labelled
+        # (`text <path>`) forms are used.
+        pat = re.compile(r":src:`([^`]+)`")
+        for rst in sorted(DOCS.rglob("*.rst")):
+            for target in pat.findall(rst.read_text()):
+                m = re.search(r"<([^>]+)>", target)
+                if m:
+                    target = m.group(1)
+                with subtests.test(rst=rst.relative_to(ROOT), ref=target):
+                    assert (ROOT / target).exists()
+
+    def test_first_commit_date(self):
+        # _ext/substitutions.py hardcodes it to keep git out of the
+        # build. Check it against the real history.
+        cmd = ["git", "log", "--reverse", "--format=%ct"]
+        out = subprocess.check_output(cmd, cwd=ROOT).split(b"\n", 1)[0]
+        first = datetime.fromtimestamp(int(out), tz=timezone.utc)
+        assert first.date() == substitutions.FIRST_COMMIT
+
+
+class TestBlogPostFiles:
+
+    def test_every_file_has_directives(self):
+        missing = []
+        for p in blog_posts():
+            text = p.read_text()
+            missed = [
+                k for k in (".. post::", ":author:", ":tags:") if k not in text
+            ]
+            if missed:
+                rel = p.relative_to(ROOT)
+                missing.append(f"{rel}: missing {missed}")
+        assert missing == []
+
+    def test_date_year_matches_path_year(self):
+        mismatches = []
+        for p in blog_posts():
+            m = re.search(r"\.\. post:: (\d{4})-", p.read_text())
+            if m and m.group(1) != p.parent.name:
+                rel = p.relative_to(ROOT)
+                mismatches.append(
+                    f"{rel}: date-year={m.group(1)} dir={p.parent.name}"
+                )
+        assert mismatches == []
+
+    def test_valid_tags(self):
+        invalid = {}
+        for p in blog_posts():
+            bad = [t for t in post_tags(p) if t not in VALID_BLOG_TAGS]
+            if bad:
+                invalid[str(p.relative_to(ROOT))] = bad
+        assert not invalid, f"invalid tags: {invalid}"
+
+
+@pytest.mark.usefixtures("build_html")
+class TestHtmlBuild:
+    """Build sanity: pages exist, extensions wire up, footer dates."""
+
+    def test_files_exist(self):
+        assert (HTML_DIR / "index.html").exists()
+        assert (HTML_DIR / "blog" / "index.html").exists()
+
+    def test_page_sources_are_published(self, subtests):
+        for name in ("api", "faq", "install", "blog/2025/drop-py27"):
+            with subtests.test(page=name):
+                src = HTML_DIR / "_sources" / (name + ".rst.txt")
+                assert src.is_file() is True
+
+    def test_github_pages_control_files(self):
+        # sphinx.ext.githubpages writes these: .nojekyll stops Jekyll
+        # from dropping _static/, CNAME is derived from html_baseurl.
+        assert (HTML_DIR / ".nojekyll").is_file()
+        assert (HTML_DIR / "CNAME").read_text().strip() == "psutil.io"
+
+    def test_substitutions_expanded(self):
+        # _ext/substitutions.py expands {{years_in_development}}. If
+        # the hook breaks, the literal token ships instead.
+        html = read_html("index.html")
+        assert f"{substitutions.years_in_development()} years" in html
+        assert "{{" not in html
+
+    def test_changelog_anchors(self):
+        # Indirectly test _ext/changelog_anchors.py. Every X.Y.Z
+        # version heading in changelog.rst must get an `id="XYZ"`
+        # anchor in the rendered HTML.
+        source = (DOCS / "changelog.rst").read_text()
+        html = read_html("changelog.html")
+        missing = []
+        for m in re.finditer(r"^(\d+)\.(\d+)\.(\d+)", source, re.MULTILINE):
+            anchor = "".join(m.groups())
+            if f'id="{anchor}"' not in html:
+                missing.append(m.group(0))
+        assert missing == []
+
+    def test_gh_role_resolves(self):
+        # Checks extlinks = {"gh": ...} in conf.py. Without it, every
+        # :gh:`NNN` in the docs silently renders as plain text instead
+        # of links.
+        html = read_html("changelog.html")
+        assert 'href="https://github.com/giampaolo/psutil/issues/' in html
+
+    def test_label_role_resolves(self):
+        source = (DOCS / "changelog.rst").read_text()
+        html = read_html("changelog.html")
+        for label in label_role.LABELS:
+            badge = f'class="cl-label cl-label-{label}">{label}<'
+            assert source.count(f":label:`{label}`") == html.count(badge)
+
+    def test_intersphinx_resolves(self):
+        # Check intersphinx_mapping["python"] in conf.py. If it does
+        # not work, :mod:`func` refs to the stdlib silently render as
+        # plain text instead of links.
+        html = read_html("api.html")
+        assert 'href="https://docs.python.org/3/' in html
+
+    def test_footer_last_updated_matches_git(self, subtests):
+        def is_merge_checkout():
+            ret = subprocess.run(
+                ["git", "rev-parse", "-q", "--verify", "HEAD^2"],
+                capture_output=True,
+                check=False,
+            )
+            return ret.returncode == 0
+
+        if is_merge_checkout():
+            pytest.skip("merge commit")
+        # Skip pages that pull in external files via `.. include::`
+        # or `.. raw:: <fmt> :file:`. sphinx-last-updated-by-git
+        # walks those deps and picks the latest commit timestamp,
+        # which we don't replicate here.
+        dep_pat = re.compile(r"^\.\. (?:include|raw)::", re.MULTILINE)
+        date_pat = re.compile(r"Updated: <a\b[^>]*>(\d{4}-\d{2}-\d{2})</a>")
+        for html in all_html_pages():
+            src = source_rst_for(html)
+            if dep_pat.search(src.read_text()):
+                continue
+            m = date_pat.search(html.read_text())
+            if m is None:
+                continue  # page doesn't render the footer date
+            cmd = [
+                "git",
+                "log",
+                "-1",
+                "--author-date-order",
+                "--format=%at",
+                "--",
+                str(src),
+            ]
+            ts = subprocess.check_output(cmd).strip()
+            if not ts:
+                continue  # untracked source file
+            expected = datetime.fromtimestamp(
+                int(ts), tz=timezone.utc
+            ).strftime("%Y-%m-%d")
+            with subtests.test(page=html.relative_to(HTML_DIR)):
+                assert m.group(1) == expected
+
+    def test_footer_github_links_resolve(self, subtests):
+        # ablog and codeautolink generate pages with no .rst behind
+        # them (blog/tag/*, blog/2025, _modules/*). Their footer
+        # links used to be built from the page name anyway, so they
+        # 404ed on GitHub.
+        pat = re.compile(
+            r'github\.com/giampaolo/psutil/(?:edit|commits)/master/(\S+?)"'
+        )
+        for page in sorted(HTML_DIR.rglob("*.html")):
+            html = page.read_text(encoding="utf-8", errors="replace")
+            for target in set(pat.findall(html)):
+                with subtests.test(page=page.relative_to(HTML_DIR)):
+                    assert (ROOT / target).is_file()
+
+
+@pytest.mark.usefixtures("build_html")
+class TestSitemap:
+
+    def test_known_pages_listed(self, subtests):
+        # sphinx-sitemap should emit one <url> per built HTML page
+        # (source docs + blog posts + ablog-generated pages), rooted at
+        # html_baseurl. dirhtml gives directory-style URLs (trailing
+        # slash); the home page is the bare root.
+        sitemap = HTML_DIR / "sitemap.xml"
+        assert sitemap.exists()
+        ns = {"s": "http://www.sitemaps.org/schemas/sitemap/0.9"}
+        tree = ET.parse(sitemap)
+        urls = {u.text for u in tree.getroot().findall("s:url/s:loc", ns)}
+        for page in (
+            "",
+            "api/",
+            "changelog/",
+            "blog/2026/event-driven-process-waiting/",
+        ):
+            with subtests.test(page=page):
+                assert conf.html_baseurl + page in urls
+
+    def test_no_duplicate_urls(self):
+        # ablog re-renders the blog index on top of blog.rst, so
+        # sphinx-sitemap lists that URL twice unless we dedupe.
+        sitemap = HTML_DIR / "sitemap.xml"
+        ns = {"s": "http://www.sitemaps.org/schemas/sitemap/0.9"}
+        urls = [
+            u.text
+            for u in ET.parse(sitemap).getroot().findall("s:url/s:loc", ns)
+        ]
+        dupes = sorted({u for u in urls if urls.count(u) > 1})
+        assert dupes == []
+
+    def test_listed_pages_have_description(self, subtests):
+        # ablog's generated pages come with no doctree, so
+        # sphinxext-opengraph skips them and emits no description.
+        pat = re.compile(r'<meta[^>]*name="description"', re.IGNORECASE)
+        sitemap = HTML_DIR / "sitemap.xml"
+        ns = {"s": "http://www.sitemaps.org/schemas/sitemap/0.9"}
+        for url in ET.parse(sitemap).getroot().findall("s:url/s:loc", ns):
+            rel = url.text.replace(conf.html_baseurl, "")
+            page = HTML_DIR / rel / "index.html"
+            with subtests.test(page=rel or "/"):
+                assert pat.search(page.read_text(errors="replace"))
+
+    def test_excludes_utility_pages(self, subtests):
+        # sitemap_excludes must use the dirhtml dir form ("search/",
+        # not "search.html") or utility + ablog pages leak in.
+        sitemap = HTML_DIR / "sitemap.xml"
+        ns = {"s": "http://www.sitemaps.org/schemas/sitemap/0.9"}
+        urls = {
+            u.text
+            for u in ET.parse(sitemap).getroot().findall("s:url/s:loc", ns)
+        }
+        for slug in (
+            "genindex",
+            "py-modindex",
+            "search",
+            "404",
+            "blog/archive",
+            "blog/drafts",
+            "blog/2026",
+        ):
+            with subtests.test(slug=slug):
+                assert conf.html_baseurl + slug + "/" not in urls
+
+    def test_has_every_blog_post(self, subtests):
+        # Catches drift between ablog's post registry and
+        # sphinx-sitemap. If sphinx-sitemap stops listing some posts
+        # (e.g. due to an ablog version bump), search engines stop
+        # discovering them.
+        sitemap = HTML_DIR / "sitemap.xml"
+        ns = {"s": "http://www.sitemaps.org/schemas/sitemap/0.9"}
+        urls = {
+            u.text
+            for u in ET.parse(sitemap).getroot().findall("s:url/s:loc", ns)
+        }
+        for rst in blog_posts():
+            rel = rst.relative_to(BLOG).with_suffix("")
+            expected = conf.html_baseurl + "blog/" + rel.as_posix() + "/"
+            with subtests.test(rst=rst):
+                assert expected in urls
+
+
+@pytest.mark.usefixtures("build_html")
+class TestCanonicalUrl:
+
+    def test_link_on_pages(self, subtests):
+        # Sphinx emits <link rel="canonical"> using html_baseurl. If
+        # html_baseurl is misconfigured, every shared URL points at a
+        # 404.
+        for page in (
+            "index.html",
+            "api.html",
+            "blog/2026/event-driven-process-waiting.html",
+        ):
+            url = find_canonical(read_html(page))
+            with subtests.test(page=page):
+                assert url is not None
+                assert url.startswith(conf.html_baseurl)
+
+    def test_og_urls_rooted_at_baseurl(self, subtests):
+        # og:url + og:image must point at the deployed domain; they
+        # once lagged html_baseurl and pointed at the old host.
+        html = read_html("api.html")
+        for prop in ("og:url", "og:image"):
+            val = og_value(html, prop)
+            with subtests.test(prop=prop):
+                assert val is not None
+                assert val.startswith(conf.html_baseurl)
+
+
+@pytest.mark.usefixtures("build_html")
+class TestRightToc:
+
+    def test_visibility(self, subtests):
+        has_toc = ("api.html", "faq.html", "glossary.html", "blog.html")
+        no_toc = ("index.html", "genindex.html", "search.html")
+        pat = re.compile(r'<aside[^>]*\bclass="[^"]*\bright-sidebar\b')
+        for file in has_toc:
+            with subtests.test(file=file):
+                assert pat.search(read_html(file))
+        for file in no_toc:
+            with subtests.test(file=file):
+                assert not pat.search(read_html(file))
+
+    def test_hash_targets_resolve(self, subtests):
+        # Every <a href="#..."> inside the right-sidebar must point to
+        # an id that exists on the same page. Otherwise the JS
+        # hash-match path in right-toc.js silently misses on direct
+        # URL load.
+        html = read_html("api.html")
+        m = re.search(
+            r'<aside[^>]*\bclass="[^"]*\bright-sidebar\b[^"]*"[^>]*>(.*?)</aside>',
+            html,
+            re.DOTALL,
+        )
+        assert m
+        hrefs = re.findall(r'href="#([^"]+)"', m.group(1))
+        assert hrefs
+        ids_on_page = set(re.findall(r'\bid="([^"]+)"', html))
+        for href in hrefs:
+            with subtests.test(href=href):
+                assert href in ids_on_page
+
+    def test_glossary_mode(self):
+        # Tests docs/_ext/glossary_toc.py, which injects
+        # glossary_terms into the Jinja context.
+        html = read_html("glossary.html")
+        assert 'data-toc-mode="glossary"' in html
+        m = re.search(
+            r'<aside class="right-sidebar'
+            r' right-sidebar--glossary"[^>]*>(.*?)</aside>',
+            html,
+            re.DOTALL,
+        )
+        assert m, "right-sidebar--glossary aside not found"
+        terms = re.findall(r'<a href="#term-[^"]*">([^<]+)</a>', m.group(1))
+        assert terms
+        assert terms == sorted(terms, key=str.lower)
+
+
+@pytest.mark.usefixtures("build_html")
+class TestCodeAutoLink:
+    """Checks sphinx-codeautolink integration."""
+
+    def test_enabled(self):
+        html = read_html("api-overview.html")
+        assert "sphinx-codeautolink-a" in html
+
+    def test_resolves_process_instance_methods(self):
+        # Check that things like `p.name()`are resolved.
+        html = read_html("api-overview.html")
+        assert (
+            '<a class="sphinx-codeautolink-a" '
+            'href="../api/#psutil.Process.name"'
+            in html
+        )
+
+
+@pytest.mark.usefixtures("build_html")
+class TestAtomFeed:
+
+    def test_entry_count(self):
+        feed = HTML_DIR / "blog" / "atom.xml"
+        ns = {"a": "http://www.w3.org/2005/Atom"}
+        entries = ET.parse(feed).getroot().findall("a:entry", ns)
+        assert len(entries) == len(blog_posts())
+
+    def test_uses_utc(self):
+        feed = HTML_DIR / "blog" / "atom.xml"
+        ns = {"a": "http://www.w3.org/2005/Atom"}
+        entries = ET.parse(feed).getroot().findall("a:entry", ns)
+        assert entries
+        non_utc = []
+        for e in entries:
+            for tag in ("a:updated", "a:published"):
+                el = e.find(tag, ns)
+                assert el is not None
+                if not (el.text.endswith("+00:00") or el.text.endswith("Z")):
+                    non_utc.append(el.text)
+        assert non_utc == []
+
+    def test_uses_canonical_url(self):
+        # Regression: feed-level + per-entry URLs must be rooted at
+        # html_baseurl so they match the deployed location. Without
+        # it, feed readers 404.
+        feed = HTML_DIR / "blog" / "atom.xml"
+        root = ET.parse(feed).getroot()
+        bad = [
+            u for u in feed_urls(root) if not u.startswith(conf.html_baseurl)
+        ]
+        assert bad == []
+
+    def test_link_on_every_page_exactly_once(self, subtests):
+        # Every page must auto-discover the atom feed (so feed readers
+        # find it from any post URL), and the <link> must appear only
+        # once. layout.html used to inject it unconditionally,
+        # duplicating ablog's auto-injection.
+        needle = 'type="application/atom+xml"'
+        for html in all_html_pages():
+            with subtests.test(page=html.relative_to(HTML_DIR)):
+                head = html.read_text()[:8192]
+                assert head.count(needle) == 1
+
+
+@pytest.mark.usefixtures("build_html")
+class TestOpenGraph:
+    """og:* and twitter:* social-preview meta tags."""
+
+    def test_tags_on_source_pages(self, subtests):
+        for rst in sorted(DOCS.rglob("*.rst")):
+            if rst.name == "blog.rst":
+                continue
+            rel = rst.relative_to(DOCS)
+            if rel.name == "index.rst" and rel.parent == pathlib.Path("."):
+                html_path = HTML_DIR / "index.html"
+            else:
+                html_path = HTML_DIR / rel.with_suffix("") / "index.html"
+            html = html_path.read_text()
+            with subtests.test(rst=rst):
+                for needle in (
+                    "og:title",
+                    "og:site_name",
+                    "og:description",
+                    "og:image",
+                ):
+                    assert needle in html
+
+    def test_tags_on_blog_posts(self, subtests):
+        # sphinxext-opengraph should emit og:* meta tags on every
+        # post page so that shared URLs render as rich previews.
+        properties = (
+            "og:title",
+            "og:url",
+            "og:site_name",
+            "og:description",
+            "og:image",
+        )
+        for rst in blog_posts():
+            html = blog_html(rst)
+            for prop in properties:
+                with subtests.test(rst=rst, prop=prop):
+                    assert f'property="{prop}"' in html
+
+    def test_type(self, subtests):
+        # For blog posts it must be og:type="article" else "website".
+        for rst in blog_posts():
+            with subtests.test(rst=rst, expected="article"):
+                assert og_value(blog_html(rst), "og:type") == "article"
+        for page in ("index.html", "api.html", "install.html"):
+            with subtests.test(page=page, expected="website"):
+                assert og_value(read_html(page), "og:type") == "website"
+
+    def test_blog_index_metadata(self, subtests):
+        # Regression: ablog renders blog.html without a doctree, so
+        # sphinxext-opengraph skips emitting og:* tags. Our
+        # opengraph_override extension synthesizes them.
+        html = read_html("blog.html")
+        for tag in (
+            'name="description"',
+            'property="og:title"',
+            'property="og:type"',
+            'property="og:url"',
+            'property="og:site_name"',
+            'property="og:description"',
+            'property="og:image"',
+            'name="twitter:card"',
+        ):
+            with subtests.test(tag=tag):
+                assert tag in html
+
+    def test_description_uses_post_excerpt(self):
+        # Blog post og:description (and the social card PNG sourced
+        # from the same value) should be the curated excerpt from the
+        # `.. post::` directive body, not the page body's first
+        # paragraph. Spot-check on a known post.
+        html = read_html("blog", "2026", "event-driven-process-waiting.html")
+        desc = og_value(html, "og:description")
+        # Excerpt opens with "Replacing"; the page body opens with
+        # "One of the less fun aspects of process management ...".
+        assert desc is not None
+        assert desc.startswith("Replacing")
+
+    def test_description_excludes_post_banner(self, subtests):
+        # Regression: the post banner (author/date/readtime/tags)
+        # used to leak into og:description, making social previews
+        # start with "Giampaolo Rodola 2026-01-28 5 min read ...".
+        for rst in blog_posts():
+            desc = og_value(blog_html(rst), "og:description")
+            with subtests.test(rst=rst):
+                assert desc is not None
+                assert not desc.startswith("Giampaolo")
+                assert "min read" not in desc[:80]
+
+
+@pytest.mark.usefixtures("build_html")
+class TestBlogPosts:
+    """Rendered blog post pages and the blog index listing."""
+
+    def test_banner_on_every_post(self, subtests):
+        css_names = (
+            "post-meta-banner",
+            "post-meta-author",
+            "post-meta-date",
+            "post-meta-readtime",
+            "post-meta-tags",
+        )
+        for rst in blog_posts():
+            html = blog_html(rst)
+            for css in css_names:
+                with subtests.test(rst=rst, css=css):
+                    assert css in html
+
+    def test_listing_has_all_posts(self, subtests):
+        # blog.html should list all posts, each containing the post's
+        # title.
+        posts = blog_posts()
+        html = read_html("blog.html")
+        assert len(re.findall(r'<li class="blog-card[^"]*"', html)) == len(
+            posts
+        )
+        for rst in posts:
+            with subtests.test(rst=rst):
+                assert post_title(rst) in html
+
+    def test_listing_shows_summary(self, subtests):
+        # Each post should have a summary below the title.
+        html = read_html("blog.html")
+        summaries = re.findall(
+            r'<div class="blog-card-summary">(.*?)</div>', html, re.DOTALL
+        )
+        posts = blog_posts()
+        assert len(summaries) == len(posts)
+        for i, summary in enumerate(summaries):
+            plain = re.sub(r"<[^>]+>", "", summary).strip()
+            with subtests.test(card=i):
+                assert plain
+
+    def test_featured_pill(self, subtests):
+        # Posts with the "featured" tag show a "Featured" pill in
+        # their post-meta banner via _ext/post_banner.py. Other posts
+        # must not.
+        for rst in blog_posts():
+            is_featured = "featured" in post_tags(rst)
+            html = blog_html(rst)
+            with subtests.test(rst=rst, is_featured=is_featured):
+                if is_featured:
+                    assert "post-meta-featured" in html
+                else:
+                    assert "post-meta-featured" not in html
+
+
+@pytest.mark.usefixtures("build_html")
+class TestNoExternalAssets:
+    """Stylesheets and fonts are self-hosted, not pulled from a CDN."""
+
+    ASSET_LINK_RE = re.compile(
+        r'<link\b[^>]*\brel="(?:stylesheet|preload)"[^>]*>', re.IGNORECASE
+    )
+    HREF_RE = re.compile(r'\bhref="([^"]+)"')
+
+    @staticmethod
+    def is_external(url):
+        return url.startswith(("http://", "https://", "//"))
+
+    def test_no_external_stylesheets(self, subtests):
+        # Analytics <script>s are deliberately external; only links count.
+        for page in all_html_pages():
+            urls = []
+            for tag in self.ASSET_LINK_RE.findall(page.read_text()):
+                urls += self.HREF_RE.findall(tag)
+            external = [u for u in urls if self.is_external(u)]
+            with subtests.test(page=page.relative_to(HTML_DIR)):
+                assert external == []
+
+    def test_no_external_css_urls(self, subtests):
+        css_dir = HTML_DIR / "_static" / "css"
+        for css in sorted(css_dir.glob("*.css")):
+            if css.name == "giscus.css":
+                continue  # runs in the giscus iframe, imports its theme
+            urls = re.findall(r'url\(\s*["\']?([^"\')]+)', css.read_text())
+            external = [u for u in urls if self.is_external(u)]
+            with subtests.test(css=css.name):
+                assert external == []
+
+
+@pytest.mark.usefixtures("build_html")
+class TestFonts:
+    """Every @font-face points at a font file that ships in the build."""
+
+    def test_font_face_files_exist(self, subtests):
+        css_dir = HTML_DIR / "_static" / "css"
+        face_re = re.compile(r"@font-face\s*\{[^}]*\}", re.DOTALL)
+        url_re = re.compile(r'url\(\s*["\']?([^"\')]+)')
+        found = 0
+        for css in sorted(css_dir.glob("*.css")):
+            for block in face_re.findall(css.read_text()):
+                for url in url_re.findall(block):
+                    found += 1
+                    resolved = (css.parent / url).resolve()
+                    with subtests.test(css=css.name, url=url):
+                        assert resolved.is_file()
+        assert found > 0
+
+
+@pytest.mark.usefixtures("build_html")
+class TestNoIndex:
+    """Utility pages are noindex'd (layout.html); content pages aren't."""
+
+    NOINDEX_RE = re.compile(
+        r'<meta[^>]*name="robots"[^>]*content="noindex"', re.IGNORECASE
+    )
+
+    def test_utility_pages_noindex(self, subtests):
+        for name in ("genindex", "py-modindex", "404", "search"):
+            path = HTML_DIR / name / "index.html"
+            if not path.is_file():
+                continue
+            with subtests.test(page=name):
+                assert self.NOINDEX_RE.search(path.read_text())
+
+    def test_blog_collections_noindex(self, subtests):
+        for name in (
+            "blog/tag",
+            "blog/tag/new-api",
+            "blog/category",
+            "blog/author",
+            "blog/archive",
+            "blog/drafts",
+        ):
+            path = HTML_DIR / name / "index.html"
+            if not path.is_file():
+                continue
+            with subtests.test(page=name):
+                assert self.NOINDEX_RE.search(path.read_text())
+
+    def test_blog_posts_indexable(self, subtests):
+        for name in ("blog", "blog/2026/event-driven-process-waiting"):
+            path = HTML_DIR / name / "index.html"
+            with subtests.test(page=name):
+                assert not self.NOINDEX_RE.search(path.read_text())
+
+    def test_content_pages_indexable(self, subtests):
+        for name in ("index.html", "api.html", "install.html"):
+            with subtests.test(page=name):
+                assert not self.NOINDEX_RE.search(read_html(name))
+
+    def test_past_releases_noindex(self):
+        # Past releases must never compete with the current docs in
+        # search results.
+        path = ROOT / "scripts" / "internal" / "docs" / "build_versions.py"
+        spec = importlib.util.spec_from_file_location("build_versions", path)
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+
+        tmp = tempfile.mkdtemp()
+        try:
+            page = pathlib.Path(tmp) / "sub" / "page.html"
+            page.parent.mkdir()
+            page.write_text("<html><head></head><body>x</body></html>")
+            entry = {"name": "7.2", "url": "/7.2/"}
+            assert mod.inject(pathlib.Path(tmp), entry, "dev") == 1
+            html = page.read_text()
+            assert self.NOINDEX_RE.search(html)
+            assert 'class="site-banner"' in html
+            assert 'data-banner-id="7.2"' in html
+            # Relative, so a file:// preview and a subdirectory both work.
+            assert '"../../_static/css/banner.css"' in html
+            assert '"../../_static/js/banner.js"' in html
+        finally:
+            shutil.rmtree(tmp)
+
+
+@pytest.mark.usefixtures("build_html")
+class TestLogo:
+    """The top-bar logo must land on the site root from every page."""
+
+    LOGO_RE = re.compile(r'<a class="topbar-logo" href="([^"]+)"')
+
+    def logo_href(self, *parts):
+        m = self.LOGO_RE.search(read_html(*parts))
+        assert m
+        return m.group(1)
+
+    def test_home_logo_targets_root(self):
+        # Not "#", which would strand the user on /# (regression).
+        assert self.logo_href("index.html") == "./"
+
+    def test_content_page_logo_targets_root(self):
+        assert self.logo_href("faq.html") == "../"
+
+    def test_404_logo_is_absolute_root(self):
+        # The 404 is served from arbitrary paths, so a relative/self
+        # link breaks; it must be the absolute root.
+        assert self.logo_href("404.html") == "/"
+
+
+@pytest.mark.usefixtures("build_html")
+class TestNotFound:
+    """The 404 is served from arbitrary paths, so every link on it must
+    be absolute; a relative one resolves against the request path and
+    404s again.
+    """
+
+    def test_root_404_html_exists(self):
+        # notfound_extras copies 404/index.html -> /404.html so static
+        # servers (GitHub Pages, Starlette) serve it for missing paths.
+        assert (HTML_DIR / "404.html").is_file()
+
+    def test_content_root_is_absolute(self):
+        # data-content_root drives JS-built URLs (search, highlight).
+        # On the 404, served from any depth, it must be absolute or a
+        # deep-path 404's search results resolve against the wrong base.
+        m = re.search(r'data-content_root="([^"]+)"', read_html("404.html"))
+        assert m
+        assert m.group(1) == "/"
+
+    def test_all_links_absolute(self):
+        html = read_html("404.html")
+        links = re.findall(r'(?:href|src|action)="([^"]+)"', html)
+        rel = [
+            u
+            for u in links
+            if not u.startswith(
+                ("/", "http://", "https://", "//", "#", "mailto:")
+            )
+        ]
+        assert rel == []
+
+    def test_helpful_links_present(self, subtests):
+        # Body "jump to ..." cross-references. Regression: notfound
+        # leaves these relative, so they used to break from deep paths.
+        html = read_html("404.html")
+        for target in ("/install/", "/api/", "/faq/", "/recipes/", "/blog/"):
+            with subtests.test(target=target):
+                assert f'href="{target}"' in html
+
+
+@pytest.mark.usefixtures("build_html")
+class TestSidebarIcons:
+    """Left-sidebar icons attach via href-based selectors in
+    doc-icons.css. When the URL scheme changed (.html -> dirhtml dirs)
+    the selectors silently stopped matching and every icon vanished.
+    """
+
+    def test_every_sidebar_link_has_icon_selector(self, subtests):
+        css = (HTML_DIR / "_static" / "css" / "doc-icons.css").read_text()
+        fragments = re.findall(r'href\*="([^"]+)"', css)
+        assert fragments
+        nav = re.search(
+            r'<nav[^>]*class="[^"]*left-sidebar.*?</nav>',
+            read_html("faq.html"),
+            re.DOTALL,
+        )
+        assert nav, "left-sidebar not found"
+        # Non-current page links look like "../<slug>/".
+        hrefs = re.findall(r'href="(\.\./[a-z-]+/)"', nav.group(0))
+        assert hrefs
+        for href in sorted(set(hrefs)):
+            with subtests.test(href=href):
+                assert any(frag in href for frag in fragments)
+
+
+@pytest.mark.usefixtures("build_html")
+class TestUrlScheme:
+    """dirhtml URL-scheme invariants.
+
+    Pages are served as directories (/faq/), so any hand-rolled
+    "<page>.html" link is dead. These guard the scheme site-wide
+    rather than one feature at a time.
+    """
+
+    SKIP = ("http://", "https://", "//", "mailto:", "data:", "#")
+
+    def resolve(self, page, url):
+        """On-disk path a link points at, or None if not checkable."""
+        url = url.split("#", 1)[0].split("?", 1)[0]
+        if not url or url.startswith(self.SKIP):
+            return None
+        if url.startswith("/"):
+            target = HTML_DIR / url.lstrip("/")
+        else:
+            target = (page.parent / url).resolve()
+        rel = target.relative_to(HTML_DIR) if _under(target) else None
+        if rel is not None and rel.parts and rel.parts[0] in PAST_RELEASE_DIRS:
+            return None
+        return target
+
+    def test_no_broken_internal_links(self):
+        # Offline link checker over every built page. This is the net
+        # that catches ".html" URLs dirhtml turned into 404s: blog tag
+        # refs, the search form action, raw-HTML blocks, extensions.
+        broken = []
+        pages = sorted(HTML_DIR.rglob("*.html"))
+        assert pages
+        for page in pages:
+            rel = page.relative_to(HTML_DIR)
+            if any(part.startswith("_") for part in rel.parts):
+                continue
+            html = page.read_text(encoding="utf-8", errors="replace")
+            for url in re.findall(r'(?:href|src|action)="([^"]*)"', html):
+                target = self.resolve(page, url)
+                if target is None:
+                    continue
+                if not (target.is_file() or (target / "index.html").is_file()):
+                    broken.append(f"{rel} -> {url}")
+        assert broken == []
+
+    def test_pages_canonicalize_to_directory_urls(self, subtests):
+        for page, slug in (
+            ("faq.html", "faq/"),
+            ("api.html", "api/"),
+            ("blog.html", "blog/"),
+        ):
+            with subtests.test(page=page):
+                expected = conf.html_baseurl + slug
+                assert find_canonical(read_html(page)) == expected
+
+    def test_blog_index_og_url_is_directory(self):
+        # opengraph_override hand-builds this one; it used to emit
+        # blog.html, a URL dirhtml never writes.
+        val = og_value(read_html("blog.html"), "og:url")
+        assert val == conf.html_baseurl + "blog/"
+
+    def test_home_canonical_is_root(self):
+        # The home page canonicalizes to the bare domain, not /index.
+        assert find_canonical(read_html("index.html")) == conf.html_baseurl
+
+    def test_sitemap_urls_are_extensionless(self):
+        # The sitemap must agree with the canonical URLs; a stray
+        # .html means the two disagree.
+        sitemap = HTML_DIR / "sitemap.xml"
+        ns = {"s": "http://www.sitemaps.org/schemas/sitemap/0.9"}
+        urls = [
+            u.text
+            for u in ET.parse(sitemap).getroot().findall("s:url/s:loc", ns)
+        ]
+        assert urls
+        assert not [u for u in urls if u.endswith(".html")]
+
+    def test_search_builder_is_dirhtml(self):
+        # searchtools.js builds result URLs as "<docname>/" only when
+        # BUILDER == "dirhtml"; otherwise it appends LINK_SUFFIX
+        # (.html) and every search result 404s.
+        opts = (HTML_DIR / "_static" / "documentation_options.js").read_text()
+        assert "BUILDER: 'dirhtml'" in opts
+
+    def test_no_absolute_self_links_with_html(self):
+        # The link checker skips absolute http(s) URLs, so a hardcoded
+        # "https://psutil.io/faq.html" would slip straight past it.
+        base = conf.html_baseurl.rstrip("/")
+        pat = re.compile(re.escape(base) + r"/[^\s\"'<>]*\.html")
+        bad = []
+        for page in sorted(HTML_DIR.rglob("*.html")):
+            rel = page.relative_to(HTML_DIR)
+            if any(part.startswith("_") for part in rel.parts):
+                continue
+            text = page.read_text(encoding="utf-8", errors="replace")
+            bad += [f"{rel} -> {hit}" for hit in pat.findall(text)]
+        assert bad == []
+
+    def test_atom_feed_urls_are_extensionless(self):
+        # Feed readers persist these; a .html entry id is a dead link
+        # that stays dead in every subscriber's reader.
+        root = ET.parse(HTML_DIR / "blog" / "atom.xml").getroot()
+        urls = feed_urls(root)
+        assert urls
+        assert [u for u in urls if ".html" in u] == []
+
+    def test_objects_inv_uris_are_extensionless(self):
+        # Other projects intersphinx against this inventory; a stale
+        # .html URI breaks every cross-reference they make into us.
+        raw = (HTML_DIR / "objects.inv").read_bytes()
+        # 4 plain-text header lines, then zlib-compressed entries.
+        entries = zlib.decompress(raw.split(b"\n", 4)[4]).decode("utf-8")
+        assert entries
+        assert ".html" not in entries
diff --git a/docs/test_docs_online.py b/docs/test_docs_online.py
new file mode 100644
index 0000000000..a59962fc22
--- /dev/null
+++ b/docs/test_docs_online.py
@@ -0,0 +1,320 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Smoke tests against the live docs site.
+
+Run with:
+
+  PSUTIL_DOCS_ONLINE=1 python3 -m pytest docs/test_docs_online.py
+"""
+
+import http.client
+import os
+import pathlib
+import re
+import socket
+import ssl
+import sys
+import urllib.error
+import urllib.request
+import xml.etree.ElementTree as ET
+from datetime import datetime
+from datetime import timezone
+from urllib.parse import urljoin
+from urllib.parse import urlsplit
+
+import pytest
+
+HERE = pathlib.Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE))
+import conf  # noqa: E402
+from testutil import UTILITY_PAGES  # noqa: E402
+from testutil import feed_urls  # noqa: E402
+from testutil import find_canonical  # noqa: E402
+from testutil import og_value  # noqa: E402
+
+BASE = conf.html_baseurl.rstrip("/") + "/"
+_parts = urlsplit(BASE)
+ORIGIN = f"{_parts.scheme}://{_parts.netloc}/"
+
+pytestmark = pytest.mark.skipif(
+    not os.environ.get("PSUTIL_DOCS_ONLINE"),
+    reason="set PSUTIL_DOCS_ONLINE=1 to run live-site smoke tests",
+)
+
+
+def fetch(url):
+    req = urllib.request.Request(
+        url, headers={"User-Agent": "psutil-docs-test"}
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        return resp.status, resp.read()
+
+
+class TestLiveSite:
+
+    def test_homepage_ok(self):
+        status, _ = fetch(BASE)
+        assert status == 200
+
+    def test_key_endpoints_reachable(self, subtests):
+        urls = [
+            BASE + "sitemap.xml",
+            BASE + "objects.inv",
+            BASE + "blog/atom.xml",
+            ORIGIN + "robots.txt",
+        ]
+        for url in urls:
+            with subtests.test(url=url):
+                status, _ = fetch(url)
+                assert status == 200
+
+    def test_sitemap_has_many_urls(self):
+        _, body = fetch(BASE + "sitemap.xml")
+        assert body.count(b"<url>") >= 20
+
+    def test_fonts_are_self_hosted(self, subtests):
+        for name in ("inter-400.woff2", "fa-solid-subset.woff2"):
+            with subtests.test(font=name):
+                status, _ = fetch(BASE + "_static/fonts/" + name)
+                assert status == 200
+
+    def test_homepage_canonical_matches_baseurl(self):
+        url = find_canonical(fetch(BASE)[1].decode("utf-8", "replace"))
+        assert url is not None
+        assert url.startswith(BASE)
+
+    def test_homepage_has_og_tags(self, subtests):
+        html = fetch(BASE)[1].decode("utf-8", "replace")
+        for prop in ("og:title", "og:image"):
+            with subtests.test(prop=prop):
+                assert f'property="{prop}"' in html
+
+    def test_og_urls_match_baseurl(self, subtests):
+        html = fetch(BASE)[1].decode("utf-8", "replace")
+        for prop, prefix in (("og:url", BASE), ("og:image", ORIGIN)):
+            with subtests.test(prop=prop):
+                val = og_value(html, prop)
+                assert val is not None
+                assert val.startswith(prefix)
+
+    def test_search_index_reachable(self):
+        status, _ = fetch(BASE + "searchindex.js")
+        assert status == 200
+
+    def test_http_redirects_to_https(self):
+        # Enforce-HTTPS: http must redirect to https.
+        conn = http.client.HTTPConnection(urlsplit(BASE).netloc, timeout=30)
+        try:
+            conn.request(
+                "GET", "/", headers={"User-Agent": "psutil-docs-test"}
+            )
+            resp = conn.getresponse()
+            assert resp.status in {301, 302, 307, 308}
+            assert resp.getheader("Location", "").startswith("https://")
+        finally:
+            conn.close()
+
+    def test_custom_404_page(self):
+        # A missing path returns the custom 404, not a bare error.
+        with pytest.raises(urllib.error.HTTPError) as exc:
+            fetch(BASE + "no-such-page-zzz.html")
+        assert exc.value.code == 404
+        assert b"psutil" in exc.value.read().lower()
+
+    def test_old_html_urls_are_gone(self):
+        # dirhtml serves content at /faq/, not /faq.html. The old .html
+        # form must 404, not silently serve a stale duplicate.
+        with pytest.raises(urllib.error.HTTPError) as exc:
+            fetch(BASE + "faq.html")
+        assert exc.value.code == 404
+
+    def test_404_deep_path_links_absolute(self, subtests):
+        # The custom 404 is served for any missing path, deep ones
+        # included. Every link on it must be absolute, else it resolves
+        # against the request path and 404s again. Regression: dirhtml
+        # left the body cross-references and logo relative.
+        with pytest.raises(urllib.error.HTTPError) as exc:
+            fetch(BASE + "no/such/deep/page-zzz")
+        assert exc.value.code == 404
+        html = exc.value.read().decode("utf-8", "replace")
+        links = re.findall(r'(?:href|src)="([^"]+)"', html)
+        rel = [
+            u
+            for u in links
+            if not u.startswith(
+                ("/", "http://", "https://", "//", "#", "mailto:")
+            )
+        ]
+        assert rel == []
+        # The absolute nav links must actually resolve.
+        targets = sorted(set(re.findall(r'"(/[a-z][a-z-]*/)"', html)))[:5]
+        assert targets
+        for t in targets:
+            with subtests.test(url=t):
+                assert fetch(ORIGIN.rstrip("/") + t)[0] == 200
+
+    def test_content_pages_reachable(self, subtests):
+        # dirhtml serves /api/; the no-slash /api 301-redirects to it
+        # (urllib follows). The .html form no longer exists.
+        for page in ("api/", "faq/", "api", "faq"):
+            with subtests.test(page=page):
+                status, body = fetch(BASE + page)
+                assert status == 200
+                assert b"psutil" in body.lower()
+
+    def test_atom_feed_rooted_at_baseurl(self):
+        root = ET.fromstring(fetch(BASE + "blog/atom.xml")[1])
+        bad = [u for u in feed_urls(root) if not u.startswith(BASE)]
+        assert bad == []
+
+    def test_no_readthedocs_in_metadata(self):
+        html = fetch(BASE)[1].decode("utf-8", "replace")
+        head = html.split("</head>", 1)[0]
+        assert "readthedocs" not in head.lower()
+
+    def test_homepage_internal_links_resolve(self, subtests):
+        html = fetch(BASE)[1].decode("utf-8", "replace")
+        pages = set()
+        for h in re.findall(r'href="([^"]+)"', html):
+            path = h.split("#", 1)[0]
+            if (
+                h.startswith(("http://", "https://", "//", "mailto:", "#"))
+                or "_static/" in h
+                or "_images/" in h
+                or path.rstrip("/").rsplit("/", 1)[-1] in UTILITY_PAGES
+            ):
+                continue
+            pages.add(urljoin(BASE, path))
+        for url in sorted(pages):
+            with subtests.test(link=url):
+                status, _ = fetch(url)
+                assert status == 200
+
+    def test_sitemap_has_lastmod(self):
+        # Regression: a shallow CI checkout drops git dates, leaving
+        # the sitemap without <lastmod>. Needs fetch-depth: 0.
+        body = fetch(BASE + "sitemap.xml")[1]
+        assert b"<lastmod>" in body
+
+    def test_sitemap_urls_resolve(self, subtests):
+        # A page left in the sitemap after removal is a dead link handed
+        # to search engines. Spot-check a sample (homepage-links covers
+        # the linked pages; this covers the sitemap itself).
+        body = fetch(BASE + "sitemap.xml")[1].decode("utf-8", "replace")
+        for url in re.findall(r"<loc>([^<]+)</loc>", body)[::4]:
+            with subtests.test(url=url):
+                assert fetch(url)[0] == 200
+
+    def test_og_image_resolves(self):
+        # The social-card image must exist, else shared links render a
+        # blank preview.
+        img = og_value(fetch(BASE)[1].decode("utf-8", "replace"), "og:image")
+        assert img is not None
+        assert fetch(img)[0] == 200
+
+    def test_robots_references_sitemap(self):
+        body = fetch(ORIGIN + "robots.txt")[1].decode("utf-8", "replace")
+        assert "sitemap.xml" in body.lower()
+
+    def test_no_external_stylesheets(self):
+        # Stylesheets / preloads must be self-hosted (analytics
+        # <script>s are deliberately external and don't count).
+        html = fetch(BASE)[1].decode("utf-8", "replace")
+        tags = re.findall(
+            r'<link\b[^>]*\brel="(?:stylesheet|preload)"[^>]*>', html
+        )
+        hrefs = [h for t in tags for h in re.findall(r'\bhref="([^"]+)"', t)]
+        external = [
+            u for u in hrefs if u.startswith(("http://", "https://", "//"))
+        ]
+        assert external == []
+
+    def test_utility_pages_noindex(self, subtests):
+        noindex = re.compile(
+            r'<meta[^>]*name="robots"[^>]*content="noindex"', re.IGNORECASE
+        )
+        for name in ("genindex/", "404/"):
+            body = fetch(BASE + name)[1].decode("utf-8", "replace")
+            with subtests.test(page=name):
+                assert noindex.search(body)
+
+    def test_tls_certificate_is_valid(self):
+        # create_default_context verifies chain + hostname, so an
+        # expired or mismatched cert raises here. Custom-domain certs
+        # are re-provisioned whenever the Pages domain is touched,
+        # which is exactly when they break.
+        host = urlsplit(BASE).netloc
+        ctx = ssl.create_default_context()
+        with socket.create_connection((host, 443), timeout=30) as sock:
+            with ctx.wrap_socket(sock, server_hostname=host) as ssock:
+                cert = ssock.getpeercert()
+        assert cert
+        expires = datetime.strptime(
+            cert["notAfter"], "%b %d %H:%M:%S %Y %Z"
+        ).replace(tzinfo=timezone.utc)
+        left = (expires - datetime.now(timezone.utc)).days
+        assert left > 20, f"TLS cert expires in {left} days"
+
+    def test_no_slash_url_redirects_to_directory(self):
+        # /api/ is the canonical dirhtml URL. The no-slash form must
+        # 301 to it; serving 200 at both would be the same page under
+        # two URLs.
+        conn = http.client.HTTPSConnection(urlsplit(BASE).netloc, timeout=30)
+        try:
+            conn.request(
+                "GET", "/api", headers={"User-Agent": "psutil-docs-test"}
+            )
+            resp = conn.getresponse()
+            assert resp.status in {301, 302, 307, 308}
+            assert resp.getheader("Location", "").endswith("/api/")
+        finally:
+            conn.close()
+
+    def test_robots_allows_indexing(self):
+        # A stray "Disallow: /" would deindex the whole site, silently.
+        body = fetch(ORIGIN + "robots.txt")[1].decode("utf-8", "replace")
+        rules = [line.strip().lower() for line in body.splitlines()]
+        assert "disallow: /" not in rules
+
+    def test_homepage_is_indexable(self):
+        # A global noindex (say a bad layout.html edit) would quietly
+        # drop the entire site from search results.
+        html = fetch(BASE)[1].decode("utf-8", "replace")
+        assert not re.search(
+            r'<meta[^>]*name="robots"[^>]*noindex', html, re.IGNORECASE
+        )
+
+
+class TestReadTheDocsRedirects:
+    """The old RTD site now redirects to psutil.io."""
+
+    HOST = "psutil.readthedocs.io"
+
+    def get(self, path):
+        # Raw connection, so the redirect isn't followed.
+        conn = http.client.HTTPSConnection(self.HOST, timeout=30)
+        try:
+            conn.request(
+                "GET", path, headers={"User-Agent": "psutil-docs-test"}
+            )
+            resp = conn.getresponse()
+            return resp.status, resp.getheader("Location", "")
+        finally:
+            conn.close()
+
+    def test_dev_urls_redirect_to_psutil_io(self, subtests):
+        # 301, not 302: search engines only transfer ranking on a
+        # permanent redirect, and these URLs are linked all over.
+        for path in ("/en/latest/", "/latest/"):
+            with subtests.test(path=path):
+                status, location = self.get(path)
+                assert status == 301
+                assert location == ORIGIN
+
+    def test_stable_still_serves_released_docs(self):
+        # TEMPORARY, remove with the dev banner: it links here, so a
+        # catch-all redirect on the RTD side would break it.
+        status, _ = self.get("/stable/")
+        assert status == 200
diff --git a/docs/testutil.py b/docs/testutil.py
new file mode 100644
index 0000000000..054e4a5248
--- /dev/null
+++ b/docs/testutil.py
@@ -0,0 +1,58 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Shared HTML/feed parsing helpers for the docs test suites.
+
+Imported by both test_docs.py (offline, on the built HTML) and
+test_docs_online.py (live site), so the two can't drift on how they
+extract the same things.
+"""
+
+import re
+
+ATOM_NS = {"a": "http://www.w3.org/2005/Atom"}
+
+# Sphinx-generated utility pages (search box, general index, module
+# index). Not real content, so link checks skip them. Slugs, matching
+# the dirhtml URLs (e.g. /genindex/).
+UTILITY_PAGES = {"search", "genindex", "py-modindex"}
+
+
+def find_canonical(html):
+    """The <link rel="canonical"> href, or None. Attribute order
+    varies between Sphinx versions, so match both.
+    """
+    m = re.search(
+        r'<link rel="canonical" href="([^"]+)"'
+        r'|<link href="([^"]+)" rel="canonical"',
+        html,
+    )
+    return (m.group(1) or m.group(2)) if m else None
+
+
+def og_value(html, prop):
+    """The `content` of a `<meta property="og:...">` tag, or None.
+    Sphinx and ablog don't agree on attribute order, so accept both.
+    """
+    m = re.search(
+        rf'<meta (?:property="{prop}" content="([^"]*)"'
+        rf'|content="([^"]*)" property="{prop}")',
+        html,
+    )
+    return (m.group(1) or m.group(2)) if m else None
+
+
+def feed_urls(root):
+    """All feed-level + per-entry URLs (link hrefs + entry ids) from a
+    parsed atom feed root element.
+    """
+    urls = [link.get("href") for link in root.findall("a:link", ATOM_NS)]
+    for entry in root.findall("a:entry", ATOM_NS):
+        idel = entry.find("a:id", ATOM_NS)
+        if idel is not None:
+            urls.append(idel.text)
+        urls.extend(
+            link.get("href") for link in entry.findall("a:link", ATOM_NS)
+        )
+    return [u for u in urls if u]
diff --git a/docs/timeline.rst b/docs/timeline.rst
new file mode 100644
index 0000000000..763fcb8646
--- /dev/null
+++ b/docs/timeline.rst
@@ -0,0 +1,630 @@
+Timeline
+========
+
+2026
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`7.2.2`
+     - 2026-01-28
+     - :ref:`what's new <722>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-7.2.1...release-7.2.2#files_bucket>`__
+
+2025
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`7.2.1`
+     - 2025-12-29
+     - :ref:`what's new <721>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-7.2.0...release-7.2.1#files_bucket>`__
+   * - :pypi:`7.2.0`
+     - 2025-12-23
+     - :ref:`what's new <720>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-7.1.3...release-7.2.0#files_bucket>`__
+   * - :pypi:`7.1.3`
+     - 2025-11-02
+     - :ref:`what's new <713>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-7.1.2...release-7.1.3#files_bucket>`__
+   * - :pypi:`7.1.2`
+     - 2025-10-25
+     - :ref:`what's new <712>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-7.1.1...release-7.1.2#files_bucket>`__
+   * - :pypi:`7.1.1`
+     - 2025-10-19
+     - :ref:`what's new <711>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-7.1.0...release-7.1.1#files_bucket>`__
+   * - :pypi:`7.1.0`
+     - 2025-09-17
+     - :ref:`what's new <710>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-7.0.0...release-7.1.0#files_bucket>`__
+   * - :pypi:`7.0.0`
+     - 2025-02-13
+     - :ref:`what's new <700>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-6.1.1...release-7.0.0#files_bucket>`__
+
+2024
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`6.1.1`
+     - 2024-12-19
+     - :ref:`what's new <611>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-6.1.0...release-6.1.1#files_bucket>`__
+   * - :pypi:`6.1.0`
+     - 2024-10-17
+     - :ref:`what's new <610>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-6.0.0...release-6.1.0#files_bucket>`__
+   * - :pypi:`6.0.0`
+     - 2024-06-18
+     - :ref:`what's new <600>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.9.8...release-6.0.0#files_bucket>`__
+   * - :pypi:`5.9.8`
+     - 2024-01-19
+     - :ref:`what's new <598>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.9.7...release-5.9.8#files_bucket>`__
+
+2023
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`5.9.7`
+     - 2023-12-17
+     - :ref:`what's new <597>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.9.6...release-5.9.7#files_bucket>`__
+   * - :pypi:`5.9.6`
+     - 2023-10-15
+     - :ref:`what's new <596>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.9.5...release-5.9.6#files_bucket>`__
+   * - :pypi:`5.9.5`
+     - 2023-04-17
+     - :ref:`what's new <595>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.9.4...release-5.9.5#files_bucket>`__
+
+2022
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`5.9.4`
+     - 2022-11-07
+     - :ref:`what's new <594>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.9.3...release-5.9.4#files_bucket>`__
+   * - :pypi:`5.9.3`
+     - 2022-10-18
+     - :ref:`what's new <593>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.9.2...release-5.9.3#files_bucket>`__
+   * - :pypi:`5.9.2`
+     - 2022-09-04
+     - :ref:`what's new <592>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.9.1...release-5.9.2#files_bucket>`__
+   * - :pypi:`5.9.1`
+     - 2022-05-20
+     - :ref:`what's new <591>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.9.0...release-5.9.1#files_bucket>`__
+
+2021
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`5.9.0`
+     - 2021-12-29
+     - :ref:`what's new <590>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.8.0...release-5.9.0#files_bucket>`__
+
+2020
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`5.8.0`
+     - 2020-12-19
+     - :ref:`what's new <580>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.7.3...release-5.8.0#files_bucket>`__
+   * - :pypi:`5.7.3`
+     - 2020-10-24
+     - :ref:`what's new <573>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.7.2...release-5.7.3#files_bucket>`__
+   * - :pypi:`5.7.2`
+     - 2020-07-15
+     - :ref:`what's new <572>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.7.1...release-5.7.2#files_bucket>`__
+   * - :pypi:`5.7.1`
+     - 2020-07-15
+     - :ref:`what's new <571>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.7.0...release-5.7.1#files_bucket>`__
+   * - :pypi:`5.7.0`
+     - 2020-02-18
+     - :ref:`what's new <570>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.6.7...release-5.7.0#files_bucket>`__
+
+2019
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`5.6.7`
+     - 2019-11-26
+     - :ref:`what's new <567>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.6.6...release-5.6.7#files_bucket>`__
+   * - :pypi:`5.6.6`
+     - 2019-11-25
+     - :ref:`what's new <566>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.6.5...release-5.6.6#files_bucket>`__
+   * - :pypi:`5.6.5`
+     - 2019-11-06
+     - :ref:`what's new <565>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.6.4...release-5.6.5#files_bucket>`__
+   * - :pypi:`5.6.4`
+     - 2019-11-04
+     - :ref:`what's new <564>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.6.3...release-5.6.4#files_bucket>`__
+   * - :pypi:`5.6.3`
+     - 2019-06-11
+     - :ref:`what's new <563>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.6.2...release-5.6.3#files_bucket>`__
+   * - :pypi:`5.6.2`
+     - 2019-04-26
+     - :ref:`what's new <562>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.6.1...release-5.6.2#files_bucket>`__
+   * - :pypi:`5.6.1`
+     - 2019-03-11
+     - :ref:`what's new <561>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.6.0...release-5.6.1#files_bucket>`__
+   * - :pypi:`5.6.0`
+     - 2019-03-05
+     - :ref:`what's new <560>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.5.1...release-5.6.0#files_bucket>`__
+   * - :pypi:`5.5.1`
+     - 2019-02-15
+     - :ref:`what's new <551>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.5.0...release-5.5.1#files_bucket>`__
+   * - :pypi:`5.5.0`
+     - 2019-01-23
+     - :ref:`what's new <550>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.4.8...release-5.5.0#files_bucket>`__
+
+2018
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`5.4.8`
+     - 2018-10-30
+     - :ref:`what's new <548>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.4.7...release-5.4.8#files_bucket>`__
+   * - :pypi:`5.4.7`
+     - 2018-08-14
+     - :ref:`what's new <547>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.4.6...release-5.4.7#files_bucket>`__
+   * - :pypi:`5.4.6`
+     - 2018-06-07
+     - :ref:`what's new <546>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.4.5...release-5.4.6#files_bucket>`__
+   * - :pypi:`5.4.5`
+     - 2018-04-13
+     - :ref:`what's new <545>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.4.4...release-5.4.5#files_bucket>`__
+   * - :pypi:`5.4.4`
+     - 2018-04-13
+     - :ref:`what's new <544>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.4.3...release-5.4.4#files_bucket>`__
+   * - :pypi:`5.4.3`
+     - 2018-01-01
+     - :ref:`what's new <543>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.4.2...release-5.4.3#files_bucket>`__
+
+2017
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`5.4.2`
+     - 2017-12-07
+     - :ref:`what's new <542>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.4.1...release-5.4.2#files_bucket>`__
+   * - :pypi:`5.4.1`
+     - 2017-11-08
+     - :ref:`what's new <541>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.4.0...release-5.4.1#files_bucket>`__
+   * - :pypi:`5.4.0`
+     - 2017-10-12
+     - :ref:`what's new <540>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.3.1...release-5.4.0#files_bucket>`__
+   * - :pypi:`5.3.1`
+     - 2017-09-10
+     - :ref:`what's new <531>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.3.0...release-5.3.1#files_bucket>`__
+   * - :pypi:`5.3.0`
+     - 2017-09-01
+     - :ref:`what's new <530>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.2.2...release-5.3.0#files_bucket>`__
+   * - :pypi:`5.2.2`
+     - 2017-04-10
+     - :ref:`what's new <522>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.2.1...release-5.2.2#files_bucket>`__
+   * - :pypi:`5.2.1`
+     - 2017-03-24
+     - :ref:`what's new <521>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.2.0...release-5.2.1#files_bucket>`__
+   * - :pypi:`5.2.0`
+     - 2017-03-05
+     - :ref:`what's new <520>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.1.3...release-5.2.0#files_bucket>`__
+   * - :pypi:`5.1.3`
+     - 2017-02-07
+     - :ref:`what's new <513>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.1.2...release-5.1.3#files_bucket>`__
+   * - :pypi:`5.1.2`
+     - 2017-02-03
+     - :ref:`what's new <512>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.1.1...release-5.1.2#files_bucket>`__
+   * - :pypi:`5.1.1`
+     - 2017-02-03
+     - :ref:`what's new <511>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.1.0...release-5.1.1#files_bucket>`__
+   * - :pypi:`5.1.0`
+     - 2017-02-01
+     - :ref:`what's new <510>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.0.1...release-5.1.0#files_bucket>`__
+
+2016
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`5.0.1`
+     - 2016-12-21
+     - :ref:`what's new <501>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-5.0.0...release-5.0.1#files_bucket>`__
+   * - :pypi:`5.0.0`
+     - 2016-11-06
+     - :ref:`what's new <500>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-4.4.2...release-5.0.0#files_bucket>`__
+   * - :pypi:`4.4.2`
+     - 2016-10-26
+     - :ref:`what's new <442>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-4.4.1...release-4.4.2#files_bucket>`__
+   * - :pypi:`4.4.1`
+     - 2016-10-25
+     - :ref:`what's new <441>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-4.4.0...release-4.4.1#files_bucket>`__
+   * - :pypi:`4.4.0`
+     - 2016-10-23
+     - :ref:`what's new <440>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-4.3.1...release-4.4.0#files_bucket>`__
+   * - :pypi:`4.3.1`
+     - 2016-09-01
+     - :ref:`what's new <431>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-4.3.0...release-4.3.1#files_bucket>`__
+   * - :pypi:`4.3.0`
+     - 2016-06-18
+     - :ref:`what's new <430>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-4.2.0...release-4.3.0#files_bucket>`__
+   * - :pypi:`4.2.0`
+     - 2016-05-14
+     - :ref:`what's new <420>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-4.1.0...release-4.2.0#files_bucket>`__
+   * - :pypi:`4.1.0`
+     - 2016-03-12
+     - :ref:`what's new <410>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-4.0.0...release-4.1.0#files_bucket>`__
+   * - :pypi:`4.0.0`
+     - 2016-02-17
+     - :ref:`what's new <400>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-3.4.2...release-4.0.0#files_bucket>`__
+   * - :pypi:`3.4.2`
+     - 2016-01-20
+     - :ref:`what's new <342>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-3.4.1...release-3.4.2#files_bucket>`__
+   * - :pypi:`3.4.1`
+     - 2016-01-15
+     - :ref:`what's new <341>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-3.3.0...release-3.4.1#files_bucket>`__
+
+2015
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`3.3.0`
+     - 2015-11-25
+     - :ref:`what's new <330>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-3.2.2...release-3.3.0#files_bucket>`__
+   * - :pypi:`3.2.2`
+     - 2015-10-04
+     - :ref:`what's new <322>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-3.2.1...release-3.2.2#files_bucket>`__
+   * - :pypi:`3.2.1`
+     - 2015-09-03
+     - :ref:`what's new <321>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-3.2.0...release-3.2.1#files_bucket>`__
+   * - :pypi:`3.2.0`
+     - 2015-09-02
+     - :ref:`what's new <320>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-3.1.1...release-3.2.0#files_bucket>`__
+   * - :pypi:`3.1.1`
+     - 2015-07-15
+     - :ref:`what's new <311>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-3.1.0...release-3.1.1#files_bucket>`__
+   * - :pypi:`3.1.0`
+     - 2015-07-15
+     - :ref:`what's new <310>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-3.0.1...release-3.1.0#files_bucket>`__
+   * - :pypi:`3.0.1`
+     - 2015-06-18
+     - :ref:`what's new <301>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-3.0.0...release-3.0.1#files_bucket>`__
+   * - :pypi:`3.0.0`
+     - 2015-06-13
+     - :ref:`what's new <300>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-2.2.1...release-3.0.0#files_bucket>`__
+   * - :pypi:`2.2.1`
+     - 2015-02-02
+     - :ref:`what's new <221>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-2.2.0...release-2.2.1#files_bucket>`__
+   * - :pypi:`2.2.0`
+     - 2015-01-06
+     - :ref:`what's new <220>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-2.1.3...release-2.2.0#files_bucket>`__
+
+2014
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`2.1.3`
+     - 2014-09-26
+     - :ref:`what's new <213>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-2.1.2...release-2.1.3#files_bucket>`__
+   * - :pypi:`2.1.2`
+     - 2014-09-21
+     - :ref:`what's new <212>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-2.1.1...release-2.1.2#files_bucket>`__
+   * - :pypi:`2.1.1`
+     - 2014-04-30
+     - :ref:`what's new <211>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-2.1.0...release-2.1.1#files_bucket>`__
+   * - :pypi:`2.1.0`
+     - 2014-04-08
+     - :ref:`what's new <210>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-2.0.0...release-2.1.0#files_bucket>`__
+   * - :pypi:`2.0.0`
+     - 2014-03-10
+     - :ref:`what's new <200>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-1.2.1...release-2.0.0#files_bucket>`__
+
+2013
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`1.2.1`
+     - 2013-11-25
+     - :ref:`what's new <121>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-1.2.0...release-1.2.1#files_bucket>`__
+   * - :pypi:`1.2.0`
+     - 2013-11-20
+     - :ref:`what's new <120>`
+     - `diff <https://github.com/giampaolo/psutil/compare/2f69cb22...release-1.2.0#files_bucket>`__
+   * - :pypi:`1.1.3`
+     - 2013-11-07
+     - :ref:`what's new <113>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-1.1.2...2f69cb22#files_bucket>`__
+   * - :pypi:`1.1.2`
+     - 2013-10-22
+     - :ref:`what's new <112>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-1.1.1...release-1.1.2#files_bucket>`__
+   * - :pypi:`1.1.1`
+     - 2013-10-08
+     - :ref:`what's new <111>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-1.1.0...release-1.1.1#files_bucket>`__
+   * - :pypi:`1.1.0`
+     - 2013-09-28
+     - :ref:`what's new <110>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-1.0.1...release-1.1.0#files_bucket>`__
+   * - :pypi:`1.0.1`
+     - 2013-07-12
+     - :ref:`what's new <101>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-1.0.0...release-1.0.1#files_bucket>`__
+   * - :pypi:`1.0.0`
+     - 2013-07-10
+     - :ref:`what's new <100>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.7.1...release-1.0.0#files_bucket>`__
+   * - :pypi:`0.7.1`
+     - 2013-05-03
+     - :ref:`what's new <071>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.7.0...release-0.7.1#files_bucket>`__
+   * - :pypi:`0.7.0`
+     - 2013-04-12
+     - :ref:`what's new <070>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.6.1...release-0.7.0#files_bucket>`__
+
+2012
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`0.6.1`
+     - 2012-08-16
+     - :ref:`what's new <061>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.6.0...release-0.6.1#files_bucket>`__
+   * - :pypi:`0.6.0`
+     - 2012-08-13
+     - :ref:`what's new <060>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.5.1...release-0.6.0#files_bucket>`__
+   * - :pypi:`0.5.1`
+     - 2012-06-29
+     - :ref:`what's new <051>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.5.0...release-0.5.1#files_bucket>`__
+   * - :pypi:`0.5.0`
+     - 2012-06-27
+     - :ref:`what's new <050>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.4.1...release-0.5.0#files_bucket>`__
+
+2011
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`0.4.1`
+     - 2011-12-14
+     - :ref:`what's new <041>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.4.0...release-0.4.1#files_bucket>`__
+   * - :pypi:`0.4.0`
+     - 2011-10-29
+     - :ref:`what's new <040>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.3.0...release-0.4.0#files_bucket>`__
+   * - :pypi:`0.3.0`
+     - 2011-07-08
+     - :ref:`what's new <030>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.2.1...release-0.3.0#files_bucket>`__
+   * - :pypi:`0.2.1`
+     - 2011-03-20
+     - :ref:`what's new <021>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.2.0...release-0.2.1#files_bucket>`__
+
+2010
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`0.2.0`
+     - 2010-11-13
+     - :ref:`what's new <020>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.1.3...release-0.2.0#files_bucket>`__
+   * - :pypi:`0.1.3`
+     - 2010-03-02
+     - :ref:`what's new <013>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.1.2...release-0.1.3#files_bucket>`__
+
+2009
+~~~~
+
+.. list-table::
+   :header-rows: 1
+   :widths: 30 50 40 20
+
+   * - Version
+     - Date
+     - Notes
+     - Diff
+   * - :pypi:`0.1.2`
+     - 2009-05-06
+     - :ref:`what's new <012>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.1.1...release-0.1.2#files_bucket>`__
+   * - :pypi:`0.1.1`
+     - 2009-03-06
+     - :ref:`what's new <011>`
+     - `diff <https://github.com/giampaolo/psutil/compare/release-0.1.0...release-0.1.1#files_bucket>`__
+   * - :pypi:`0.1.0`
+     - 2009-01-27
+     - :ref:`what's new <010>`
+     - `diff <https://github.com/giampaolo/psutil/compare/d84cc9a7...release-0.1.0#files_bucket>`__
diff --git a/docs/versions.json b/docs/versions.json
new file mode 100644
index 0000000000..306bc53ab5
--- /dev/null
+++ b/docs/versions.json
@@ -0,0 +1,7 @@
+{
+    "current": "dev",
+    "versions": [
+        { "name": "dev", "url": "/", "note": "main site" },
+        { "name": "7.2", "url": "/7.2/", "note": "release", "ref": "v7.2.2" }
+    ]
+}
diff --git a/make.bat b/make.bat
deleted file mode 100644
index c4736e89af..0000000000
--- a/make.bat
+++ /dev/null
@@ -1,246 +0,0 @@
-@echo off
-
-rem ==========================================================================
-rem Shortcuts for various tasks, emulating UNIX "make" on Windows.
-rem It is primarly intended as a shortcut for compiling / installing
-rem psutil ("make.bat build", "make.bat install") and running tests
-rem ("make.bat test").
-rem
-rem This script is modeled after my Windows installation which uses:
-rem - Visual studio 2008 for Python 2.6, 2.7, 3.2
-rem - Visual studio 2010 for Python 3.3+
-rem ...therefore it might not work on your Windows installation.
-rem
-rem By default C:\Python27\python.exe is used.
-rem To compile for a specific Python version run:
-rem     set PYTHON=C:\Python34\python.exe & make.bat build
-rem
-rem To use a different test script:
-rem      set PYTHON=C:\Python34\python.exe & set TSCRIPT=foo.py & make.bat test
-rem ==========================================================================
-
-if "%PYTHON%" == "" (
-    set PYTHON=C:\Python27\python.exe
-)
-if "%TSCRIPT%" == "" (
-    set TSCRIPT=psutil\tests\runner.py
-)
-
-set VSINSTALLDIR=%VS90COMNTOOLS%..\..
-
-set PYTHON26=C:\Python26\python.exe
-set PYTHON27=C:\Python27\python.exe
-set PYTHON33=C:\Python33\python.exe
-set PYTHON34=C:\Python34\python.exe
-set PYTHON35=C:\Python35\python.exe
-set PYTHON26-64=C:\Python26-64\python.exe
-set PYTHON27-64=C:\Python27-64\python.exe
-set PYTHON33-64=C:\Python33-64\python.exe
-set PYTHON34-64=C:\Python34-64\python.exe
-set PYTHON35-64=C:\Python35-64\python.exe
-
-set ALL_PYTHONS=%PYTHON26% %PYTHON27% %PYTHON33% %PYTHON34% %PYTHON35% %PYTHON26-64% %PYTHON27-64% %PYTHON33-64% %PYTHON34-64% %PYTHON35-64%
-
-rem Needed to locate the .pypirc file and upload exes on PYPI.
-set HOME=%USERPROFILE%
-
-rem ==========================================================================
-
-if "%1" == "help" (
-    :help
-    echo Run `make ^<target^>` where ^<target^> is one of:
-    echo   build         compile without installing
-    echo   build-all     build exes + wheels
-    echo   clean         clean build files
-    echo   flake8        run flake8
-    echo   install       compile and install
-    echo   setup-dev-env install/upgrade pip, pywin32, wheels, etc.
-    echo   setup-dev-env-all same as above, for all python versions
-    echo   test          run tests
-    echo   test-memleaks run memory leak tests
-    echo   test-process  run process related tests
-    echo   test-system   run system APIs related tests
-    echo   test-platform platform-specific Windows tests
-    echo   uninstall     uninstall
-    echo   upload-all    upload exes + wheels
-    goto :eof
-)
-
-if "%1" == "clean" (
-    for /r %%R in (__pycache__) do if exist %%R (rmdir /S /Q %%R)
-    for /r %%R in (*.pyc) do if exist %%R (del /s %%R)
-    for /r %%R in (*.pyd) do if exist %%R (del /s %%R)
-    for /r %%R in (*.orig) do if exist %%R (del /s %%R)
-    for /r %%R in (*.bak) do if exist %%R (del /s %%R)
-    for /r %%R in (*.rej) do if exist %%R (del /s %%R)
-    if exist psutil.egg-info (rmdir /S /Q psutil.egg-info)
-    if exist build (rmdir /S /Q build)
-    if exist dist (rmdir /S /Q dist)
-    goto :eof
-)
-
-if "%1" == "build" (
-    :build
-    "%VSINSTALLDIR%\VC\bin\vcvars64.bat"
-    %PYTHON% setup.py build
-    if %errorlevel% neq 0 goto :error
-	rem copies *.pyd files in ./psutil directory in order to allow
-	rem "import psutil" when using the interactive interpreter from
-    rem within this directory.
-    %PYTHON% setup.py build_ext -i
-    if %errorlevel% neq 0 goto :error
-    goto :eof
-)
-
-if "%1" == "install" (
-    :install
-    call :build
-    %PYTHON% setup.py develop
-    goto :eof
-)
-
-if "%1" == "uninstall" (
-    for %%A in ("%PYTHON%") do (
-        set folder=%%~dpA
-    )
-    for /F "delims=" %%i in ('dir /b %folder%\Lib\site-packages\*psutil*') do (
-        rmdir /S /Q %folder%\Lib\site-packages\%%i
-    )
-    goto :eof
-)
-
-if "%1" == "test" (
-    call :install
-    %PYTHON% %TSCRIPT%
-    goto :eof
-)
-
-if "%1" == "test-process" (
-    call :install
-    %PYTHON% -m unittest -v psutil.tests.test_process
-    goto :eof
-)
-
-if "%1" == "test-system" (
-    call :install
-    %PYTHON% -m unittest -v psutil.tests.test_system
-    goto :eof
-)
-
-f "%1" == "test-platform" (
-    call :install
-    %PYTHON% psutil\tests\test_windows.py
-    goto :eof
-)
-
-if "%1" == "test-by-name" (
-    call :install
-    %PYTHON% -m nose psutil\tests\test_process.py psutil\tests\test_system.py psutil\tests\test_windows.py psutil\tests\test_misc.py --nocapture -v -m %2
-    goto :eof
-)
-
-if "%1" == "test-memleaks" (
-    call :install
-    %PYTHON% test\test_memory_leaks.py
-    goto :eof
-)
-
-if "%1" == "build-all" (
-    :build-all
-    "%VSINSTALLDIR%\VC\bin\vcvars64.bat"
-    for %%P in (%ALL_PYTHONS%) do (
-        @echo ------------------------------------------------
-        @echo building exe for %%P
-        @echo ------------------------------------------------
-        %%P setup.py build bdist_wininst || goto :error
-        @echo ------------------------------------------------
-        @echo building wheel for %%P
-        @echo ------------------------------------------------
-        %%P setup.py build bdist_wheel || goto :error
-    )
-    echo OK
-    goto :eof
-)
-
-if "%1" == "upload-all" (
-    :upload-exes
-    "%VSINSTALLDIR%\VC\bin\vcvars64.bat"
-    for %%P in (%ALL_PYTHONS%) do (
-        @echo ------------------------------------------------
-        @echo uploading exe for %%P
-        @echo ------------------------------------------------
-        %%P setup.py build bdist_wininst upload || goto :error
-        @echo ------------------------------------------------
-        @echo uploading wheel for %%P
-        @echo ------------------------------------------------
-        %%P setup.py build bdist_wheel upload || goto :error
-    )
-    echo OK
-    goto :eof
-)
-
-if "%1" == "setup-dev-env" (
-    :setup-env
-    if not exist get-pip.py (
-        @echo ------------------------------------------------
-        @echo downloading pip installer
-        @echo ------------------------------------------------
-        C:\python27\python.exe -c "import urllib2; r = urllib2.urlopen('https://bootstrap.pypa.io/get-pip.py'); open('get-pip.py', 'wb').write(r.read())"
-    )
-    @echo ------------------------------------------------
-    @echo installing pip for %PYTHON%
-    @echo ------------------------------------------------
-    %PYTHON% get-pip.py
-    @echo ------------------------------------------------
-    @echo upgrade pip for %PYTHON%
-    @echo ------------------------------------------------
-    %PYTHON% -m pip install pip --upgrade
-    @echo ------------------------------------------------
-    @echo installing deps
-    @echo ------------------------------------------------
-    rem mandatory / for unittests
-    %PYTHON% -m pip install unittest2 ipaddress mock wmi wheel pypiwin32 --upgrade
-    rem nice to have
-    rem %PYTHON% -m pip install ipdb nose --upgrade
-    goto :eof
-)
-
-if "%1" == "setup-dev-env-all" (
-    :setup-env
-    if not exist get-pip.py (
-        @echo ------------------------------------------------
-        @echo downloading pip installer
-        @echo ------------------------------------------------
-        C:\python27\python.exe -c "import urllib2; r = urllib2.urlopen('https://bootstrap.pypa.io/get-pip.py'); open('get-pip.py', 'wb').write(r.read())"
-    )
-    for %%P in (%ALL_PYTHONS%) do (
-        @echo ------------------------------------------------
-        @echo installing pip for %%P
-        @echo ------------------------------------------------
-        %%P get-pip.py
-        @echo ------------------------------------------------
-        @echo installing deps for %%P
-        @echo ------------------------------------------------
-        rem mandatory / for unittests
-        %%P -m pip install unittest2 ipaddress mock wmi wheel pypiwin32 --upgrade
-        rem nice to have
-        rem %%P -m pip install ipdb nose --upgrade
-    )
-    goto :eof
-)
-
-
-if "%1" == "flake8" (
-    :flake8
-    %PYTHON% -c "from flake8.main import main; main()"
-    goto :eof
-)
-
-goto :help
-
-:error
-    @echo ------------------------------------------------
-    @echo last command exited with error code %errorlevel%
-    @echo ------------------------------------------------
-    @exit /b %errorlevel%
-    goto :eof
diff --git a/psutil/__init__.py b/psutil/__init__.py
index 8c84747dd4..cfd6ed8cc5 100644
--- a/psutil/__init__.py
+++ b/psutil/__init__.py
@@ -1,74 +1,190 @@
-# -*- coding: utf-8 -*-
-
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """psutil is a cross-platform library for retrieving information on
-running processes and system utilization (CPU, memory, disks, network)
-in Python.
+running processes and system utilization (CPU, memory, disks, network,
+sensors) in Python. Supported platforms:
+
+ - Linux
+ - Windows
+ - macOS
+ - FreeBSD
+ - OpenBSD
+ - NetBSD
+ - Sun Solaris
+ - AIX
+
+Supported Python versions are cPython 3.8+ and PyPy.
 """
 
-from __future__ import division
+from __future__ import annotations
 
 import collections
-import errno
+import contextlib
+import datetime
 import functools
 import os
 import signal
+import socket
 import subprocess
 import sys
+import threading
 import time
-import traceback
+import warnings
+from typing import TYPE_CHECKING as _TYPE_CHECKING
+
 try:
     import pwd
 except ImportError:
     pwd = None
 
 from . import _common
-from ._common import deprecated_method
-from ._common import memoize
-from ._compat import callable
-from ._compat import long
-from ._compat import PY3 as _PY3
-
-from ._common import STATUS_DEAD
-from ._common import STATUS_DISK_SLEEP
-from ._common import STATUS_IDLE  # bsd
-from ._common import STATUS_LOCKED
-from ._common import STATUS_RUNNING
-from ._common import STATUS_SLEEPING
-from ._common import STATUS_STOPPED
-from ._common import STATUS_TRACING_STOP
-from ._common import STATUS_WAITING  # bsd
-from ._common import STATUS_WAKING
-from ._common import STATUS_ZOMBIE
-
-from ._common import CONN_CLOSE
-from ._common import CONN_CLOSE_WAIT
-from ._common import CONN_CLOSING
-from ._common import CONN_ESTABLISHED
-from ._common import CONN_FIN_WAIT1
-from ._common import CONN_FIN_WAIT2
-from ._common import CONN_LAST_ACK
-from ._common import CONN_LISTEN
-from ._common import CONN_NONE
-from ._common import CONN_SYN_RECV
-from ._common import CONN_SYN_SENT
-from ._common import CONN_TIME_WAIT
-from ._common import NIC_DUPLEX_FULL
-from ._common import NIC_DUPLEX_HALF
-from ._common import NIC_DUPLEX_UNKNOWN
-
+from . import _ntuples as _ntp
+from ._common import AIX
 from ._common import BSD
-from ._common import FREEBSD  # NOQA
+from ._common import FREEBSD
 from ._common import LINUX
-from ._common import NETBSD  # NOQA
-from ._common import OPENBSD  # NOQA
-from ._common import OSX
-from ._common import POSIX  # NOQA
+from ._common import MACOS
+from ._common import NETBSD
+from ._common import OPENBSD
+from ._common import OSX  # deprecated alias
+from ._common import POSIX
 from ._common import SUNOS
 from ._common import WINDOWS
+from ._common import AccessDenied
+from ._common import Error
+from ._common import NoSuchProcess
+from ._common import TimeoutExpired
+from ._common import ZombieProcess
+from ._common import bytes2human
+from ._common import debug
+from ._common import memoize_when_activated
+from ._common import warn
+from ._common import wrap_numbers as _wrap_numbers
+from ._enums import BatteryTime
+from ._enums import ConnectionStatus
+from ._enums import NicDuplex
+from ._enums import ProcessStatus
+
+if _TYPE_CHECKING:
+    from collections.abc import Collection
+    from typing import Any
+    from typing import Callable
+    from typing import Generator
+    from typing import Iterator
+
+    from ._ntuples import pconn
+    from ._ntuples import pcputimes
+    from ._ntuples import pctxsw
+    from ._ntuples import pfootprint
+    from ._ntuples import pfullmem
+    from ._ntuples import pgids
+    from ._ntuples import pheap
+    from ._ntuples import pio
+    from ._ntuples import pionice
+    from ._ntuples import pmem
+    from ._ntuples import pmem_extras
+    from ._ntuples import pmmap_ext
+    from ._ntuples import pmmap_grouped
+    from ._ntuples import popenfile
+    from ._ntuples import ppagefaults
+    from ._ntuples import pthread
+    from ._ntuples import puids
+    from ._ntuples import sbattery
+    from ._ntuples import sconn
+    from ._ntuples import scpufreq
+    from ._ntuples import scpustats
+    from ._ntuples import scputimes
+    from ._ntuples import sdiskio
+    from ._ntuples import sdiskpart
+    from ._ntuples import sdiskusage
+    from ._ntuples import sfan
+    from ._ntuples import shwtemp
+    from ._ntuples import snetio
+    from ._ntuples import snicaddr
+    from ._ntuples import snicstats
+    from ._ntuples import sswap
+    from ._ntuples import suser
+    from ._ntuples import svmem
+    from ._pswindows import WindowsService
+
+    # _export_enum() puts these in the module namespace at run time.
+    STATUS_DEAD: ProcessStatus
+    STATUS_DISK_SLEEP: ProcessStatus
+    STATUS_IDLE: ProcessStatus
+    STATUS_LOCKED: ProcessStatus
+    STATUS_PARKED: ProcessStatus
+    STATUS_RUNNING: ProcessStatus
+    STATUS_SLEEPING: ProcessStatus
+    STATUS_STOPPED: ProcessStatus
+    STATUS_SUSPENDED: ProcessStatus
+    STATUS_TRACING_STOP: ProcessStatus
+    STATUS_WAITING: ProcessStatus
+    STATUS_WAKE_KILL: ProcessStatus
+    STATUS_WAKING: ProcessStatus
+    STATUS_ZOMBIE: ProcessStatus
+
+    CONN_CLOSE: ConnectionStatus
+    CONN_CLOSE_WAIT: ConnectionStatus
+    CONN_CLOSING: ConnectionStatus
+    CONN_ESTABLISHED: ConnectionStatus
+    CONN_FIN_WAIT1: ConnectionStatus
+    CONN_FIN_WAIT2: ConnectionStatus
+    CONN_LAST_ACK: ConnectionStatus
+    CONN_LISTEN: ConnectionStatus
+    CONN_NONE: ConnectionStatus
+    CONN_SYN_RECV: ConnectionStatus
+    CONN_SYN_SENT: ConnectionStatus
+    CONN_TIME_WAIT: ConnectionStatus
+    CONN_BOUND: ConnectionStatus  # SunOS
+    CONN_DELETE_TCB: ConnectionStatus  # Windows
+    CONN_IDLE: ConnectionStatus  # SunOS
+
+    NIC_DUPLEX_FULL: NicDuplex
+    NIC_DUPLEX_HALF: NicDuplex
+    NIC_DUPLEX_UNKNOWN: NicDuplex
+
+    POWER_TIME_UNKNOWN: BatteryTime
+    POWER_TIME_UNLIMITED: BatteryTime
+
+    IOPRIO_CLASS_BE: ProcessIOPriority  # Linux
+    IOPRIO_CLASS_IDLE: ProcessIOPriority  # Linux
+    IOPRIO_CLASS_NONE: ProcessIOPriority  # Linux
+    IOPRIO_CLASS_RT: ProcessIOPriority  # Linux
+    IOPRIO_HIGH: ProcessIOPriority  # Windows
+    IOPRIO_LOW: ProcessIOPriority  # Windows
+    IOPRIO_NORMAL: ProcessIOPriority  # Windows
+    IOPRIO_VERYLOW: ProcessIOPriority  # Windows
+
+    ABOVE_NORMAL_PRIORITY_CLASS: ProcessPriority  # Windows
+    BELOW_NORMAL_PRIORITY_CLASS: ProcessPriority  # Windows
+    HIGH_PRIORITY_CLASS: ProcessPriority  # Windows
+    IDLE_PRIORITY_CLASS: ProcessPriority  # Windows
+    NORMAL_PRIORITY_CLASS: ProcessPriority  # Windows
+    REALTIME_PRIORITY_CLASS: ProcessPriority  # Windows
+
+    RLIMIT_AS: ProcessRlimit  # Linux, FreeBSD
+    RLIMIT_CORE: ProcessRlimit  # Linux, FreeBSD
+    RLIMIT_CPU: ProcessRlimit  # Linux, FreeBSD
+    RLIMIT_DATA: ProcessRlimit  # Linux, FreeBSD
+    RLIMIT_FSIZE: ProcessRlimit  # Linux, FreeBSD
+    RLIMIT_LOCKS: ProcessRlimit  # Linux
+    RLIMIT_MEMLOCK: ProcessRlimit  # Linux, FreeBSD
+    RLIMIT_MSGQUEUE: ProcessRlimit  # Linux
+    RLIMIT_NICE: ProcessRlimit  # Linux
+    RLIMIT_NOFILE: ProcessRlimit  # Linux, FreeBSD
+    RLIMIT_NPROC: ProcessRlimit  # Linux, FreeBSD
+    RLIMIT_NPTS: ProcessRlimit  # FreeBSD
+    RLIMIT_RSS: ProcessRlimit  # Linux, FreeBSD
+    RLIMIT_RTPRIO: ProcessRlimit  # Linux
+    RLIMIT_RTTIME: ProcessRlimit  # Linux
+    RLIMIT_SBSIZE: ProcessRlimit  # FreeBSD
+    RLIMIT_SIGPENDING: ProcessRlimit  # Linux
+    RLIMIT_STACK: ProcessRlimit  # Linux, FreeBSD
+    RLIMIT_SWAP: ProcessRlimit  # FreeBSD
+    RLIM_INFINITY: ProcessRlimit  # Linux, FreeBSD
+
 
 if LINUX:
     # This is public API and it will be retrieved from _pslinux.py
@@ -76,79 +192,44 @@
     PROCFS_PATH = "/proc"
 
     from . import _pslinux as _psplatform
-
-    from ._pslinux import IOPRIO_CLASS_BE  # NOQA
-    from ._pslinux import IOPRIO_CLASS_IDLE  # NOQA
-    from ._pslinux import IOPRIO_CLASS_NONE  # NOQA
-    from ._pslinux import IOPRIO_CLASS_RT  # NOQA
-    # Linux >= 2.6.36
-    if _psplatform.HAS_PRLIMIT:
-        from ._psutil_linux import RLIM_INFINITY  # NOQA
-        from ._psutil_linux import RLIMIT_AS  # NOQA
-        from ._psutil_linux import RLIMIT_CORE  # NOQA
-        from ._psutil_linux import RLIMIT_CPU  # NOQA
-        from ._psutil_linux import RLIMIT_DATA  # NOQA
-        from ._psutil_linux import RLIMIT_FSIZE  # NOQA
-        from ._psutil_linux import RLIMIT_LOCKS  # NOQA
-        from ._psutil_linux import RLIMIT_MEMLOCK  # NOQA
-        from ._psutil_linux import RLIMIT_NOFILE  # NOQA
-        from ._psutil_linux import RLIMIT_NPROC  # NOQA
-        from ._psutil_linux import RLIMIT_RSS  # NOQA
-        from ._psutil_linux import RLIMIT_STACK  # NOQA
-        # Kinda ugly but considerably faster than using hasattr() and
-        # setattr() against the module object (we are at import time:
-        # speed matters).
-        from . import _psutil_linux
-        try:
-            RLIMIT_MSGQUEUE = _psutil_linux.RLIMIT_MSGQUEUE
-        except AttributeError:
-            pass
-        try:
-            RLIMIT_NICE = _psutil_linux.RLIMIT_NICE
-        except AttributeError:
-            pass
-        try:
-            RLIMIT_RTPRIO = _psutil_linux.RLIMIT_RTPRIO
-        except AttributeError:
-            pass
-        try:
-            RLIMIT_RTTIME = _psutil_linux.RLIMIT_RTTIME
-        except AttributeError:
-            pass
-        try:
-            RLIMIT_SIGPENDING = _psutil_linux.RLIMIT_SIGPENDING
-        except AttributeError:
-            pass
+    from ._enums import ProcessIOPriority
+    from ._enums import ProcessRlimit
 
 elif WINDOWS:
     from . import _pswindows as _psplatform
-    from ._psutil_windows import ABOVE_NORMAL_PRIORITY_CLASS  # NOQA
-    from ._psutil_windows import BELOW_NORMAL_PRIORITY_CLASS  # NOQA
-    from ._psutil_windows import HIGH_PRIORITY_CLASS  # NOQA
-    from ._psutil_windows import IDLE_PRIORITY_CLASS  # NOQA
-    from ._psutil_windows import NORMAL_PRIORITY_CLASS  # NOQA
-    from ._psutil_windows import REALTIME_PRIORITY_CLASS  # NOQA
-    from ._pswindows import CONN_DELETE_TCB  # NOQA
-
-elif OSX:
+    from ._enums import ProcessIOPriority
+    from ._enums import ProcessPriority
+
+elif MACOS:
     from . import _psosx as _psplatform
 
 elif BSD:
     from . import _psbsd as _psplatform
 
+    if FREEBSD:
+        from ._enums import ProcessRlimit
+
 elif SUNOS:
     from . import _pssunos as _psplatform
-    from ._pssunos import CONN_BOUND  # NOQA
-    from ._pssunos import CONN_IDLE  # NOQA
 
-    # This is public API and it will be retrieved from _pssunos.py
+    # This is public writable API which is read from _pslinux.py and
+    # _pssunos.py via sys.modules.
+    PROCFS_PATH = "/proc"
+
+elif AIX:
+    from . import _psaix as _psplatform
+
+    # This is public API and it will be retrieved from _pslinux.py
     # via sys.modules.
     PROCFS_PATH = "/proc"
 
 else:  # pragma: no cover
-    raise NotImplementedError('platform %s is not supported' % sys.platform)
+    msg = f"platform {sys.platform} is not supported"
+    raise NotImplementedError(msg)
 
+from . import _psutil
 
+# fmt: off
 __all__ = [
     # exceptions
     "Error", "NoSuchProcess", "ZombieProcess", "AccessDenied",
@@ -157,20 +238,10 @@
     # constants
     "version_info", "__version__",
 
-    "STATUS_RUNNING", "STATUS_IDLE", "STATUS_SLEEPING", "STATUS_DISK_SLEEP",
-    "STATUS_STOPPED", "STATUS_TRACING_STOP", "STATUS_ZOMBIE", "STATUS_DEAD",
-    "STATUS_WAKING", "STATUS_LOCKED", "STATUS_WAITING", "STATUS_LOCKED",
-
-    "CONN_ESTABLISHED", "CONN_SYN_SENT", "CONN_SYN_RECV", "CONN_FIN_WAIT1",
-    "CONN_FIN_WAIT2", "CONN_TIME_WAIT", "CONN_CLOSE", "CONN_CLOSE_WAIT",
-    "CONN_LAST_ACK", "CONN_LISTEN", "CONN_CLOSING", "CONN_NONE",
-
     "AF_LINK",
 
-    "NIC_DUPLEX_FULL", "NIC_DUPLEX_HALF", "NIC_DUPLEX_UNKNOWN",
-
-    "BSD", "FREEBSD", "LINUX", "NETBSD", "OPENBSD", "OSX", "POSIX", "SUNOS",
-    "WINDOWS",
+    "BSD", "FREEBSD", "LINUX", "NETBSD", "OPENBSD", "MACOS", "OSX", "POSIX",
+    "SUNOS", "WINDOWS", "AIX",
 
     # classes
     "Process", "Popen",
@@ -179,20 +250,53 @@
     "pid_exists", "pids", "process_iter", "wait_procs",             # proc
     "virtual_memory", "swap_memory",                                # memory
     "cpu_times", "cpu_percent", "cpu_times_percent", "cpu_count",   # cpu
-    "cpu_stats",
+    "cpu_stats", "getloadavg",  # "cpu_freq",
     "net_io_counters", "net_connections", "net_if_addrs",           # network
     "net_if_stats",
     "disk_io_counters", "disk_partitions", "disk_usage",            # disk
+    # "sensors_temperatures", "sensors_battery", "sensors_fans"     # sensors
     "users", "boot_time",                                           # others
+    "bytes2human",
 ]
+# fmt: on
+
 __all__.extend(_psplatform.__extra__all__)
-__author__ = "Giampaolo Rodola'"
-__version__ = "4.3.1"
-version_info = tuple([int(num) for num in __version__.split('.')])
+_globals = globals()
+
+
+def _export_enum(cls):
+    __all__.append(cls.__name__)
+    for name, member in cls.__members__.items():
+        _globals[name] = member  # noqa: F821
+        __all__.append(name)
+
+
+# Populate global namespace with enums and CONSTANTs.
+_export_enum(ProcessStatus)
+_export_enum(ConnectionStatus)
+_export_enum(NicDuplex)
+_export_enum(BatteryTime)
+if LINUX or WINDOWS:
+    _export_enum(ProcessIOPriority)
+if WINDOWS:
+    _export_enum(ProcessPriority)
+if LINUX or FREEBSD:
+    _export_enum(ProcessRlimit)
+if LINUX or SUNOS or AIX:
+    __all__.append("PROCFS_PATH")
+
+del _globals, _export_enum
+
 AF_LINK = _psplatform.AF_LINK
-_TOTAL_PHYMEM = None
-_timer = getattr(time, 'monotonic', time.time)
 
+__author__ = "Giampaolo Rodola'"
+__version__ = "8.0.0"
+version_info = tuple(int(num) for num in __version__.split('.'))
+
+_timer = getattr(time, 'monotonic', time.time)
+_TOTAL_PHYMEM = None
+_LOWEST_PID = None
+_SENTINEL = object()
 
 # Sanity check in case the user messed up with psutil installation
 # or did something weird with sys.path. In this case we might end
@@ -200,184 +304,133 @@
 # was compiled for a different version of psutil.
 # We want to prevent that by failing sooner rather than later.
 # See: https://github.com/giampaolo/psutil/issues/564
-if (int(__version__.replace('.', '')) !=
-        getattr(_psplatform.cext, 'version', None)):
-    msg = "version conflict: %r C extension module was built for another " \
-          "version of psutil (different than %s)" % (_psplatform.cext.__file__,
-                                                     __version__)
+if int(__version__.replace('.', '')) != getattr(_psutil, 'version', None):
+    msg = f"version conflict: {_psutil.__file__!r} C extension "
+    msg += "module was built for another version of psutil"
+    if hasattr(_psutil, 'version'):
+        v = ".".join(list(str(_psutil.version)))
+        msg += f" ({v} instead of {__version__})"
+    else:
+        msg += f" (different than {__version__})"
+    what = getattr(
+        _psutil,
+        "__file__",
+        "the existing psutil install directory",
+    )
+    msg += f"; you may try to 'pip uninstall psutil', manually remove {what}"
+    msg += " or clean the virtual env somehow, then reinstall"
     raise ImportError(msg)
 
 
 # =====================================================================
-# --- exceptions
+# --- Utils
 # =====================================================================
 
-class Error(Exception):
-    """Base exception class. All other psutil exceptions inherit
-    from this one.
-    """
 
-    def __init__(self, msg=""):
-        self.msg = msg
+if hasattr(_psplatform, 'ppid_map'):
+    # Faster version (Windows and Linux).
+    _ppid_map = _psplatform.ppid_map
+else:  # pragma: no cover
 
-    def __repr__(self):
-        ret = "%s.%s %s" % (self.__class__.__module__,
-                            self.__class__.__name__, self.msg)
-        return ret.strip()
+    def _ppid_map():
+        """Return a `{pid: ppid, ...}` dict for all running processes in
+        one shot. Used to speed up `Process.children()`.
+        """
+        ret = {}
+        for pid in pids():
+            try:
+                ret[pid] = _psplatform.Process(pid).ppid()
+            except (NoSuchProcess, ZombieProcess):
+                pass
+        return ret
 
-    __str__ = __repr__
 
+def _pprint_secs(secs):
+    """Format seconds in a human readable form."""
+    now = time.time()
+    secs_ago = int(now - secs)
+    fmt = "%H:%M:%S" if secs_ago < 60 * 60 * 24 else "%Y-%m-%d %H:%M:%S"
+    return datetime.datetime.fromtimestamp(secs).strftime(fmt)
 
-class NoSuchProcess(Error):
-    """Exception raised when a process with a certain PID doesn't
-    or no longer exists.
-    """
 
-    def __init__(self, pid, name=None, msg=None):
-        Error.__init__(self, msg)
-        self.pid = pid
-        self.name = name
-        self.msg = msg
-        if msg is None:
-            if name:
-                details = "(pid=%s, name=%s)" % (self.pid, repr(self.name))
-            else:
-                details = "(pid=%s)" % self.pid
-            self.msg = "process no longer exists " + details
+def _check_conn_kind(kind):
+    """Check net_connections()'s `kind` parameter."""
+    kinds = tuple(_common.conn_tmap)
+    if kind not in kinds:
+        msg = f"invalid kind argument {kind!r}; valid ones are: {kinds}"
+        raise ValueError(msg)
 
 
-class ZombieProcess(NoSuchProcess):
-    """Exception raised when querying a zombie process. This is
-    raised on OSX, BSD and Solaris only, and not always: depending
-    on the query the OS may be able to succeed anyway.
-    On Linux all zombie processes are querable (hence this is never
-    raised). Windows doesn't have zombie processes.
-    """
+# =====================================================================
+# --- Process class
+# =====================================================================
 
-    def __init__(self, pid, name=None, ppid=None, msg=None):
-        Error.__init__(self, msg)
-        self.pid = pid
-        self.ppid = ppid
-        self.name = name
-        self.msg = msg
-        if msg is None:
-            args = ["pid=%s" % pid]
-            if name:
-                args.append("name=%s" % repr(self.name))
-            if ppid:
-                args.append("ppid=%s" % self.ppid)
-            details = "(%s)" % ", ".join(args)
-            self.msg = "process still exists but it's a zombie " + details
-
-
-class AccessDenied(Error):
-    """Exception raised when permission to perform an action is denied."""
-
-    def __init__(self, pid=None, name=None, msg=None):
-        Error.__init__(self, msg)
-        self.pid = pid
-        self.name = name
-        self.msg = msg
-        if msg is None:
-            if (pid is not None) and (name is not None):
-                self.msg = "(pid=%s, name=%s)" % (pid, repr(name))
-            elif (pid is not None):
-                self.msg = "(pid=%s)" % self.pid
-            else:
-                self.msg = ""
 
+def _use_prefetch(method):
+    """Decorator returning cached values from `process_iter(attrs=...)`.
 
-class TimeoutExpired(Error):
-    """Raised on Process.wait(timeout) if timeout expires and process
-    is still alive.
+    When `process_iter()` is called with an *attrs* argument, it
+    pre-fetches the requested attributes via `as_dict()` and stores
+    them in `Process._prefetch`.  This decorator makes the decorated
+    method return the cached value (if present) instead of issuing
+    a new system call.
     """
 
-    def __init__(self, seconds, pid=None, name=None):
-        Error.__init__(self, "timeout after %s seconds" % seconds)
-        self.seconds = seconds
-        self.pid = pid
-        self.name = name
-        if (pid is not None) and (name is not None):
-            self.msg += " (pid=%s, name=%s)" % (pid, repr(name))
-        elif (pid is not None):
-            self.msg += " (pid=%s)" % self.pid
-
+    @functools.wraps(method)
+    def wrapper(self, *args, **kwargs):
+        if not args and not kwargs:
+            try:
+                return self._prefetch[method.__name__]
+            except KeyError:
+                pass
+        return method(self, *args, **kwargs)
 
-# push exception classes into platform specific module namespace
-_psplatform.NoSuchProcess = NoSuchProcess
-_psplatform.ZombieProcess = ZombieProcess
-_psplatform.AccessDenied = AccessDenied
-_psplatform.TimeoutExpired = TimeoutExpired
+    return wrapper
 
 
-# =====================================================================
-# --- Process class
-# =====================================================================
+class Process:
+    """Represents an OS process identified by a PID.
 
+    If *pid* arg is omitted, the current process PID (`os.getpid()`) is
+    used. Raises `NoSuchProcess` if the PID does not exist.
 
-def _assert_pid_not_reused(fun):
-    """Decorator which raises NoSuchProcess in case a process is no
-    longer running or its PID has been reused.
-    """
-    @functools.wraps(fun)
-    def wrapper(self, *args, **kwargs):
-        if not self.is_running():
-            raise NoSuchProcess(self.pid, self._name)
-        return fun(self, *args, **kwargs)
-    return wrapper
+    The way this class is bound to a process is via its PID. Most
+    methods do not guarantee that the PID has not been reused, so you
+    may end up retrieving information for a different process.
 
+    Real process identity is checked (via PID + creation time) only for
+    methods that set attributes or send signals.
 
-class Process(object):
-    """Represents an OS process with the given PID.
-    If PID is omitted current process PID (os.getpid()) is used.
-    Raise NoSuchProcess if PID does not exist.
-
-    Note that most of the methods of this class do not make sure
-    the PID of the process being queried has been reused over time.
-    That means you might end up retrieving an information referring
-    to another process in case the original one this instance
-    refers to is gone in the meantime.
-
-    The only exceptions for which process identity is pre-emptively
-    checked and guaranteed are:
-
-     - parent()
-     - children()
-     - nice() (set)
-     - ionice() (set)
-     - rlimit() (set)
-     - cpu_affinity (set)
-     - suspend()
-     - resume()
-     - send_signal()
-     - terminate()
-     - kill()
-
-    To prevent this problem for all other methods you can:
-      - use is_running() before querying the process
-      - if you're continuously iterating over a set of Process
-        instances use process_iter() which pre-emptively checks
-        process identity for every yielded instance
+    To avoid issues with PID reuse for other read-only methods, call
+    `is_running()` before querying the process.
     """
 
-    def __init__(self, pid=None):
+    attrs: frozenset[str] = frozenset()  # dynamically set later
+
+    def __init__(self, pid: int | None = None) -> None:
         self._init(pid)
 
     def _init(self, pid, _ignore_nsp=False):
         if pid is None:
             pid = os.getpid()
         else:
-            if not _PY3 and not isinstance(pid, (int, long)):
-                raise TypeError('pid must be an integer (got %r)' % pid)
             if pid < 0:
-                raise ValueError('pid must be a positive integer (got %s)'
-                                 % pid)
+                msg = f"pid must be a positive integer (got {pid})"
+                raise ValueError(msg)
+            try:
+                _psutil.check_pid_range(pid)
+            except OverflowError as err:
+                msg = "process PID out of range"
+                raise NoSuchProcess(pid, msg=msg) from err
+
         self._pid = pid
         self._name = None
         self._exe = None
         self._create_time = None
         self._gone = False
+        self._pid_reused = False
         self._hash = None
+        self._lock = threading.RLock()
         # used for caching on Windows only (on POSIX ppid may change)
         self._ppid = None
         # platform-specific modules define an _psplatform.Process
@@ -385,141 +438,353 @@ def _init(self, pid, _ignore_nsp=False):
         self._proc = _psplatform.Process(pid)
         self._last_sys_cpu_times = None
         self._last_proc_cpu_times = None
-        # cache creation time for later use in is_running() method
+        self._exitcode = _SENTINEL
+        self._prefetch = {}
+        self._ad_value = _SENTINEL
+        self._ident = (self.pid, None)
         try:
-            self.create_time()
+            self._ident = self._get_ident()
         except AccessDenied:
-            # we should never get here as AFAIK we're able to get
-            # process creation time on all platforms even as a
-            # limited user
+            # This should happen on Windows only, since we use the fast
+            # create time method. AFAIK, on all other platforms we are
+            # able to get create time for all PIDs.
             pass
         except ZombieProcess:
-            # Let's consider a zombie process as legitimate as
-            # tehcnically it's still alive (it can be queried,
-            # although not always, and it's returned by pids()).
+            # Zombies can still be queried by this class (although
+            # not always) and pids() return them so just go on.
             pass
         except NoSuchProcess:
             if not _ignore_nsp:
-                msg = 'no process found with pid %s' % pid
-                raise NoSuchProcess(pid, None, msg)
-            else:
-                self._gone = True
-        # This pair is supposed to indentify a Process instance
-        # univocally over time (the PID alone is not enough as
-        # it might refer to a process whose PID has been reused).
-        # This will be used later in __eq__() and is_running().
-        self._ident = (self.pid, self._create_time)
+                msg = "process PID not found"
+                raise NoSuchProcess(pid, msg=msg) from None
+            self._gone = True
 
-    def __str__(self):
-        try:
-            pid = self.pid
-            name = repr(self.name())
-        except ZombieProcess:
-            details = "(pid=%s (zombie))" % self.pid
-        except NoSuchProcess:
-            details = "(pid=%s (terminated))" % self.pid
-        except AccessDenied:
-            details = "(pid=%s)" % (self.pid)
+    def _is_ad_value(self, value):
+        """Whether `value` is the `ad_value` that process_iter(attrs=...)
+        stored in place of a getter which raised AccessDenied.
+        """
+        return self._ad_value is not _SENTINEL and value is self._ad_value
+
+    def _get_ident(self):
+        """Return a `(pid, uid)` tuple which is supposed to identify a
+        Process instance univocally over time.
+
+        The PID alone is not enough, as it can be assigned to a new
+        process after this one terminates, so we add creation time to
+        the mix. We need this in order to prevent killing the wrong
+        process later on. This is also known as PID reuse or PID
+        recycling problem.
+
+        The reliability of this strategy mostly depends on
+        `create_time()` precision, which is 0.01 secs on Linux. The
+        assumption is that, after a process terminates, the kernel
+        won't reuse the same PID after such a short period of time
+        (0.01 secs). Technically this is inherently racy, but
+        practically it should be good enough.
+
+        NOTE: unreliable on FreeBSD and OpenBSD as ctime is subject to
+        system clock updates, so the PID-reuse check there is disabled.
+        Same goes for SunOS and AIX, where we don't know whether ctime
+        is stable across clock updates.
+
+        NOTE 2: it is also disabled on Windows in case `create_time()`
+        can't be fetched due to `AccessDenied`.
+        """
+
+        if WINDOWS:
+            # Use create_time() fast method in order to speedup
+            # `process_iter()`. This means we'll get AccessDenied for
+            # most ADMIN processes, but that's fine since it means
+            # we'll also get AccessDenied on kill().
+            # https://github.com/giampaolo/psutil/issues/2366#issuecomment-2381646555
+            self._create_time = self._proc.create_time(fast_only=True)
+            return (self.pid, self._create_time)
+        elif LINUX or NETBSD or OSX:
+            # Use 'monotonic' process starttime since boot to form unique
+            # process identity, since it is stable over changes to system
+            # time.
+            return (self.pid, self._proc.create_time(monotonic=True))
         else:
-            details = "(pid=%s, name=%s)" % (pid, name)
-        return "%s.%s%s" % (self.__class__.__module__,
-                            self.__class__.__name__, details)
+            # Still call create_time() to check PID existence (raise
+            # NSP at construction time), but don't use it for identity.
+            self.create_time()
+            return (self.pid, None)
+
+    def __str__(self):
+        info = {}
+        info["pid"] = self.pid
+        with self.oneshot():
+            if self._pid_reused:
+                info["status"] = "terminated + PID reused"
+            else:
+                try:
+                    info["name"] = self._name or self.name()
+                    info["status"] = str(self.status())
+                except ZombieProcess:
+                    info["status"] = "zombie"
+                except NoSuchProcess:
+                    info["status"] = "terminated"
+                except AccessDenied:
+                    pass
 
-    def __repr__(self):
-        return "<%s at %s>" % (self.__str__(), id(self))
+            if self._exitcode not in {_SENTINEL, None}:
+                info["exitcode"] = self._exitcode
+            if self._create_time is not None:
+                info['started'] = _pprint_secs(self._create_time)
+
+            return "{}.{}({})".format(
+                self.__class__.__module__,
+                self.__class__.__name__,
+                ", ".join([f"{k}={v!r}" for k, v in info.items()]),
+            )
+
+    __repr__ = __str__
+
+    @staticmethod
+    def _cmp_idents(ident1, ident2):
+        """Compare two `(pid, ctime)` identity tuples and return
+        "same", "different" or "unknown". "unknown" means ctime is
+        missing on either side (`AccessDenied` on Windows, zombies
+        resulting in ctime 0), which is not proof of a different
+        process.
+        """
+        pid1, ctime1 = ident1
+        pid2, ctime2 = ident2
+        if pid1 != pid2:
+            return "different"
+        if not ctime1 or not ctime2:
+            return "unknown"
+        return "same" if ctime1 == ctime2 else "different"
 
     def __eq__(self, other):
         # Test for equality with another Process object based
         # on PID and creation time.
         if not isinstance(other, Process):
             return NotImplemented
-        return self._ident == other._ident
+        return self._cmp_idents(self._ident, other._ident) != "different"
 
     def __ne__(self, other):
         return not self == other
 
     def __hash__(self):
+        # PID only: __eq__ can match idents with different ctimes, and
+        # equal objects must hash the same.
         if self._hash is None:
-            self._hash = hash(self._ident)
+            self._hash = hash(self._ident[0])
         return self._hash
 
+    def _raise_if_pid_reused(self):
+        """Raise `NoSuchProcess` in case process PID has been reused."""
+        if self._pid_reused or (not self.is_running() and self._pid_reused):
+            # We may directly raise NSP in here already if PID is just
+            # not running, but I prefer NSP to be raised naturally by
+            # the actual Process API call. This way unit tests will tell
+            # us if the API is broken (aka don't raise NSP when it
+            # should). We also remain consistent with all other "get"
+            # APIs which don't use _raise_if_pid_reused().
+            msg = "process no longer exists and its PID has been reused"
+            raise NoSuchProcess(self.pid, self._name, msg=msg)
+
+    @property
+    def pid(self) -> int:
+        """The process PID."""
+        return self._pid
+
+    # DEPRECATED
+    @property
+    def info(self) -> dict:
+        """Return pre-fetched `process_iter()` info dict.
+
+        Deprecated: use method calls instead (e.g. `p.name()`).
+        """
+        msg = (
+            "Process.info is deprecated; use method calls instead"
+            " (e.g. p.name() instead of p.info['name'])"
+        )
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+        # Return a copy to prevent the user from mutating the dict and
+        # corrupting the prefetch cache.
+        return self._prefetch.copy()
+
     # --- utility methods
 
-    def as_dict(self, attrs=None, ad_value=None):
+    @contextlib.contextmanager
+    def oneshot(self) -> Generator[None, None, None]:
+        """Context manager which speeds up the retrieval of multiple
+        process attributes at the same time.
+
+        Internally, many attributes (e.g. `name()`, `ppid()`, `uids()`,
+        `create_time()`, ...) share the same system call. This context
+        manager executes each system call once, and caches the results,
+        so subsequent calls return cached values. The cache is cleared
+        when exiting the context manager block. Use this every time you
+        retrieve more than one attribute about the process.
+
+        >>> import psutil
+        >>> p = psutil.Process()
+        >>> with p.oneshot():
+        ...     p.name()  # collect multiple info
+        ...     p.cpu_times()  # return cached value
+        ...     p.cpu_percent()  # return cached value
+        ...     p.create_time()  # return cached value
+        ...
+        >>>
+        """
+        with self._lock:
+            if hasattr(self, "_cache"):
+                # NOOP: this covers the use case where the user enters the
+                # context twice:
+                #
+                # >>> with p.oneshot():
+                # ...    with p.oneshot():
+                # ...
+                #
+                # Also, since as_dict() internally uses oneshot()
+                # I expect that the code below will be a pretty common
+                # "mistake" that the user will make, so let's guard
+                # against that:
+                #
+                # >>> with p.oneshot():
+                # ...    p.as_dict()
+                # ...
+                yield
+            else:
+                try:
+                    self.cpu_times.cache_activate(self)
+                    # cached in case memory_percent() is used
+                    self.memory_info.cache_activate(self)
+                    # cached in case parent() is used
+                    self.ppid.cache_activate(self)
+                    # cached in case username() is used
+                    if POSIX:
+                        self.uids.cache_activate(self)
+                    # specific implementation cache
+                    self._proc.oneshot_enter()
+                    yield
+                finally:
+                    self.cpu_times.cache_deactivate(self)
+                    self.memory_info.cache_deactivate(self)
+                    self.ppid.cache_deactivate(self)
+                    if POSIX:
+                        self.uids.cache_deactivate(self)
+                    self._proc.oneshot_exit()
+
+    def as_dict(
+        self, attrs: Collection[str] | None = None, ad_value: Any = None
+    ) -> dict[str, Any]:
         """Utility method returning process information as a
         hashable dictionary.
 
-        If 'attrs' is specified it must be a list of strings
-        reflecting available Process class' attribute names
-        (e.g. ['cpu_times', 'name']) else all public (read
-        only) attributes are assumed.
+        If *attrs* is specified it must be a collection of strings
+        reflecting available Process class' attribute names (e.g.
+        ['cpu_times', 'name']) else all public (read-only) attributes
+        are assumed. See `Process.attrs` for a full list.
 
-        'ad_value' is the value which gets assigned in case
-        AccessDenied or ZombieProcess exception is raised when
+        *ad_value* is the value which gets assigned in case
+        `AccessDenied` or `ZombieProcess` exception is raised when
         retrieving that particular process information.
         """
-        valid_names = _as_dict_attrnames
+        valid_names = self.attrs
+        # Deprecated attrs: not returned by default but still accepted if
+        # explicitly requested.
+        deprecated_names = {"memory_full_info"}
+
         if attrs is not None:
             if not isinstance(attrs, (list, tuple, set, frozenset)):
-                raise TypeError("invalid attrs type %s" % type(attrs))
+                msg = f"invalid attrs type {type(attrs)}"
+                raise TypeError(msg)
             attrs = set(attrs)
-            invalid_names = attrs - valid_names
+            invalid_names = attrs - valid_names - deprecated_names
             if invalid_names:
-                raise ValueError("invalid attr name%s %s" % (
+                msg = "invalid attr name{} {}".format(
                     "s" if len(invalid_names) > 1 else "",
-                    ", ".join(map(repr, invalid_names))))
-
-        retdict = dict()
-        ls = attrs or valid_names
-        for name in ls:
-            try:
-                if name == 'pid':
-                    ret = self.pid
-                else:
-                    meth = getattr(self, name)
-                    ret = meth()
-            except (AccessDenied, ZombieProcess):
-                ret = ad_value
-            except NotImplementedError:
-                # in case of not implemented functionality (may happen
-                # on old or exotic systems) we want to crash only if
-                # the user explicitly asked for that particular attr
-                if attrs:
-                    raise
-                continue
-            retdict[name] = ret
+                    ", ".join(map(repr, invalid_names)),
+                )
+                raise ValueError(msg)
+
+        retdict = {}
+        names = attrs or sorted(valid_names)
+        with self.oneshot():
+            for name in names:
+                try:
+                    if name == 'pid':
+                        ret = self.pid
+                    else:
+                        meth = getattr(self, name)
+                        ret = meth()
+                except (AccessDenied, ZombieProcess):
+                    ret = ad_value
+                except NotImplementedError:
+                    # in case of not implemented functionality (may happen
+                    # on old or exotic systems) we want to crash only if
+                    # the user explicitly asked for that particular attr
+                    if attrs:
+                        raise
+                    continue
+                retdict[name] = ret
         return retdict
 
-    def parent(self):
-        """Return the parent process as a Process object pre-emptively
+    def parent(self) -> Process | None:
+        """Return the parent process as a `Process` object, preemptively
         checking whether PID has been reused.
+
         If no parent is known return None.
         """
+        lowest_pid = _LOWEST_PID if _LOWEST_PID is not None else pids()[0]
+        if self.pid == lowest_pid:
+            return None
         ppid = self.ppid()
         if ppid is not None:
-            ctime = self.create_time()
+            # Get a fresh (non-cached) ctime in case the system clock
+            # was updated. TODO: use a monotonic ctime on platforms
+            # where it's supported.
+            proc_ctime = Process(self.pid).create_time()
             try:
                 parent = Process(ppid)
-                if parent.create_time() <= ctime:
+                if parent.create_time() <= proc_ctime:
                     return parent
                 # ...else ppid has been reused by another process
             except NoSuchProcess:
                 pass
 
-    def is_running(self):
+    def parents(self) -> list[Process]:
+        """Return the parents of this process as a list of `Process`
+        instances.
+
+        If no parents are known return an empty list.
+        """
+        parents = []
+        proc = self.parent()
+        while proc is not None:
+            parents.append(proc)
+            proc = proc.parent()
+        return parents
+
+    def is_running(self) -> bool:
         """Return whether this process is running.
-        It also checks if PID has been reused by another process in
-        which case return False.
+
+        It also checks if PID has been reused by another process, in
+        which case it will remove the process from `process_iter()`
+        internal cache and return False.
         """
-        if self._gone:
+        if self._gone or self._pid_reused:
             return False
         try:
             # Checking if PID is alive is not enough as the PID might
-            # have been reused by another process: we also want to
-            # verify process identity.
-            # Process identity / uniqueness over time is guaranteed by
-            # (PID + creation time) and that is verified in __eq__.
-            return self == Process(self.pid)
+            # have been reused by another process. Process identity is
+            # guaranteed by (PID + creation time), see __eq__.
+            other = Process(self.pid)
+            self._pid_reused = self != other
+            if self._pid_reused:
+                debug(f"PID reuse detected: {self._ident} vs. {other._ident}")
+                _pids_reused.add(self.pid)
+                raise NoSuchProcess(self.pid)
+            if self._cmp_idents(self._ident, other._ident) == "unknown":
+                debug(
+                    "null create time, PID reuse check inconclusive:"
+                    f" {self._ident} vs. {other._ident}"
+                )
+            return True
         except ZombieProcess:
             # We should never get here as it's already handled in
             # Process.__init__; here just for extra safety.
@@ -530,12 +795,9 @@ def is_running(self):
 
     # --- actual API
 
-    @property
-    def pid(self):
-        """The process PID."""
-        return self._pid
-
-    def ppid(self):
+    @_use_prefetch
+    @memoize_when_activated
+    def ppid(self) -> int:
         """The process parent PID.
         On Windows the return value is cached after first call.
         """
@@ -543,16 +805,15 @@ def ppid(self):
         # change to 1 (init) in case this process turns into a zombie:
         # https://github.com/giampaolo/psutil/issues/321
         # http://stackoverflow.com/questions/356722/
-
-        # XXX should we check creation time here rather than in
-        # Process.parent()?
+        self._raise_if_pid_reused()
         if POSIX:
             return self._proc.ppid()
-        else:
+        else:  # pragma: no cover
             self._ppid = self._ppid or self._proc.ppid()
             return self._ppid
 
-    def name(self):
+    @_use_prefetch
+    def name(self) -> str:
         """The process name. The return value is cached after first call."""
         # Process name is only cached on Windows as on POSIX it may
         # change, see:
@@ -567,7 +828,12 @@ def name(self):
             # Examples are "gnome-keyring-d" vs. "gnome-keyring-daemon".
             try:
                 cmdline = self.cmdline()
-            except AccessDenied:
+            except (AccessDenied, ZombieProcess):
+                # Just pass and return the truncated name: it's better
+                # than nothing. Note: there are actual cases where a
+                # zombie process can return a name() but not a
+                # cmdline(), see:
+                # https://github.com/giampaolo/psutil/issues/2239
                 pass
             else:
                 if cmdline:
@@ -578,11 +844,14 @@ def name(self):
         self._proc._name = name
         return name
 
-    def exe(self):
+    @_use_prefetch
+    def exe(self) -> str:
         """The process executable as an absolute path.
-        May also be an empty string.
-        The return value is cached after first call.
+
+        May also be an empty string. The return value is cached after
+        first call.
         """
+
         def guess_it(fallback):
             # try to guess exe from cmdline[0] in absence of a native
             # exe representation
@@ -592,9 +861,11 @@ def guess_it(fallback):
                 # Attempt to guess only in case of an absolute path.
                 # It is not safe otherwise as the process might have
                 # changed cwd.
-                if (os.path.isabs(exe) and
-                        os.path.isfile(exe) and
-                        os.access(exe, os.X_OK)):
+                if (
+                    os.path.isabs(exe)
+                    and os.path.isfile(exe)
+                    and os.access(exe, os.X_OK)
+                ):
                     return exe
             if isinstance(fallback, AccessDenied):
                 raise fallback
@@ -617,27 +888,34 @@ def guess_it(fallback):
                 self._exe = exe
         return self._exe
 
-    def cmdline(self):
+    @_use_prefetch
+    def cmdline(self) -> list[str]:
         """The command line this process has been called with."""
         return self._proc.cmdline()
 
-    def status(self):
-        """The process current status as a STATUS_* constant."""
+    @_use_prefetch
+    def status(self) -> ProcessStatus | str:
+        """The process current status as a `STATUS_` constant."""
         try:
             return self._proc.status()
         except ZombieProcess:
-            return STATUS_ZOMBIE
+            return ProcessStatus.STATUS_ZOMBIE
 
-    def username(self):
+    @_use_prefetch
+    def username(self) -> str:
         """The name of the user that owns the process.
-        On UNIX this is calculated by using *real* process uid.
+
+        On UNIX this is calculated by using the real process uid.
         """
         if POSIX:
             if pwd is None:
                 # might happen if python was installed from sources
-                raise ImportError(
-                    "requires pwd module shipped with standard python")
-            real_uid = self.uids().real
+                msg = "requires pwd module shipped with standard python"
+                raise ImportError(msg)
+            uids = self.uids()
+            if self._is_ad_value(uids):
+                return uids
+            real_uid = uids.real
             try:
                 return pwd.getpwuid(real_uid).pw_name
             except KeyError:
@@ -646,162 +924,209 @@ def username(self):
         else:
             return self._proc.username()
 
-    def create_time(self):
+    @_use_prefetch
+    def create_time(self) -> float:
         """The process creation time as a floating point number
-        expressed in seconds since the epoch, in UTC.
-        The return value is cached after first call.
+        expressed in seconds since the epoch (seconds since January 1,
+        1970, at midnight UTC).
+
+        The return value, which is cached after first call, is based on
+        the system clock, which means it may be affected by changes
+        such as manual adjustments or time synchronization (e.g. NTP).
         """
         if self._create_time is None:
             self._create_time = self._proc.create_time()
         return self._create_time
 
-    def cwd(self):
+    @_use_prefetch
+    def cwd(self) -> str:
         """Process current working directory as an absolute path."""
         return self._proc.cwd()
 
-    def nice(self, value=None):
+    @_use_prefetch
+    def nice(self, value: int | None = None) -> int | None:
         """Get or set process niceness (priority)."""
         if value is None:
             return self._proc.nice_get()
         else:
-            if not self.is_running():
-                raise NoSuchProcess(self.pid, self._name)
+            self._raise_if_pid_reused()
             self._proc.nice_set(value)
 
     if POSIX:
 
-        def uids(self):
-            """Return process UIDs as a (real, effective, saved)
-            namedtuple.
+        @_use_prefetch
+        @memoize_when_activated
+        def uids(self) -> puids:
+            """Return process UIDs as a `(real, effective, saved)`
+            named tuple.
             """
             return self._proc.uids()
 
-        def gids(self):
-            """Return process GIDs as a (real, effective, saved)
-            namedtuple.
+        @_use_prefetch
+        def gids(self) -> pgids:
+            """Return process GIDs as a `(real, effective, saved)`
+            named tuple.
             """
             return self._proc.gids()
 
-        def terminal(self):
+        @_use_prefetch
+        def terminal(self) -> str | None:
             """The terminal associated with this process, if any,
             else None.
             """
             return self._proc.terminal()
 
-        def num_fds(self):
+        @_use_prefetch
+        def num_fds(self) -> int:
             """Return the number of file descriptors opened by this
             process (POSIX only).
             """
             return self._proc.num_fds()
 
-    # Linux, BSD and Windows only
     if hasattr(_psplatform.Process, "io_counters"):
 
-        def io_counters(self):
-            """Return process I/O statistics as a
-            (read_count, write_count, read_bytes, write_bytes)
-            namedtuple.
-            Those are the number of read/write calls performed and the
-            amount of bytes read and written by the process.
+        @_use_prefetch
+        def io_counters(self) -> pio:
+            """Return process I/O statistics (primarily read and
+            written bytes).
+
+            Availability: Linux, Windows, BSD, AIX
             """
             return self._proc.io_counters()
 
-    # Linux and Windows >= Vista only
     if hasattr(_psplatform.Process, "ionice_get"):
 
-        def ionice(self, ioclass=None, value=None):
+        @_use_prefetch
+        def ionice(
+            self, ioclass: int | None = None, value: int | None = None
+        ) -> pionice | ProcessIOPriority | None:
             """Get or set process I/O niceness (priority).
 
-            On Linux 'ioclass' is one of the IOPRIO_CLASS_* constants.
-            'value' is a number which goes from 0 to 7. The higher the
+            On Linux *ioclass* is one of the `IOPRIO_CLASS_*` constants.
+            *value* is a number which goes from 0 to 7. The higher the
             value, the lower the I/O priority of the process.
 
-            On Windows only 'ioclass' is used and it can be set to 2
-            (normal), 1 (low) or 0 (very low).
+            On Windows only *ioclass* is used and it can be set to
+            one of the `IOPRIO_*` constants.
 
-            Available on Linux and Windows > Vista only.
+            Availability: Linux, Windows
             """
             if ioclass is None:
                 if value is not None:
-                    raise ValueError("'ioclass' argument must be specified")
+                    msg = "'ioclass' argument must be specified"
+                    raise ValueError(msg)
                 return self._proc.ionice_get()
             else:
+                self._raise_if_pid_reused()
                 return self._proc.ionice_set(ioclass, value)
 
-    # Linux only
     if hasattr(_psplatform.Process, "rlimit"):
 
-        def rlimit(self, resource, limits=None):
-            """Get or set process resource limits as a (soft, hard)
+        def rlimit(
+            self,
+            resource: int,
+            limits: tuple[int, int] | None = None,
+        ) -> tuple[int, int] | None:
+            """Get or set process resource limits as a `(soft, hard)`
             tuple.
 
-            'resource' is one of the RLIMIT_* constants.
-            'limits' is supposed to be a (soft, hard)  tuple.
+            - resource: one of the `RLIMIT_*` constants.
+            - limits: a `(soft, hard)` tuple (set).
 
             See "man prlimit" for further info.
-            Available on Linux only.
+
+            Availability: Linux, FreeBSD
             """
-            if limits is None:
-                return self._proc.rlimit(resource)
-            else:
-                return self._proc.rlimit(resource, limits)
+            if limits is not None:
+                self._raise_if_pid_reused()
+            return self._proc.rlimit(resource, limits)
 
-    # Windows, Linux and FreeBSD only
     if hasattr(_psplatform.Process, "cpu_affinity_get"):
 
-        def cpu_affinity(self, cpus=None):
+        @_use_prefetch
+        def cpu_affinity(
+            self, cpus: list[int] | None = None
+        ) -> list[int] | None:
             """Get or set process CPU affinity.
-            If specified 'cpus' must be a list of CPUs for which you
-            want to set the affinity (e.g. [0, 1]).
-            (Windows, Linux and BSD only).
+
+            If specified, *cpus* must be a list of CPUs for which you
+            want to set the affinity (e.g. `[0, 1]`). If an empty list is
+            passed, all eligible CPUs are assumed (and set).
+
+            Availability: Linux, Windows, FreeBSD
             """
-            # Automatically remove duplicates both on get and
-            # set (for get it's not really necessary, it's
-            # just for extra safety).
             if cpus is None:
-                return list(set(self._proc.cpu_affinity_get()))
+                return sorted(set(self._proc.cpu_affinity_get()))
             else:
+                self._raise_if_pid_reused()
+                if not cpus:
+                    if hasattr(self._proc, "_get_eligible_cpus"):
+                        cpus = self._proc._get_eligible_cpus()
+                    else:
+                        cpus = tuple(range(len(cpu_times(percpu=True))))
                 self._proc.cpu_affinity_set(list(set(cpus)))
 
-    # Linux, OSX and Windows only
+    # Linux, FreeBSD, SunOS
+    if hasattr(_psplatform.Process, "cpu_num"):
+
+        @_use_prefetch
+        def cpu_num(self) -> int:
+            """Return what CPU this process is currently running on.
+
+            The returned number should be <= `psutil.cpu_count()`.
+            """
+            return self._proc.cpu_num()
+
+    # All platforms has it, but maybe not in the future.
     if hasattr(_psplatform.Process, "environ"):
 
-        def environ(self):
-            """The environment variables of the process as a dict.  Note: this
-            might not reflect changes made after the process started.  """
+        @_use_prefetch
+        def environ(self) -> dict[str, str]:
+            """The environment variables of the process as a dict.
+
+            Note: this might not reflect changes made after the process
+            started.
+            """
             return self._proc.environ()
 
     if WINDOWS:
 
-        def num_handles(self):
+        @_use_prefetch
+        def num_handles(self) -> int:
             """Return the number of handles opened by this process
-            (Windows only).
+
+            Availability: Windows
             """
             return self._proc.num_handles()
 
-    def num_ctx_switches(self):
+    @_use_prefetch
+    def num_ctx_switches(self) -> pctxsw:
         """Return the number of voluntary and involuntary context
         switches performed by this process.
         """
         return self._proc.num_ctx_switches()
 
-    def num_threads(self):
+    @_use_prefetch
+    def num_threads(self) -> int:
         """Return the number of threads used by this process."""
         return self._proc.num_threads()
 
-    def threads(self):
-        """Return threads opened by process as a list of
-        (id, user_time, system_time) namedtuples representing
-        thread id and thread CPU times (user/system).
-        On OpenBSD this method requires root access.
-        """
-        return self._proc.threads()
+    if hasattr(_psplatform.Process, "threads"):
+
+        @_use_prefetch
+        def threads(self) -> list[pthread]:
+            """Return threads opened by process as a list of
+            `(id, user_time, system_time)` named tuples.
+
+            On OpenBSD this method requires root access.
+            """
+            return self._proc.threads()
 
-    @_assert_pid_not_reused
-    def children(self, recursive=False):
+    def children(self, recursive: bool = False) -> list[Process]:
         """Return the children of this process as a list of Process
-        instances, pre-emptively checking whether PID has been reused.
-        If recursive is True return all the parent descendants.
+        instances, preemptively checking whether PID has been reused.
+
+        If *recursive* is True return all the parent descendants.
 
         Example (A == this process):
 
@@ -824,90 +1149,78 @@ def children(self, recursive=False):
         process Y won't be listed as the reference to process A
         is lost.
         """
-        if hasattr(_psplatform, 'ppid_map'):
-            # Windows only: obtain a {pid:ppid, ...} dict for all running
-            # processes in one shot (faster).
-            ppid_map = _psplatform.ppid_map()
-        else:
-            ppid_map = None
-
+        self._raise_if_pid_reused()
+        ppid_map = _ppid_map()
+        # Get a fresh (non-cached) ctime in case the system clock was
+        # updated. TODO: use a monotonic ctime on platforms where it's
+        # supported.
+        proc_ctime = Process(self.pid).create_time()
         ret = []
         if not recursive:
-            if ppid_map is None:
-                # 'slow' version, common to all platforms except Windows
-                for p in process_iter():
+            for pid, ppid in ppid_map.items():
+                if ppid == self.pid:
                     try:
-                        if p.ppid() == self.pid:
-                            # if child happens to be older than its parent
-                            # (self) it means child's PID has been reused
-                            if self.create_time() <= p.create_time():
-                                ret.append(p)
+                        child = Process(pid)
+                        # if child happens to be older than its parent
+                        # (self) it means child's PID has been reused
+                        if proc_ctime <= child.create_time():
+                            ret.append(child)
                     except (NoSuchProcess, ZombieProcess):
                         pass
-            else:  # pragma: no cover
-                # Windows only (faster)
-                for pid, ppid in ppid_map.items():
-                    if ppid == self.pid:
-                        try:
-                            child = Process(pid)
-                            # if child happens to be older than its parent
-                            # (self) it means child's PID has been reused
-                            if self.create_time() <= child.create_time():
-                                ret.append(child)
-                        except (NoSuchProcess, ZombieProcess):
-                            pass
         else:
-            # construct a dict where 'values' are all the processes
-            # having 'key' as their parent
-            table = collections.defaultdict(list)
-            if ppid_map is None:
-                for p in process_iter():
-                    try:
-                        table[p.ppid()].append(p)
-                    except (NoSuchProcess, ZombieProcess):
-                        pass
-            else:  # pragma: no cover
-                for pid, ppid in ppid_map.items():
-                    try:
-                        p = Process(pid)
-                        table[ppid].append(p)
-                    except (NoSuchProcess, ZombieProcess):
-                        pass
-            # At this point we have a mapping table where table[self.pid]
-            # are the current process' children.
-            # Below, we look for all descendants recursively, similarly
-            # to a recursive function call.
-            checkpids = [self.pid]
-            for pid in checkpids:
-                for child in table[pid]:
+            # Construct a {pid: [child pids]} dict
+            reverse_ppid_map = collections.defaultdict(list)
+            for pid, ppid in ppid_map.items():
+                reverse_ppid_map[ppid].append(pid)
+            # Recursively traverse that dict, starting from self.pid,
+            # such that we only call Process() on actual children
+            seen = set()
+            stack = [self.pid]
+            while stack:
+                pid = stack.pop()
+                if pid in seen:
+                    # Since pids can be reused while the ppid_map is
+                    # constructed, there may be rare instances where
+                    # there's a cycle in the recorded process "tree".
+                    continue
+                seen.add(pid)
+                for child_pid in reverse_ppid_map[pid]:
                     try:
+                        child = Process(child_pid)
                         # if child happens to be older than its parent
                         # (self) it means child's PID has been reused
-                        intime = self.create_time() <= child.create_time()
-                    except (NoSuchProcess, ZombieProcess):
-                        pass
-                    else:
+                        intime = proc_ctime <= child.create_time()
                         if intime:
                             ret.append(child)
-                            if child.pid not in checkpids:
-                                checkpids.append(child.pid)
+                            stack.append(child_pid)
+                    except (NoSuchProcess, ZombieProcess):
+                        pass
         return ret
 
-    def cpu_percent(self, interval=None):
+    @_use_prefetch
+    def cpu_percent(self, interval: float | None = None) -> float:
         """Return a float representing the current process CPU
         utilization as a percentage.
 
-        When interval is 0.0 or None (default) compares process times
+        When *interval* is 0.0 or None (default) compares process times
         to system CPU times elapsed since last call, returning
         immediately (non-blocking). That means that the first time
-        this is called it will return a meaningful 0.0 value.
+        this is called it will return a meaningless 0.0 value.
 
-        When interval is > 0.0 compares process times to system CPU
+        When *interval* is > 0.0 compares process times to system CPU
         times elapsed before and after the interval (blocking).
 
         In this case is recommended for accuracy that this function
         be called with at least 0.1 seconds between calls.
 
+        A value > 100.0 can be returned in case of processes running
+        multiple threads on different CPU cores.
+
+        The returned value is explicitly NOT split evenly between
+        all available logical CPUs. This means that a busy loop process
+        running on a system with 2 logical CPUs will be reported as
+        having 100% CPU utilization instead of 50%.
+
         Examples:
 
           >>> import psutil
@@ -921,13 +1234,14 @@ def cpu_percent(self, interval=None):
           >>>
         """
         blocking = interval is not None and interval > 0.0
+        if interval is not None and interval < 0:
+            msg = f"interval is not positive (got {interval!r})"
+            raise ValueError(msg)
         num_cpus = cpu_count() or 1
-        if POSIX:
-            def timer():
-                return _timer() * num_cpus
-        else:
-            def timer():
-                return sum(cpu_times())
+
+        def timer():
+            return _timer() * num_cpus
+
         if blocking:
             st1 = timer()
             pt1 = self._proc.cpu_times()
@@ -954,12 +1268,12 @@ def timer():
             # This is the utilization split evenly between all CPUs.
             # E.g. a busy loop process on a 2-CPU-cores system at this
             # point is reported as 50% instead of 100%.
-            overall_cpus_percent = ((delta_proc / delta_time) * 100)
+            overall_cpus_percent = (delta_proc / delta_time) * 100
         except ZeroDivisionError:
             # interval was too low
             return 0.0
         else:
-            # Note 1.
+            # Note 1:
             # in order to emulate "top" we multiply the value for the num
             # of CPU cores. This way the busy process will be reported as
             # having 100% (or more) usage.
@@ -968,7 +1282,7 @@ def timer():
             # taskmgr.exe on Windows differs in that it will show 50%
             # instead.
             #
-            # Note #3:
+            # Note 3:
             # a percentage > 100 is legitimate as it can result from a
             # process with multiple threads running on different CPU
             # cores (top does the same), see:
@@ -977,91 +1291,156 @@ def timer():
             single_cpu_percent = overall_cpus_percent * num_cpus
             return round(single_cpu_percent, 1)
 
-    def cpu_times(self):
-        """Return a (user, system, children_user, children_system)
-        namedtuple representing the accumulated process time, in
-        seconds.
-        This is similar to os.times() but per-process.
-        On OSX and Windows children_user and children_system are
-        always set to 0.
+    @_use_prefetch
+    @memoize_when_activated
+    def cpu_times(self) -> pcputimes:
+        """Return a `(user, system, children_user, children_system)`
+        named tuple representing the accumulated process time,
+        expressed in seconds.
+
+        Linux includes an additional `iowait` field.
+
+        On macOS and Windows `children_user` and `children_system`
+        fields are always set to 0.
         """
         return self._proc.cpu_times()
 
-    def memory_info(self):
-        """Return a namedtuple with variable fields depending on the
+    @_use_prefetch
+    @memoize_when_activated
+    def memory_info(self) -> pmem:
+        """Return a named tuple with variable fields depending on the
         platform, representing memory information about the process.
 
-        The "portable" fields available on all plaforms are `rss` and `vms`.
+        The portable fields available on all platforms are `rss` and `vms`.
 
         All numbers are expressed in bytes.
         """
         return self._proc.memory_info()
 
-    @deprecated_method(replacement="memory_info")
-    def memory_info_ex(self):
-        return self.memory_info()
+    # Linux, macOS, Windows
+    if hasattr(_psplatform.Process, "memory_extras"):
+
+        @_use_prefetch
+        def memory_extras(self) -> pmem_extras:
+            """Return a named tuple with extra platform-specific memory
+            metrics, complementing `memory_info()`.
 
-    def memory_full_info(self):
-        """This method returns the same information as memory_info(),
-        plus, on some platform (Linux, OSX, Windows), also provides
-        additional metrics (USS, PSS and swap).
-        The additional metrics provide a better representation of actual
-        process memory usage.
+            All numbers are expressed in bytes.
+            """
+            return self._proc.memory_extras()
 
-        Namely USS is the memory which is unique to a process and which
-        would be freed if the process was terminated right now.
+    # Linux, macOS, Windows
+    if hasattr(_psplatform.Process, "memory_footprint"):
 
-        It does so by passing through the whole process address.
-        As such it usually requires higher user privileges than
-        memory_info() and is considerably slower.
-        """
-        return self._proc.memory_full_info()
+        @_use_prefetch
+        def memory_footprint(self) -> pfootprint:
+            """Return a named tuple with USS memory, and on Linux also
+            PSS and swap.
+
+            These values provide a more accurate representation of
+            actual process memory usage.
 
-    def memory_percent(self, memtype="rss"):
+            USS is the memory unique to a process and which would
+            be freed if the process was terminated right now.
+
+            It does so by passing through the whole process address. As
+            such it usually requires higher user privileges than
+            `memory_info()` or `memory_extras()` and is considerably
+            slower.
+            """
+            return self._proc.memory_footprint()
+
+    # DEPRECATED
+    def memory_full_info(self) -> pfullmem:
+        """Return the same information as `memory_info()` plus
+        `memory_footprint()` in a single named tuple.
+
+        DEPRECATED in 8.0.0. Use `memory_footprint()` instead.
+        """
+        msg = (
+            "memory_full_info() is deprecated; use memory_footprint() instead"
+        )
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+        basic_mem = self.memory_info()
+        if self._is_ad_value(basic_mem):
+            return basic_mem
+        if hasattr(self, "memory_footprint"):
+            fp = self.memory_footprint()
+            if self._is_ad_value(fp):
+                return fp
+            return _ntp.pfullmem(*basic_mem + fp)
+        return _ntp.pfullmem(*basic_mem)
+
+    @_use_prefetch
+    def memory_percent(self, memtype: str = "rss") -> float:
         """Compare process memory to total physical system memory and
         calculate process memory utilization as a percentage.
-        'memtype' argument is a string that dictates what type of
-        process memory you want to compare against (defaults to "rss").
-        The list of available strings can be obtained like this:
 
-        >>> psutil.Process().memory_info()._fields
-        ('rss', 'vms', 'shared', 'text', 'lib', 'data', 'dirty', 'uss', 'pss')
+        *memtype* argument is a string that dictates what type of
+        process memory you want to compare against (defaults to
+        "rss"). It can be any field of `memory_info()`,
+        `memory_extras()` or `memory_footprint()`. The divisor is
+        always total physical memory, regardless of *memtype*.
         """
-        valid_types = list(_psplatform.pfullmem._fields)
-        if hasattr(_psplatform, "pfullmem"):
-            valid_types.extend(list(_psplatform.pfullmem._fields))
+        valid_types = list(_ntp.pmem._fields)
+        if hasattr(_ntp, "pmem_extras"):
+            valid_types += [
+                f for f in _ntp.pmem_extras._fields if f not in valid_types
+            ]
+        if hasattr(_ntp, "pfootprint"):
+            valid_types += [
+                f for f in _ntp.pfootprint._fields if f not in valid_types
+            ]
         if memtype not in valid_types:
-            raise ValueError("invalid memtype %r; valid types are %r" % (
-                memtype, tuple(valid_types)))
-        fun = self.memory_full_info if memtype in ('uss', 'pss', 'swap') else \
-            self.memory_info
+            msg = (
+                f"invalid memtype {memtype!r}; valid types are"
+                f" {tuple(valid_types)!r}"
+            )
+            raise ValueError(msg)
+
+        if memtype in _ntp.pmem._fields:
+            fun = self.memory_info
+        elif (
+            hasattr(_ntp, "pmem_extras")
+            and memtype in _ntp.pmem_extras._fields
+        ):
+            fun = self.memory_extras
+        else:
+            fun = self.memory_footprint
+
         metrics = fun()
+        if self._is_ad_value(metrics):
+            return metrics
         value = getattr(metrics, memtype)
 
         # use cached value if available
         total_phymem = _TOTAL_PHYMEM or virtual_memory().total
         if not total_phymem > 0:
             # we should never get here
-            raise ValueError(
-                "can't calculate process memory percent because "
-                "total physical system memory is not positive (%r)"
-                % total_phymem)
+            msg = (
+                "can't calculate process memory percent because total physical"
+                f" system memory is not positive ({total_phymem!r})"
+            )
+            raise ValueError(msg)
         return (value / float(total_phymem)) * 100
 
     if hasattr(_psplatform.Process, "memory_maps"):
-        # Available everywhere except OpenBSD and NetBSD.
 
-        def memory_maps(self, grouped=True):
-            """Return process' mapped memory regions as a list of namedtuples
-            whose fields are variable depending on the platform.
+        @_use_prefetch
+        def memory_maps(
+            self, grouped: bool = True
+        ) -> list[pmmap_grouped] | list[pmmap_ext]:
+            """Return process mapped memory regions as a list of named
+            tuples whose fields are variable depending on the platform.
 
-            If 'grouped' is True the mapped regions with the same 'path'
+            If *grouped* is True the mapped regions with the same 'path'
             are grouped together and the different memory fields are summed.
 
-            If 'grouped' is False every mapped region is shown as a single
-            entity and the namedtuple will also include the mapped region's
+            If *grouped* is False every mapped region is shown as a single
+            entity and the named tuple will also include the mapped region's
             address space ('addr') and permission set ('perms').
             """
+
             it = self._proc.memory_maps()
             if grouped:
                 d = {}
@@ -1069,145 +1448,216 @@ def memory_maps(self, grouped=True):
                     path = tupl[2]
                     nums = tupl[3:]
                     try:
-                        d[path] = map(lambda x, y: x + y, d[path], nums)
+                        d[path] = list(map(lambda x, y: x + y, d[path], nums))
                     except KeyError:
                         d[path] = nums
-                nt = _psplatform.pmmap_grouped
-                return [nt(path, *d[path]) for path in d]  # NOQA
+                return [_ntp.pmmap_grouped(path, *d[path]) for path in d]
             else:
-                nt = _psplatform.pmmap_ext
-                return [nt(*x) for x in it]
+                return [_ntp.pmmap_ext(*x) for x in it]
+
+    @_use_prefetch
+    def page_faults(self) -> ppagefaults:
+        """Return the number of page faults for this process as a
+        `(minor, major)` named tuple.
+
+        - `minor` (a.k.a. *soft* faults): occur when a memory page is
+          not currently mapped into the process address space, but is
+          already present in physical RAM (e.g. a shared library page
+          loaded by another process). The kernel resolves these without
+          disk I/O.
+
+        - `major` (a.k.a. *hard* faults): occur when the page must be
+          fetched from disk. These are expensive because they stall the
+          process until I/O completes.
 
-    def open_files(self):
-        """Return files opened by process as a list of
-        (path, fd) namedtuples including the absolute file name
-        and file descriptor number.
+        Both counters are cumulative since process creation.
+        """
+        return self._proc.page_faults()
+
+    @_use_prefetch
+    def open_files(self) -> list[popenfile]:
+        """Return files opened by process as a list of `(path, fd)`
+        named tuples including the absolute file name and file
+        descriptor number.
+
+        On Linux the named tuple also includes `position`, `mode` and
+        `flags` fields.
         """
         return self._proc.open_files()
 
-    def connections(self, kind='inet'):
-        """Return connections opened by process as a list of
-        (fd, family, type, laddr, raddr, status) namedtuples.
-        The 'kind' parameter filters for connections that match the
+    @_use_prefetch
+    def net_connections(self, kind: str = "inet") -> list[pconn]:
+        """Return socket connections opened by process as a list of
+        `(fd, family, type, laddr, raddr, status)` named tuples.
+
+        The *kind* parameter filters for connections that match the
         following criteria:
 
-        Kind Value      Connections using
-        inet            IPv4 and IPv6
-        inet4           IPv4
-        inet6           IPv6
-        tcp             TCP
-        tcp4            TCP over IPv4
-        tcp6            TCP over IPv6
-        udp             UDP
-        udp4            UDP over IPv4
-        udp6            UDP over IPv6
-        unix            UNIX socket (both UDP and TCP protocols)
-        all             the sum of all the possible families and protocols
+        +------------+----------------------------------------------------+
+        | Kind Value | Connections using                                  |
+        +------------+----------------------------------------------------+
+        | 'inet'     | IPv4 and IPv6                                      |
+        | 'inet4'    | IPv4                                               |
+        | 'inet6'    | IPv6                                               |
+        | 'tcp'      | TCP                                                |
+        | 'tcp4'     | TCP over IPv4                                      |
+        | 'tcp6'     | TCP over IPv6                                      |
+        | 'udp'      | UDP                                                |
+        | 'udp4'     | UDP over IPv4                                      |
+        | 'udp6'     | UDP over IPv6                                      |
+        | 'unix'     | UNIX socket (both UDP and TCP protocols)           |
+        | 'all'      | the sum of all the possible families and protocols |
+        +------------+----------------------------------------------------+
         """
-        return self._proc.connections(kind)
+        _check_conn_kind(kind)
+        return self._proc.net_connections(kind)
+
+    @_common.deprecated_method(replacement="net_connections")
+    def connections(self, kind="inet") -> list[pconn]:
+        return self.net_connections(kind=kind)
+
+    # --- signals
 
     if POSIX:
+
         def _send_signal(self, sig):
-            if self.pid == 0:
+            assert not self.pid < 0, self.pid
+            self._raise_if_pid_reused()
+
+            pid, ppid, name = self.pid, self._ppid, self._name
+            if pid == 0:
                 # see "man 2 kill"
-                raise ValueError(
+                msg = (
                     "preventing sending signal to process with PID 0 as it "
                     "would affect every process in the process group of the "
-                    "calling process (os.getpid()) instead of PID 0")
+                    "calling process (os.getpid()) instead of PID 0"
+                )
+                raise ValueError(msg)
             try:
-                os.kill(self.pid, sig)
-            except OSError as err:
-                if err.errno == errno.ESRCH:
-                    if OPENBSD and pid_exists(self.pid):
-                        # We do this because os.kill() lies in case of
-                        # zombie processes.
-                        raise ZombieProcess(self.pid, self._name, self._ppid)
-                    else:
-                        self._gone = True
-                        raise NoSuchProcess(self.pid, self._name)
-                if err.errno in (errno.EPERM, errno.EACCES):
-                    raise AccessDenied(self.pid, self._name)
-                raise
-
-    @_assert_pid_not_reused
-    def send_signal(self, sig):
-        """Send a signal to process pre-emptively checking whether
-        PID has been reused (see signal module constants) .
-        On Windows only SIGTERM is valid and is treated as an alias
-        for kill().
+                os.kill(pid, sig)
+            except ProcessLookupError as err:
+                if OPENBSD and pid_exists(pid):
+                    # We do this because os.kill() lies in case of
+                    # zombie processes.
+                    raise ZombieProcess(pid, name, ppid) from err
+                self._gone = True
+                raise NoSuchProcess(pid, name) from err
+            except PermissionError as err:
+                raise AccessDenied(pid, name) from err
+
+    def send_signal(self, sig: int) -> None:
+        """Send a signal *sig* to process, preemptively checking
+        whether PID has been reused (see signal module constants).
+
+        On Windows only SIGTERM, CTRL_C_EVENT and CTRL_BREAK_EVENT
+        are valid. SIGTERM is treated as an alias for `kill()`.
         """
         if POSIX:
             self._send_signal(sig)
         else:  # pragma: no cover
-            if sig == signal.SIGTERM:
-                self._proc.kill()
-            # py >= 2.7
-            elif sig in (getattr(signal, "CTRL_C_EVENT", object()),
-                         getattr(signal, "CTRL_BREAK_EVENT", object())):
-                self._proc.send_signal(sig)
-            else:
-                raise ValueError(
-                    "only SIGTERM, CTRL_C_EVENT and CTRL_BREAK_EVENT signals "
-                    "are supported on Windows")
-
-    @_assert_pid_not_reused
-    def suspend(self):
-        """Suspend process execution with SIGSTOP pre-emptively checking
+            self._raise_if_pid_reused()
+            if sig != signal.SIGTERM and not self.is_running():
+                msg = "process no longer exists"
+                raise NoSuchProcess(self.pid, self._name, msg=msg)
+            self._proc.send_signal(sig)
+
+    def suspend(self) -> None:
+        """Suspend process execution with SIGSTOP preemptively checking
         whether PID has been reused.
-        On Windows this has the effect ot suspending all process threads.
+
+        On Windows this has the effect of suspending all process threads.
         """
         if POSIX:
             self._send_signal(signal.SIGSTOP)
         else:  # pragma: no cover
+            self._raise_if_pid_reused()
             self._proc.suspend()
 
-    @_assert_pid_not_reused
-    def resume(self):
-        """Resume process execution with SIGCONT pre-emptively checking
+    def resume(self) -> None:
+        """Resume process execution with SIGCONT preemptively checking
         whether PID has been reused.
+
         On Windows this has the effect of resuming all process threads.
         """
         if POSIX:
             self._send_signal(signal.SIGCONT)
         else:  # pragma: no cover
+            self._raise_if_pid_reused()
             self._proc.resume()
 
-    @_assert_pid_not_reused
-    def terminate(self):
-        """Terminate the process with SIGTERM pre-emptively checking
+    def terminate(self) -> None:
+        """Terminate the process with SIGTERM preemptively checking
         whether PID has been reused.
-        On Windows this is an alias for kill().
+
+        On Windows this is an alias for `kill()`.
         """
         if POSIX:
             self._send_signal(signal.SIGTERM)
         else:  # pragma: no cover
+            self._raise_if_pid_reused()
             self._proc.kill()
 
-    @_assert_pid_not_reused
-    def kill(self):
-        """Kill the current process with SIGKILL pre-emptively checking
+    def kill(self) -> None:
+        """Kill the current process with SIGKILL preemptively checking
         whether PID has been reused.
         """
         if POSIX:
             self._send_signal(signal.SIGKILL)
         else:  # pragma: no cover
+            self._raise_if_pid_reused()
             self._proc.kill()
 
-    def wait(self, timeout=None):
-        """Wait for process to terminate and, if process is a children
+    def wait(self, timeout: float | None = None) -> int | None:
+        """Wait for process to terminate, and if process is a child
         of os.getpid(), also return its exit code, else None.
 
-        If the process is already terminated immediately return None
-        instead of raising NoSuchProcess.
+        On Windows there's no such limitation (exit code is always
+        returned).
 
-        If timeout (in seconds) is specified and process is still alive
-        raise TimeoutExpired.
+        If the process is already terminated, immediately return None
+        instead of raising `NoSuchProcess`.
 
-        To wait for multiple Process(es) use psutil.wait_procs().
+        If *timeout* (in seconds) is specified and process is still
+        alive, raise `TimeoutExpired`.
+
+        If *timeout=0* either return immediately or raise
+        `TimeoutExpired` (non-blocking).
+
+        To wait for multiple Process objects use `psutil.wait_procs()`.
         """
-        if timeout is not None and not timeout >= 0:
-            raise ValueError("timeout must be a positive integer")
-        return self._proc.wait(timeout)
+        if self.pid == 0:
+            msg = "can't wait for PID 0"
+            raise ValueError(msg)
+        if timeout is not None:
+            if not isinstance(timeout, (int, float)):
+                msg = f"timeout must be an int or float (got {type(timeout)})"
+                raise TypeError(msg)
+            if timeout < 0:
+                msg = f"timeout must be positive or zero (got {timeout})"
+                raise ValueError(msg)
+
+        if self._exitcode is not _SENTINEL:
+            return self._exitcode
+
+        try:
+            self._exitcode = self._proc.wait(timeout)
+        except TimeoutExpired as err:
+            exc = TimeoutExpired(timeout, pid=self.pid, name=self._name)
+            raise exc from err
+
+        return self._exitcode
+
+
+# The valid attr names which can be processed by Process.as_dict(attrs=...)
+# and process_iter(attrs=...).
+# fmt: off
+Process.attrs = frozenset(
+    x for x in dir(Process) if not x.startswith("_") and x not in
+     {'send_signal', 'suspend', 'resume', 'terminate', 'kill', 'wait',
+      'is_running', 'as_dict', 'parent', 'parents', 'children', 'rlimit',
+      'connections', 'memory_full_info', 'oneshot', 'info', 'attrs'}
+)
+# fmt: on
 
 
 # =====================================================================
@@ -1216,38 +1666,34 @@ def wait(self, timeout=None):
 
 
 class Popen(Process):
-    """A more convenient interface to stdlib subprocess.Popen class.
-    It starts a sub process and deals with it exactly as when using
-    subprocess.Popen class but in addition also provides all the
-    properties and methods of psutil.Process class as a unified
-    interface:
+    """Same as `subprocess.Popen`, but in addition it provides all
+    `Process` methods in a single class.
+
+    For the following methods which are common to both classes, psutil
+    implementation takes precedence:
+
+    * `send_signal()`
+    * `terminate()`
+    * `kill()`
+
+    This is done in order to avoid killing another process in case its
+    PID has been reused, fixing BPO-6973.
 
       >>> import psutil
       >>> from subprocess import PIPE
       >>> p = psutil.Popen(["python", "-c", "print 'hi'"], stdout=PIPE)
       >>> p.name()
-      'python'
+      'python3'
       >>> p.uids()
       user(real=1000, effective=1000, saved=1000)
       >>> p.username()
       'giampaolo'
       >>> p.communicate()
-      ('hi\n', None)
+      ('hi', None)
       >>> p.terminate()
       >>> p.wait(timeout=2)
       0
       >>>
-
-    For method names common to both classes such as kill(), terminate()
-    and wait(), psutil.Process implementation takes precedence.
-
-    Unlike subprocess.Popen this class pre-emptively checks whether PID
-    has been reused on send_signal(), terminate() and kill() so that
-    you don't accidentally terminate another process, fixing
-    http://bugs.python.org/issue6973.
-
-    For a complete documentation refer to:
-    http://docs.python.org/library/subprocess.html
     """
 
     def __init__(self, *args, **kwargs):
@@ -1260,6 +1706,27 @@ def __init__(self, *args, **kwargs):
     def __dir__(self):
         return sorted(set(dir(Popen) + dir(subprocess.Popen)))
 
+    def __enter__(self) -> Popen:
+        if hasattr(self.__subproc, '__enter__'):
+            self.__subproc.__enter__()
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        if hasattr(self.__subproc, '__exit__'):
+            return self.__subproc.__exit__(*args, **kwargs)
+        else:
+            if self.stdout:
+                self.stdout.close()
+            if self.stderr:
+                self.stderr.close()
+            try:
+                # Flushing a BufferedWriter may raise an error.
+                if self.stdin:
+                    self.stdin.close()
+            finally:
+                # Wait for the process to terminate, to avoid zombies.
+                self.wait()
+
     def __getattribute__(self, name):
         try:
             return object.__getattribute__(self, name)
@@ -1267,39 +1734,35 @@ def __getattribute__(self, name):
             try:
                 return object.__getattribute__(self.__subproc, name)
             except AttributeError:
-                raise AttributeError("%s instance has no attribute '%s'"
-                                     % (self.__class__.__name__, name))
+                msg = f"{self.__class__!r} has no attribute {name!r}"
+                raise AttributeError(msg) from None
 
-    def wait(self, timeout=None):
+    def wait(self, timeout: float | None = None) -> int | None:
         if self.__subproc.returncode is not None:
             return self.__subproc.returncode
-        ret = super(Popen, self).wait(timeout)
+        ret = super().wait(timeout)
         self.__subproc.returncode = ret
         return ret
 
 
-# The valid attr names which can be processed by Process.as_dict().
-_as_dict_attrnames = set(
-    [x for x in dir(Process) if not x.startswith('_') and x not in
-     ['send_signal', 'suspend', 'resume', 'terminate', 'kill', 'wait',
-      'is_running', 'as_dict', 'parent', 'children', 'rlimit',
-      'memory_info_ex']])
-
-
 # =====================================================================
 # --- system processes related functions
 # =====================================================================
 
 
-def pids():
+def pids() -> list[int]:
     """Return a list of current running PIDs."""
-    return _psplatform.pids()
+    global _LOWEST_PID
+    ret = sorted(_psplatform.pids())
+    _LOWEST_PID = ret[0]
+    return ret
+
 
+def pid_exists(pid: int) -> bool:
+    """Return True if *pid* exists in the current process list.
 
-def pid_exists(pid):
-    """Return True if given PID exists in the current process list.
-    This is faster than doing "pid in psutil.pids()" and
-    should be preferred.
+    This is faster than doing `pid in psutil.pids()` and should be
+    preferred.
     """
     if pid < 0:
         return False
@@ -1315,81 +1778,120 @@ def pid_exists(pid):
 
 
 _pmap = {}
+_pids_reused = set()
 
 
-def process_iter():
-    """Return a generator yielding a Process instance for all
+def process_iter(
+    attrs: Collection[str] | None = None, ad_value: Any = None
+) -> Iterator[Process]:
+    """Return a generator yielding a `Process` instance for all
     running processes.
 
-    Every new Process instance is only created once and then cached
+    Every new `Process` instance is only created once and then cached
     into an internal table which is updated every time this is used.
-
-    Cached Process instances are checked for identity so that you're
-    safe in case a PID has been reused by another process, in which
-    case the cached instance is updated.
+    Cache can optionally be cleared via `process_iter.cache_clear()`.
 
     The sorting order in which processes are yielded is based on
     their PIDs.
+
+    *attrs* and *ad_value* have the same meaning as in
+    `Process.as_dict()`.
+
+    If *attrs* is specified, `Process.as_dict()` is called and the
+    results are cached, so that subsequent method calls (e.g.
+    `p.name()`) return cached values. Use `attrs=Process.attrs` to
+    retrieve all process info (slow).
+
+    If a method raises `AccessDenied` during pre-fetch, it will return
+    *ad_value* (default None) instead of raising.
     """
+    global _pmap
+
     def add(pid):
         proc = Process(pid)
-        _pmap[proc.pid] = proc
+        pmap[proc.pid] = proc
         return proc
 
     def remove(pid):
-        _pmap.pop(pid, None)
-
+        pmap.pop(pid, None)
+
+    if attrs is not None:
+        if attrs == []:  # deprecated in 8.0.0
+            msg = (
+                "process_iter(attrs=[]) is deprecated; use "
+                "process_iter(attrs=Process.attrs) to retrieve all attributes"
+            )
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+        elif not attrs:
+            # as_dict() will resolve an empty list|tuple|set to "all
+            # attribute names", but it's ambiguous and should be
+            # signaled.
+            msg = (
+                f"process_iter(attrs={attrs}) is ambiguous; use "
+                "process_iter(attrs=Process.attrs) to retrieve all attributes"
+            )
+            warnings.warn(msg, UserWarning, stacklevel=2)
+
+    pmap = _pmap.copy()
     a = set(pids())
-    b = set(_pmap.keys())
+    b = set(pmap)
     new_pids = a - b
     gone_pids = b - a
-
     for pid in gone_pids:
         remove(pid)
-    for pid, proc in sorted(list(_pmap.items()) +
-                            list(dict.fromkeys(new_pids).items())):
-        try:
-            if proc is None:  # new process
-                yield add(pid)
-            else:
-                # use is_running() to check whether PID has been reused by
-                # another process in which case yield a new Process instance
-                if proc.is_running():
-                    yield proc
-                else:
-                    yield add(pid)
-        except NoSuchProcess:
-            remove(pid)
-        except AccessDenied:
-            # Process creation time can't be determined hence there's
-            # no way to tell whether the pid of the cached process
-            # has been reused. Just return the cached version.
-            if proc is None and pid in _pmap:
-                try:
-                    yield _pmap[pid]
-                except KeyError:
-                    # If we get here it is likely that 2 threads were
-                    # using process_iter().
-                    pass
-            else:
-                raise
+    while _pids_reused:
+        pid = _pids_reused.pop()
+        debug(f"refreshing Process instance for reused PID {pid}")
+        remove(pid)
+    try:
+        ls = sorted(list(pmap.items()) + list(dict.fromkeys(new_pids).items()))
+        for pid, proc in ls:
+            try:
+                if proc is None:  # new process
+                    proc = add(pid)
+                proc._prefetch = {}  # clear cache
+                proc._ad_value = _SENTINEL
+                if attrs is not None:
+                    proc._prefetch = proc.as_dict(
+                        attrs=attrs, ad_value=ad_value
+                    )
+                    proc._ad_value = ad_value
+                yield proc
+            except ZombieProcess:
+                if proc is not None:
+                    yield proc  # zombie processes are still valid
+            except NoSuchProcess:
+                remove(pid)
+    finally:
+        _pmap = pmap
+
+
+process_iter.cache_clear = lambda: _pmap.clear()  # noqa: PLW0108
+process_iter.cache_clear.__doc__ = "Clear process_iter() internal cache."
 
 
-def wait_procs(procs, timeout=None, callback=None):
+def wait_procs(
+    procs: list[Process],
+    timeout: float | None = None,
+    callback: Callable[[Process], None] | None = None,
+) -> tuple[list[Process], list[Process]]:
     """Convenience function which waits for a list of processes to
     terminate.
 
-    Return a (gone, alive) tuple indicating which processes
+    Return a `(gone, alive)` tuple indicating which processes
     are gone and which ones are still alive.
 
-    The gone ones will have a new 'returncode' attribute indicating
+    The gone ones will have a new `returncode` attribute indicating
     process exit status (may be None).
 
-    'callback' is a function which gets called every time a process
-    terminates (a Process instance is passed as callback argument).
+    *callback* is a function which gets called every time a process
+    terminates (a `Process` instance is passed as callback argument).
 
     Function will return as soon as all processes terminate or when
-    timeout occurs.
+    *timeout* occurs.
+
+    Differently from `Process.wait()` it will not raise `TimeoutExpired` if
+    *timeout* occurs.
 
     Typical use case is:
 
@@ -1409,25 +1911,29 @@ def wait_procs(procs, timeout=None, callback=None):
     >>> for p in alive:
     ...     p.kill()
     """
+
     def check_gone(proc, timeout):
         try:
             returncode = proc.wait(timeout=timeout)
-        except TimeoutExpired:
+        except (TimeoutExpired, subprocess.TimeoutExpired):
             pass
         else:
             if returncode is not None or not proc.is_running():
+                # Set new Process instance attribute.
                 proc.returncode = returncode
                 gone.add(proc)
                 if callback is not None:
                     callback(proc)
 
     if timeout is not None and not timeout >= 0:
-        msg = "timeout must be a positive integer, got %s" % timeout
+        msg = f"timeout must be a positive integer, got {timeout}"
         raise ValueError(msg)
+    if callback is not None and not callable(callback):
+        msg = f"callback {callback!r} is not a callable"
+        raise TypeError(msg)
+
     gone = set()
     alive = set(procs)
-    if callback is not None and not callable(callback):
-        raise TypeError("callback %r is not a callable" % callable)
     if timeout is not None:
         deadline = _timer() + timeout
 
@@ -1449,14 +1955,14 @@ def check_gone(proc, timeout):
                 check_gone(proc, timeout)
             else:
                 check_gone(proc, max_timeout)
-        alive = alive - gone
+        alive = alive - gone  # noqa: PLR6104
 
     if alive:
         # Last attempt over processes survived so far.
         # timeout == 0 won't make this function wait any further.
         for proc in alive:
             check_gone(proc, 0)
-        alive = alive - gone
+        alive = alive - gone  # noqa: PLR6104
 
     return (list(gone), list(alive))
 
@@ -1466,12 +1972,11 @@ def check_gone(proc, timeout):
 # =====================================================================
 
 
-@memoize
-def cpu_count(logical=True):
+def cpu_count(logical: bool = True) -> int | None:
     """Return the number of logical CPUs in the system (same as
-    os.cpu_count() in Python 3.4).
+    `os.cpu_count()`).
 
-    If logical is False return the number of physical cores only
+    If *logical* is False return the number of physical cores only
     (e.g. hyper thread CPUs are excluded).
 
     Return None if undetermined.
@@ -1482,30 +1987,36 @@ def cpu_count(logical=True):
     >>> psutil.cpu_count.cache_clear()
     """
     if logical:
-        return _psplatform.cpu_count_logical()
+        ret = _psplatform.cpu_count_logical()
     else:
-        return _psplatform.cpu_count_physical()
-
-
-def cpu_times(percpu=False):
-    """Return system-wide CPU times as a namedtuple.
-    Every CPU time represents the seconds the CPU has spent in the given mode.
-    The namedtuple's fields availability varies depending on the platform:
-     - user
-     - system
-     - idle
-     - nice (UNIX)
-     - iowait (Linux)
-     - irq (Linux, FreeBSD)
-     - softirq (Linux)
-     - steal (Linux >= 2.6.11)
-     - guest (Linux >= 2.6.24)
-     - guest_nice (Linux >= 3.2.0)
-
-    When percpu is True return a list of namedtuples for each CPU.
-    First element of the list refers to first CPU, second element
-    to second CPU and so on.
-    The order of the list is consistent across calls.
+        ret = _psplatform.cpu_count_cores()
+    if ret is not None and ret < 1:
+        ret = None
+    return ret
+
+
+def cpu_times(percpu: bool = False) -> scputimes | list[scputimes]:
+    """Return system-wide CPU times as a named tuple.
+
+    Every CPU time represents the seconds the CPU has spent in the
+    given mode:
+
+    - `user`
+    - `system`
+    - `idle`
+    - `nice` (UNIX)
+    - `iowait` (Linux)
+    - `irq` (Linux, FreeBSD)
+    - `softirq` (Linux)
+    - `steal` (Linux)
+    - `guest` (Linux)
+    - `guest_nice` (Linux)
+    - `dpc` (Windows)
+
+    When *percpu* is True return a list of named tuples for each
+    logical CPU. First element of the list refers to first CPU, second
+    element to second CPU and so on. The order of the list is
+    consistent across calls.
     """
     if not percpu:
         return _psplatform.cpu_times()
@@ -1514,35 +2025,90 @@ def cpu_times(percpu=False):
 
 
 try:
-    _last_cpu_times = cpu_times()
-except Exception:
+    _last_cpu_times = {threading.current_thread().ident: cpu_times()}
+except Exception:  # noqa: BLE001
     # Don't want to crash at import time.
-    _last_cpu_times = None
-    traceback.print_exc()
+    _last_cpu_times = {}
 
 try:
-    _last_per_cpu_times = cpu_times(percpu=True)
-except Exception:
+    _last_per_cpu_times = {
+        threading.current_thread().ident: cpu_times(percpu=True)
+    }
+except Exception:  # noqa: BLE001
     # Don't want to crash at import time.
-    _last_per_cpu_times = None
-    traceback.print_exc()
+    _last_per_cpu_times = {}
 
 
-def cpu_percent(interval=None, percpu=False):
+def _cpu_tot_time(times):
+    """Given a `cpu_time()` named tuple calculates the total CPU time
+    (including idle time).
+    """
+    tot = sum(times)
+    if LINUX:
+        # On Linux guest times are already accounted in "user" or
+        # "nice" times, so we subtract them from total.
+        # Htop does the same. References:
+        # https://github.com/giampaolo/psutil/pull/940
+        # http://unix.stackexchange.com/questions/178045
+        # https://github.com/torvalds/linux/blob/447976ef4/kernel/sched/cputime.c#L158
+        tot -= times.guest
+        tot -= times.guest_nice
+    return tot
+
+
+def _cpu_busy_time(times):
+    """Given a `cpu_time()` named tuple calculates the busy CPU time by
+    subtracting all idle CPU times.
+    """
+    busy = _cpu_tot_time(times)
+    busy -= times.idle
+    # Linux: "iowait" is time during which the CPU does not do anything
+    # (waits for IO to complete). On Linux IO wait is *not* accounted
+    # in "idle" time so we subtract it. Htop does the same.
+    # References:
+    # https://github.com/torvalds/linux/blob/447976ef4/kernel/sched/cputime.c#L244
+    busy -= getattr(times, "iowait", 0)
+    return busy
+
+
+def _cpu_times_deltas(t1, t2):
+    assert t1._fields == t2._fields, (t1, t2)
+    field_deltas = []
+    for field in _ntp.scputimes._fields:
+        field_delta = getattr(t2, field) - getattr(t1, field)
+        # CPU times are always supposed to increase over time
+        # or at least remain the same and that's because time
+        # cannot go backwards.
+        # Surprisingly sometimes this might not be the case (at
+        # least on Windows and Linux), see:
+        # https://github.com/giampaolo/psutil/issues/392
+        # https://github.com/giampaolo/psutil/issues/645
+        # https://github.com/giampaolo/psutil/issues/1210
+        # Trim negative deltas to zero to ignore decreasing fields.
+        # top does the same. Reference:
+        # https://gitlab.com/procps-ng/procps/blob/v3.3.12/top/top.c#L5063
+        field_delta = max(0, field_delta)
+        field_deltas.append(field_delta)
+    return _ntp.scputimes(*field_deltas)
+
+
+def cpu_percent(
+    interval: float | None = None, percpu: bool = False
+) -> float | list[float]:
     """Return a float representing the current system-wide CPU
     utilization as a percentage.
 
-    When interval is > 0.0 compares system CPU times elapsed before
+    When *interval* is > 0.0 compares system CPU times elapsed before
     and after the interval (blocking).
 
-    When interval is 0.0 or None compares system CPU times elapsed
+    When *interval* is 0.0 or None compares system CPU times elapsed
     since last call or module import, returning immediately (non
     blocking). That means the first time this is called it will
     return a meaningless 0.0 value which you should ignore.
     In this case is recommended for accuracy that this function be
     called with at least 0.1 seconds between calls.
 
-    When percpu is True returns a list of floats representing the
+    When *percpu* is True returns a list of floats representing the
     utilization as a percentage for each CPU.
     First element of the list refers to first CPU, second element
     to second CPU and so on.
@@ -1563,25 +2129,23 @@ def cpu_percent(interval=None, percpu=False):
       2.9
       >>>
     """
-    global _last_cpu_times
-    global _last_per_cpu_times
+    tid = threading.current_thread().ident
     blocking = interval is not None and interval > 0.0
+    if interval is not None and interval < 0:
+        msg = f"interval is not positive (got {interval})"
+        raise ValueError(msg)
 
     def calculate(t1, t2):
-        t1_all = sum(t1)
-        t1_busy = t1_all - t1.idle
+        times_delta = _cpu_times_deltas(t1, t2)
+        all_delta = _cpu_tot_time(times_delta)
+        busy_delta = _cpu_busy_time(times_delta)
 
-        t2_all = sum(t2)
-        t2_busy = t2_all - t2.idle
-
-        # this usually indicates a float precision issue
-        if t2_busy <= t1_busy:
+        try:
+            busy_perc = (busy_delta / all_delta) * 100
+        except ZeroDivisionError:
             return 0.0
-
-        busy_delta = t2_busy - t1_busy
-        all_delta = t2_all - t1_all
-        busy_perc = (busy_delta / all_delta) * 100
-        return round(busy_perc, 1)
+        else:
+            return round(busy_perc, 1)
 
     # system-wide usage
     if not percpu:
@@ -1589,14 +2153,9 @@ def calculate(t1, t2):
             t1 = cpu_times()
             time.sleep(interval)
         else:
-            t1 = _last_cpu_times
-            if t1 is None:
-                # Something bad happened at import time. We'll
-                # get a meaningful result on the next call. See:
-                # https://github.com/giampaolo/psutil/pull/715
-                t1 = cpu_times()
-        _last_cpu_times = cpu_times()
-        return calculate(t1, _last_cpu_times)
+            t1 = _last_cpu_times.get(tid) or cpu_times()
+        _last_cpu_times[tid] = cpu_times()
+        return calculate(t1, _last_cpu_times[tid])
     # per-cpu usage
     else:
         ret = []
@@ -1604,28 +2163,25 @@ def calculate(t1, t2):
             tot1 = cpu_times(percpu=True)
             time.sleep(interval)
         else:
-            tot1 = _last_per_cpu_times
-            if tot1 is None:
-                # Something bad happened at import time. We'll
-                # get a meaningful result on the next call. See:
-                # https://github.com/giampaolo/psutil/pull/715
-                tot1 = cpu_times(percpu=True)
-        _last_per_cpu_times = cpu_times(percpu=True)
-        for t1, t2 in zip(tot1, _last_per_cpu_times):
+            tot1 = _last_per_cpu_times.get(tid) or cpu_times(percpu=True)
+        _last_per_cpu_times[tid] = cpu_times(percpu=True)
+        for t1, t2 in zip(tot1, _last_per_cpu_times[tid]):
             ret.append(calculate(t1, t2))
         return ret
 
 
-# Use separate global vars for cpu_times_percent() so that it's
-# independent from cpu_percent() and they can both be used within
-# the same program.
-_last_cpu_times_2 = _last_cpu_times
-_last_per_cpu_times_2 = _last_per_cpu_times
+# Use a separate dict for cpu_times_percent(), so it's independent from
+# cpu_percent() and they can both be used within the same program.
+_last_cpu_times_2 = _last_cpu_times.copy()
+_last_per_cpu_times_2 = _last_per_cpu_times.copy()
+
 
+def cpu_times_percent(
+    interval: float | None = None, percpu: bool = False
+) -> scputimes | list[scputimes]:
+    """Same as `cpu_percent()`, but provides utilization percentages
+    for each specific CPU time as is returned by `cpu_times()`.
 
-def cpu_times_percent(interval=None, percpu=False):
-    """Same as cpu_percent() but provides utilization percentages
-    for each specific CPU time as is returned by cpu_times().
     For instance, on Linux we'll get:
 
       >>> cpu_times_percent()
@@ -1633,39 +2189,31 @@ def cpu_times_percent(interval=None, percpu=False):
                  irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
       >>>
 
-    interval and percpu arguments have the same meaning as in
-    cpu_percent().
+    *interval* and *percpu* arguments have the same meaning as in
+    `cpu_percent()`.
     """
-    global _last_cpu_times_2
-    global _last_per_cpu_times_2
+    tid = threading.current_thread().ident
     blocking = interval is not None and interval > 0.0
+    if interval is not None and interval < 0:
+        msg = f"interval is not positive (got {interval!r})"
+        raise ValueError(msg)
 
     def calculate(t1, t2):
         nums = []
-        all_delta = sum(t2) - sum(t1)
-        for field in t1._fields:
-            field_delta = getattr(t2, field) - getattr(t1, field)
-            try:
-                field_perc = (100 * field_delta) / all_delta
-            except ZeroDivisionError:
-                field_perc = 0.0
+        times_delta = _cpu_times_deltas(t1, t2)
+        all_delta = _cpu_tot_time(times_delta)
+        # "scale" is the value to multiply each delta with to get percentages.
+        # We use "max" to avoid division by zero (if all_delta is 0, then all
+        # fields are 0 so percentages will be 0 too. all_delta cannot be a
+        # fraction because cpu times are integers)
+        scale = 100.0 / max(1, all_delta)
+        for field_delta in times_delta:
+            field_perc = field_delta * scale
             field_perc = round(field_perc, 1)
-            # CPU times are always supposed to increase over time
-            # or at least remain the same and that's because time
-            # cannot go backwards.
-            # Surprisingly sometimes this might not be the case (at
-            # least on Windows and Linux), see:
-            # https://github.com/giampaolo/psutil/issues/392
-            # https://github.com/giampaolo/psutil/issues/645
-            # I really don't know what to do about that except
-            # forcing the value to 0 or 100.
-            if field_perc > 100.0:
-                field_perc = 100.0
-            # `<=` because `-0.0 == 0.0` evaluates to True
-            elif field_perc <= 0.0:
-                field_perc = 0.0
+            # make sure we don't return negative values or values over 100%
+            field_perc = min(max(0.0, field_perc), 100.0)
             nums.append(field_perc)
-        return _psplatform.scputimes(*nums)
+        return _ntp.scputimes(*nums)
 
     # system-wide usage
     if not percpu:
@@ -1673,14 +2221,9 @@ def calculate(t1, t2):
             t1 = cpu_times()
             time.sleep(interval)
         else:
-            t1 = _last_cpu_times_2
-            if t1 is None:
-                # Something bad happened at import time. We'll
-                # get a meaningful result on the next call. See:
-                # https://github.com/giampaolo/psutil/pull/715
-                t1 = cpu_times()
-        _last_cpu_times_2 = cpu_times()
-        return calculate(t1, _last_cpu_times_2)
+            t1 = _last_cpu_times_2.get(tid) or cpu_times()
+        _last_cpu_times_2[tid] = cpu_times()
+        return calculate(t1, _last_cpu_times_2[tid])
     # per-cpu usage
     else:
         ret = []
@@ -1688,80 +2231,114 @@ def calculate(t1, t2):
             tot1 = cpu_times(percpu=True)
             time.sleep(interval)
         else:
-            tot1 = _last_per_cpu_times_2
-            if tot1 is None:
-                # Something bad happened at import time. We'll
-                # get a meaningful result on the next call. See:
-                # https://github.com/giampaolo/psutil/pull/715
-                tot1 = cpu_times(percpu=True)
-        _last_per_cpu_times_2 = cpu_times(percpu=True)
-        for t1, t2 in zip(tot1, _last_per_cpu_times_2):
+            tot1 = _last_per_cpu_times_2.get(tid) or cpu_times(percpu=True)
+        _last_per_cpu_times_2[tid] = cpu_times(percpu=True)
+        for t1, t2 in zip(tot1, _last_per_cpu_times_2[tid]):
             ret.append(calculate(t1, t2))
         return ret
 
 
-def cpu_stats():
+def cpu_stats() -> scpustats:
     """Return CPU statistics."""
     return _psplatform.cpu_stats()
 
 
+if hasattr(_psplatform, "cpu_freq"):
+
+    def cpu_freq(percpu: bool = False) -> scpufreq | list[scpufreq] | None:
+        """Return CPU frequency as a named tuple including current,
+        min and max frequency expressed in Mhz.
+
+        If *percpu* is True and the system supports per-cpu frequency
+        retrieval (Linux and FreeBSD), a list of frequencies is
+        returned for each CPU. If not, a list with one element is
+        returned.
+        """
+        ret = _psplatform.cpu_freq()
+        if percpu:
+            return ret
+        else:
+            num_cpus = float(len(ret))
+            if num_cpus == 0:
+                return None
+            elif num_cpus == 1:
+                return ret[0]
+            else:
+                currs, mins, maxs = 0.0, 0.0, 0.0
+                set_none = False
+                for cpu in ret:
+                    currs += cpu.current
+                    # On FreeBSD min/max are None if the sysctl value
+                    # can't be parsed.
+                    if cpu.min is None or cpu.max is None:
+                        set_none = True
+                        continue
+                    mins += cpu.min
+                    maxs += cpu.max
+
+                current = currs / num_cpus
+
+                if set_none:
+                    min_ = max_ = None
+                else:
+                    min_ = mins / num_cpus
+                    max_ = maxs / num_cpus
+
+                return _ntp.scpufreq(current, min_, max_)
+
+    __all__.append("cpu_freq")
+
+
+def getloadavg() -> tuple[float, float, float]:
+    """Return the average system load over the last 1, 5 and 15 minutes
+    as a tuple.
+
+    On Windows this is emulated by using a Windows API that spawns a
+    thread which keeps running in background and updates results every
+    5 seconds, mimicking the UNIX behavior.
+    """
+    if hasattr(os, "getloadavg"):
+        return os.getloadavg()
+    else:
+        return _psplatform.getloadavg()
+
+
 # =====================================================================
 # --- system memory related functions
 # =====================================================================
 
 
-def virtual_memory():
-    """Return statistics about system memory usage as a namedtuple
-    including the following fields, expressed in bytes:
+def virtual_memory() -> svmem:
+    """Return statistics about system memory usage as a named tuple.
+
+    The fields vary by platform (see official doc), but the following
+    are present on all platforms:
 
      - total:
-       total physical memory available.
+       total physical memory available
 
      - available:
-       the actual amount of available memory that can be given
-       instantly to processes that request more memory in bytes; this
-       is calculated by summing different memory values depending on
-       the platform (e.g. free + buffers + cached on Linux) and it is
-       supposed to be used to monitor actual memory usage in a cross
-       platform fashion.
+       the memory that can be given instantly to processes without the
+       system going into swap.
+       This is calculated by summing different memory values depending
+       on the platform and it is supposed to be used to monitor actual
+       memory usage in a cross platform fashion.
 
      - percent:
-       the percentage usage calculated as (total - available) / total * 100
+       the percentage usage calculated as `(total - available) / total * 100`
 
      - used:
-       memory used, calculated differently depending on the platform and
-       designed for informational purposes only:
-        OSX: active + inactive + wired
-        BSD: active + wired + cached
-        LINUX: total - free
+        memory used, calculated differently depending on the platform and
+        designed for informational purposes only
 
      - free:
        memory not being used at all (zeroed) that is readily available;
        note that this doesn't reflect the actual memory available
        (use 'available' instead)
 
-    Platform-specific fields:
-
-     - active (UNIX):
-       memory currently in use or very recently used, and so it is in RAM.
-
-     - inactive (UNIX):
-       memory that is marked as not used.
+    The sum of `used` and `available` does not necessarily equal `total`.
 
-     - buffers (BSD, Linux):
-       cache for things like file system metadata.
-
-     - cached (BSD, OSX):
-       cache for various things.
-
-     - wired (OSX, BSD):
-       memory that is marked to always stay in RAM. It is never moved to disk.
-
-     - shared (BSD):
-       memory that may be simultaneously accessed by multiple processes.
-
-    The sum of 'used' and 'available' does not necessarily equal total.
-    On Windows 'available' and 'free' are the same.
+    On Windows `available` and `free` are the same.
     """
     global _TOTAL_PHYMEM
     ret = _psplatform.virtual_memory()
@@ -1770,8 +2347,8 @@ def virtual_memory():
     return ret
 
 
-def swap_memory():
-    """Return system swap memory statistics as a namedtuple including
+def swap_memory() -> sswap:
+    """Return system swap memory statistics as a named tuple including
     the following fields:
 
      - total:   total swap memory in bytes
@@ -1781,65 +2358,85 @@ def swap_memory():
      - sin:     no. of bytes the system has swapped in from disk (cumulative)
      - sout:    no. of bytes the system has swapped out from disk (cumulative)
 
-    'sin' and 'sout' on Windows are meaningless and always set to 0.
+    `sin` and `sout` on Windows are meaningless and always set to 0.
     """
     return _psplatform.swap_memory()
 
 
 # =====================================================================
-# --- disks/paritions related functions
+# --- disks/partitions related functions
 # =====================================================================
 
 
-def disk_usage(path):
-    """Return disk usage statistics about the given path as a namedtuple
-    including total, used and free space expressed in bytes plus the
-    percentage usage.
+def disk_usage(path: str) -> sdiskusage:
+    """Return disk usage statistics about the given *path* as a
+    named tuple including total, used and free space expressed in bytes
+    plus the percentage usage.
     """
     return _psplatform.disk_usage(path)
 
 
-def disk_partitions(all=False):
+def disk_partitions(all: bool = False) -> list[sdiskpart]:
     """Return mounted partitions as a list of
-    (device, mountpoint, fstype, opts) namedtuple.
-    'opts' field is a raw string separated by commas indicating mount
+    (device, mountpoint, fstype, opts) named tuple.
+
+    `opts` field is a raw string separated by commas indicating mount
     options which may vary depending on the platform.
 
-    If "all" parameter is False return physical devices only and ignore
+    If *all* parameter is False return physical devices only and ignore
     all others.
     """
     return _psplatform.disk_partitions(all)
 
 
-def disk_io_counters(perdisk=False):
-    """Return system disk I/O statistics as a namedtuple including
+def disk_io_counters(
+    perdisk: bool = False, nowrap: bool = True
+) -> sdiskio | dict[str, sdiskio] | None:
+    """Return system disk I/O statistics as a named tuple including
     the following fields:
 
      - read_count:  number of reads
      - write_count: number of writes
      - read_bytes:  number of bytes read
      - write_bytes: number of bytes written
-     - read_time:   time spent reading from disk (in milliseconds)
-     - write_time:  time spent writing to disk (in milliseconds)
+     - read_time:   (not NetBSD, OpenBSD) time spent reading from
+       disk (in ms)
+     - write_time:  (not NetBSD, OpenBSD) time spent writing to
+       disk (in ms)
+
+    Platform specific:
 
-    If perdisk is True return the same information for every
-    physical disk installed on the system as a dictionary
-    with partition names as the keys and the namedtuple
-    described above as the values.
+     - busy_time: (Linux, FreeBSD) time spent doing actual I/Os (in ms)
+     - read_merged_count (Linux): number of merged reads
+     - write_merged_count (Linux): number of merged writes
 
-    On recent Windows versions 'diskperf -y' command may need to be
-    executed first otherwise this function won't find any disk.
+    If *perdisk* is True return the same information for every
+    physical disk as a dictionary with partition names as the keys.
+
+    If *nowrap* is True (default), counters that overflow and wrap to
+    zero are automatically adjusted so they never decrease (this can
+    happen on very busy or long-lived systems).
+    `disk_io_counters.cache_clear()` can be used to invalidate the
+    *nowrap* cache.
     """
-    rawdict = _psplatform.disk_io_counters()
+    kwargs = dict(perdisk=perdisk) if LINUX else {}
+    rawdict = _psplatform.disk_io_counters(**kwargs)
     if not rawdict:
-        raise RuntimeError("couldn't find any physical disk")
-    nt = getattr(_psplatform, "sdiskio", _common.sdiskio)
+        return {} if perdisk else None
+    if nowrap:
+        rawdict = _wrap_numbers(rawdict, 'psutil.disk_io_counters')
     if perdisk:
         for disk, fields in rawdict.items():
-            rawdict[disk] = nt(*fields)
+            rawdict[disk] = _ntp.sdiskio(*fields)
         return rawdict
     else:
-        return nt(*[sum(x) for x in zip(*rawdict.values())])
+        return _ntp.sdiskio(*(sum(x) for x in zip(*rawdict.values())))
+
+
+disk_io_counters.cache_clear = functools.partial(
+    _wrap_numbers.cache_clear, 'psutil.disk_io_counters'
+)
+disk_io_counters.cache_clear.__doc__ = "Clears nowrap argument cache"
 
 
 # =====================================================================
@@ -1847,8 +2444,10 @@ def disk_io_counters(perdisk=False):
 # =====================================================================
 
 
-def net_io_counters(pernic=False):
-    """Return network I/O statistics as a namedtuple including
+def net_io_counters(
+    pernic: bool = False, nowrap: bool = True
+) -> snetio | dict[str, snetio] | None:
+    """Return network I/O statistics as a named tuple including
     the following fields:
 
      - bytes_sent:   number of bytes sent
@@ -1859,139 +2458,253 @@ def net_io_counters(pernic=False):
      - errout:       total number of errors while sending
      - dropin:       total number of incoming packets which were dropped
      - dropout:      total number of outgoing packets which were dropped
-                     (always 0 on OSX and BSD)
+                     (always 0 on macOS and BSD)
 
-    If pernic is True return the same information for every
-    network interface installed on the system as a dictionary
-    with network interface names as the keys and the namedtuple
-    described above as the values.
+    If *pernic* is True return the same information for every
+    network interface as a dictionary with interface names as the
+    keys.
+
+    If *nowrap* is True (default), counters that overflow and wrap to
+    zero are automatically adjusted so they never decrease (this can
+    happen on very busy or long-lived systems).
+    `net_io_counters.cache_clear()` can be used to invalidate the
+    *nowrap* cache.
     """
     rawdict = _psplatform.net_io_counters()
     if not rawdict:
-        raise RuntimeError("couldn't find any network interface")
+        return {} if pernic else None
+    if nowrap:
+        rawdict = _wrap_numbers(rawdict, 'psutil.net_io_counters')
     if pernic:
         for nic, fields in rawdict.items():
-            rawdict[nic] = _common.snetio(*fields)
+            rawdict[nic] = _ntp.snetio(*fields)
         return rawdict
     else:
-        return _common.snetio(*[sum(x) for x in zip(*rawdict.values())])
+        return _ntp.snetio(*[sum(x) for x in zip(*rawdict.values())])
+
 
+net_io_counters.cache_clear = functools.partial(
+    _wrap_numbers.cache_clear, 'psutil.net_io_counters'
+)
+net_io_counters.cache_clear.__doc__ = "Clears nowrap argument cache"
 
-def net_connections(kind='inet'):
-    """Return system-wide connections as a list of
-    (fd, family, type, laddr, raddr, status, pid) namedtuples.
-    In case of limited privileges 'fd' and 'pid' may be set to -1
+
+def net_connections(kind: str = 'inet') -> list[sconn]:
+    """Return system-wide socket connections as a list of
+    (fd, family, type, laddr, raddr, status, pid) named tuples.
+
+    In case of limited privileges `fd` and `pid` may be set to -1
     and None respectively.
-    The 'kind' parameter filters for connections that fit the
+
+    The *kind* parameter filters for connections that fit the
     following criteria:
 
-    Kind Value      Connections using
-    inet            IPv4 and IPv6
-    inet4           IPv4
-    inet6           IPv6
-    tcp             TCP
-    tcp4            TCP over IPv4
-    tcp6            TCP over IPv6
-    udp             UDP
-    udp4            UDP over IPv4
-    udp6            UDP over IPv6
-    unix            UNIX socket (both UDP and TCP protocols)
-    all             the sum of all the possible families and protocols
-
-    On OSX this function requires root privileges.
+    +------------+----------------------------------------------------+
+    | Kind Value | Connections using                                  |
+    +------------+----------------------------------------------------+
+    | 'inet'     | IPv4 and IPv6                                      |
+    | 'inet4'    | IPv4                                               |
+    | 'inet6'    | IPv6                                               |
+    | 'tcp'      | TCP                                                |
+    | 'tcp4'     | TCP over IPv4                                      |
+    | 'tcp6'     | TCP over IPv6                                      |
+    | 'udp'      | UDP                                                |
+    | 'udp4'     | UDP over IPv4                                      |
+    | 'udp6'     | UDP over IPv6                                      |
+    | 'unix'     | UNIX socket (both UDP and TCP protocols)           |
+    | 'all'      | the sum of all the possible families and protocols |
+    +------------+----------------------------------------------------+
+
+    On macOS this function requires root privileges.
     """
+    _check_conn_kind(kind)
     return _psplatform.net_connections(kind)
 
 
-def net_if_addrs():
-    """Return the addresses associated to each NIC (network interface
-    card) installed on the system as a dictionary whose keys are the
-    NIC names and value is a list of namedtuples for each address
-    assigned to the NIC. Each namedtuple includes 5 fields:
-
-     - family
-     - address
-     - netmask
-     - broadcast
-     - ptp
-
-    'family' can be either socket.AF_INET, socket.AF_INET6 or
-    psutil.AF_LINK, which refers to a MAC address.
-    'address' is the primary address and it is always set.
-    'netmask' and 'broadcast' and 'ptp' may be None.
-    'ptp' stands for "point to point" and references the destination
-    address on a point to point interface (typically a VPN).
-    'broadcast' and 'ptp' are mutually exclusive.
-
-    Note: you can have more than one address of the same family
-    associated with each interface.
+def net_if_addrs() -> dict[str, list[snicaddr]]:
+    """Return a dictionary mapping each NIC (Network Interface Card) to
+    a list of named tuples representing its addresses. Multiple
+    addresses of the same family can exist per interface.
+
+    The named tuple includes 5 fields (addresses may be None):
+
+    - family: the address family, either `AF_INET`, `AF_INET6`,
+      `psutil.AF_LINK` (a MAC address) or `AF_UNSPEC` (a virtual or
+      unconfigured NIC).
+    - address: the primary NIC address
+    - netmask: the netmask address
+    - broadcast: the broadcast address; always None on Windows
+    - ptp: a "point to point" address (typically a VPN); always None on
+      Windows
     """
-    has_enums = sys.version_info >= (3, 4)
-    if has_enums:
-        import socket
     rawlist = _psplatform.net_if_addrs()
     rawlist.sort(key=lambda x: x[1])  # sort by family
     ret = collections.defaultdict(list)
     for name, fam, addr, mask, broadcast, ptp in rawlist:
-        if has_enums:
-            try:
-                fam = socket.AddressFamily(fam)
-            except ValueError:
-                if WINDOWS and fam == -1:
-                    fam = _psplatform.AF_LINK
-                elif (hasattr(_psplatform, "AF_LINK") and
-                        _psplatform.AF_LINK == fam):
-                    # Linux defines AF_LINK as an alias for AF_PACKET.
-                    # We re-set the family here so that repr(family)
-                    # will show AF_LINK rather than AF_PACKET
-                    fam = _psplatform.AF_LINK
+        try:
+            fam = socket.AddressFamily(fam)
+        except ValueError:
+            if WINDOWS and fam == -1:
+                fam = _psplatform.AF_LINK
+            elif (
+                hasattr(_psplatform, "AF_LINK") and fam == _psplatform.AF_LINK
+            ):
+                # Linux defines AF_LINK as an alias for AF_PACKET.
+                # We re-set the family here so that repr(family)
+                # will show AF_LINK rather than AF_PACKET
+                fam = _psplatform.AF_LINK
+
         if fam == _psplatform.AF_LINK:
             # The underlying C function may return an incomplete MAC
             # address in which case we fill it with null bytes, see:
             # https://github.com/giampaolo/psutil/issues/786
             separator = ":" if POSIX else "-"
             while addr.count(separator) < 5:
-                addr += "%s00" % separator
-        ret[name].append(_common.snic(fam, addr, mask, broadcast, ptp))
+                addr += f"{separator}00"
+
+        nt = _ntp.snicaddr(fam, addr, mask, broadcast, ptp)
+
+        # On Windows broadcast is None, so we determine it via
+        # ipaddress module. On POSIX a /32 has no broadcast address,
+        # but getifaddrs() hands back the local address.
+        if nt.netmask and (
+            fam == socket.AF_INET or (WINDOWS and fam == socket.AF_INET6)
+        ):
+            try:
+                calculated = _common.broadcast_addr(nt)
+            except Exception as err:  # noqa: BLE001
+                warn(f"broadcast_addr() failed: {err!r}")
+            else:
+                if calculated is None:
+                    nt = nt._replace(broadcast=None)
+                elif WINDOWS:
+                    nt = nt._replace(broadcast=calculated)
+
+        ret[name].append(nt)
+
     return dict(ret)
 
 
-def net_if_stats():
+def net_if_stats() -> dict[str, snicstats]:
     """Return information about each NIC (network interface card)
     installed on the system as a dictionary whose keys are the
-    NIC names and value is a namedtuple with the following fields:
+    NIC names and value is a named tuple with the following fields:
 
      - isup: whether the interface is up (bool)
-     - duplex: can be either NIC_DUPLEX_FULL, NIC_DUPLEX_HALF or
-               NIC_DUPLEX_UNKNOWN
+     - duplex: can be either `NIC_DUPLEX_FULL`, `NIC_DUPLEX_HALF` or
+               `NIC_DUPLEX_UNKNOWN`
      - speed: the NIC speed expressed in mega bits (MB); if it can't
               be determined (e.g. 'localhost') it will be set to 0.
      - mtu: the maximum transmission unit expressed in bytes.
+     - flags: a string of comma-separated flags on the interface.
     """
     return _psplatform.net_if_stats()
 
 
+# =====================================================================
+# --- sensors
+# =====================================================================
+
+
+# Linux, macOS
+if hasattr(_psplatform, "sensors_temperatures"):
+
+    def sensors_temperatures(
+        fahrenheit: bool = False,
+    ) -> dict[str, list[shwtemp]]:
+        """Return hardware temperatures.
+
+        Each entry is a named tuple representing a certain hardware
+        sensor (it may be a CPU, an hard disk or something else,
+        depending on the OS and its configuration).
+
+        All temperatures are expressed in celsius unless *fahrenheit*
+        is set to True.
+        """
+
+        def convert(n):
+            if n is not None:
+                return (float(n) * 9 / 5) + 32 if fahrenheit else n
+
+        ret = collections.defaultdict(list)
+        rawdict = _psplatform.sensors_temperatures()
+
+        for name, values in rawdict.items():
+            while values:
+                label, current, high, critical = values.pop(0)
+                current = convert(current)
+                high = convert(high)
+                critical = convert(critical)
+
+                if high and not critical:
+                    critical = high
+                elif critical and not high:
+                    high = critical
+
+                ret[name].append(_ntp.shwtemp(label, current, high, critical))
+
+        return dict(ret)
+
+    __all__.append("sensors_temperatures")
+
+
+# Linux
+if hasattr(_psplatform, "sensors_fans"):
+
+    def sensors_fans() -> dict[str, list[sfan]]:
+        """Return fans speed. Each entry is a named tuple
+        representing a certain hardware sensor.
+        All speed are expressed in RPM (rounds per minute).
+        """
+        return _psplatform.sensors_fans()
+
+    __all__.append("sensors_fans")
+
+
+# Linux, Windows, FreeBSD, macOS
+if hasattr(_psplatform, "sensors_battery"):
+
+    def sensors_battery() -> sbattery | None:
+        """Return battery information. If no battery is installed
+        returns None.
+
+         - percent: battery power left as a percentage.
+         - secsleft: a rough approximation of how many seconds are left
+                     before the battery runs out of power. May be
+                     `POWER_TIME_UNLIMITED` or `POWER_TIME_UNKNOWN`.
+         - power_plugged: True if the AC power cable is connected.
+        """
+        return _psplatform.sensors_battery()
+
+    __all__.append("sensors_battery")
+
+
 # =====================================================================
 # --- other system related functions
 # =====================================================================
 
 
-def boot_time():
-    """Return the system boot time expressed in seconds since the epoch."""
-    # Note: we are not caching this because it is subject to
-    # system clock updates.
+def boot_time() -> float:
+    """Return the system boot time expressed in seconds since the epoch
+    (seconds since January 1, 1970, at midnight UTC).
+
+    The returned value is based on the system clock, which means it may
+    be affected by changes such as manual adjustments or time
+    synchronization (e.g. NTP).
+    """
     return _psplatform.boot_time()
 
 
-def users():
+def users() -> list[suser]:
     """Return users currently connected on the system as a list of
-    namedtuples including the following fields.
+    named tuples including the following fields:
 
      - user: the name of the user
      - terminal: the tty or pseudo-tty associated with the user, if any.
      - host: the host name associated with the entry, if any.
      - started: the creation time as a floating point number expressed in
        seconds since the epoch.
+     - pid: the PID of the login process (None on Windows and OpenBSD).
     """
     return _psplatform.users()
 
@@ -2003,81 +2716,77 @@ def users():
 
 if WINDOWS:
 
-    def win_service_iter():
-        """Return a generator yielding a WindowsService instance for all
-        Windows services installed.
+    def win_service_iter() -> Iterator[WindowsService]:
+        """Return a generator yielding a `WindowsService` instance for
+        all Windows services installed.
         """
         return _psplatform.win_service_iter()
 
-    def win_service_get(name):
-        """Get a Windows service by name.
-        Raise NoSuchProcess if no service with such name exists.
+    def win_service_get(name) -> WindowsService:
+        """Get a Windows service by *name*.
+
+        Raise `NoSuchProcess` if no service with such name exists.
         """
         return _psplatform.win_service_get(name)
 
 
 # =====================================================================
+# --- malloc / heap
+# =====================================================================
 
 
-def test():  # pragma: no cover
-    """List info of all currently running processes emulating ps aux
-    output.
+# Linux + glibc, Windows, macOS, FreeBSD, NetBSD
+if hasattr(_psplatform, "heap_info"):
+
+    def heap_info() -> pheap:
+        """Return low-level heap statistics from the C heap allocator
+        (glibc).
+
+        - `heap_used`: the total number of bytes allocated via
+          malloc/free. These are typically allocations smaller than
+          MMAP_THRESHOLD.
+
+        - `mmap_used`: the total number of bytes allocated via `mmap()`
+          or via large ``malloc()`` allocations.
+
+        - `heap_count` (Windows only): number of private heaps created
+          via `HeapCreate()`.
+        """
+        return _ntp.pheap(*_psplatform.heap_info())
+
+    def heap_trim() -> None:
+        """Request that the underlying allocator free any unused memory
+        it's holding in the heap (typically small `malloc()`
+        allocations).
+
+        In practice, modern allocators rarely comply, so this is not a
+        general-purpose memory-reduction tool and won't meaningfully
+        shrink RSS in real programs. Its primary value is in **leak
+        detection tools**.
+
+        Calling `heap_trim()` before taking measurements helps reduce
+        allocator noise, giving you a cleaner baseline so that changes
+        in `heap_used` come from the code you're testing, not from
+        internal allocator caching or fragmentation. Its effectiveness
+        depends on allocator behavior and fragmentation patterns.
+        """
+        _psplatform.heap_trim()
+
+    __all__.append("heap_info")
+    __all__.append("heap_trim")
+
+
+# =====================================================================
+
+
+def _set_debug(value):
+    """Enable or disable `PSUTIL_DEBUG` option, which prints debugging
+    messages to stderr.
     """
-    import datetime
+    import psutil._common
 
-    today_day = datetime.date.today()
-    templ = "%-10s %5s %4s %4s %7s %7s %-13s %5s %7s  %s"
-    attrs = ['pid', 'cpu_percent', 'memory_percent', 'name', 'cpu_times',
-             'create_time', 'memory_info']
-    if POSIX:
-        attrs.append('uids')
-        attrs.append('terminal')
-    print(templ % ("USER", "PID", "%CPU", "%MEM", "VSZ", "RSS", "TTY",
-                   "START", "TIME", "COMMAND"))
-    for p in process_iter():
-        try:
-            pinfo = p.as_dict(attrs, ad_value='')
-        except NoSuchProcess:
-            pass
-        else:
-            if pinfo['create_time']:
-                ctime = datetime.datetime.fromtimestamp(pinfo['create_time'])
-                if ctime.date() == today_day:
-                    ctime = ctime.strftime("%H:%M")
-                else:
-                    ctime = ctime.strftime("%b%d")
-            else:
-                ctime = ''
-            cputime = time.strftime("%M:%S",
-                                    time.localtime(sum(pinfo['cpu_times'])))
-            try:
-                user = p.username()
-            except Error:
-                user = ''
-            if WINDOWS and '\\' in user:
-                user = user.split('\\')[1]
-            vms = pinfo['memory_info'] and \
-                int(pinfo['memory_info'].vms / 1024) or '?'
-            rss = pinfo['memory_info'] and \
-                int(pinfo['memory_info'].rss / 1024) or '?'
-            memp = pinfo['memory_percent'] and \
-                round(pinfo['memory_percent'], 1) or '?'
-            print(templ % (
-                user[:10],
-                pinfo['pid'],
-                pinfo['cpu_percent'],
-                memp,
-                vms,
-                rss,
-                pinfo.get('terminal', '') or '?',
-                ctime,
-                cputime,
-                pinfo['name'].strip() or '?'))
-
-
-del memoize, division, deprecated_method
-if sys.version_info[0] < 3:
-    del num, x
-
-if __name__ == "__main__":
-    test()
+    psutil._common.PSUTIL_DEBUG = bool(value)
+    _psutil.set_debug(bool(value))
+
+
+del memoize_when_activated
diff --git a/psutil/_common.py b/psutil/_common.py
index c595724115..cf73879c81 100644
--- a/psutil/_common.py
+++ b/psutil/_common.py
@@ -2,22 +2,24 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""Common objects shared by __init__.py and _ps*.py modules."""
+"""Common objects shared by __init__.py and _ps*.py modules.
 
-from __future__ import division
+Note: this module is imported by setup.py, so it should not import
+psutil or third-party modules.
+"""
 
-import contextlib
-import errno
+import collections
 import functools
 import os
 import socket
 import stat
 import sys
+import threading
 import warnings
-from collections import namedtuple
 from socket import AF_INET
 from socket import SOCK_DGRAM
 from socket import SOCK_STREAM
+
 try:
     from socket import AF_INET6
 except ImportError:
@@ -27,35 +29,28 @@
 except ImportError:
     AF_UNIX = None
 
-if sys.version_info >= (3, 4):
-    import enum
-else:
-    enum = None
 
+PSUTIL_DEBUG = bool(os.getenv('PSUTIL_DEBUG'))
+PSUTIL_TESTING = bool(os.getenv('PSUTIL_TESTING'))
+_DEFAULT = object()
+
+# fmt: off
 __all__ = [
     # OS constants
-    'FREEBSD', 'BSD', 'LINUX', 'NETBSD', 'OPENBSD', 'OSX', 'POSIX', 'SUNOS',
-    'WINDOWS',
-    # connection constants
-    'CONN_CLOSE', 'CONN_CLOSE_WAIT', 'CONN_CLOSING', 'CONN_ESTABLISHED',
-    'CONN_FIN_WAIT1', 'CONN_FIN_WAIT2', 'CONN_LAST_ACK', 'CONN_LISTEN',
-    'CONN_NONE', 'CONN_SYN_RECV', 'CONN_SYN_SENT', 'CONN_TIME_WAIT',
-    # net constants
-    'NIC_DUPLEX_FULL', 'NIC_DUPLEX_HALF', 'NIC_DUPLEX_UNKNOWN',
-    # process status constants
-    'STATUS_DEAD', 'STATUS_DISK_SLEEP', 'STATUS_IDLE', 'STATUS_LOCKED',
-    'STATUS_RUNNING', 'STATUS_SLEEPING', 'STATUS_STOPPED', 'STATUS_SUSPENDED',
-    'STATUS_TRACING_STOP', 'STATUS_WAITING', 'STATUS_WAKE_KILL',
-    'STATUS_WAKING', 'STATUS_ZOMBIE',
-    # named tuples
-    'pconn', 'pcputimes', 'pctxsw', 'pgids', 'pio', 'pionice', 'popenfile',
-    'pthread', 'puids', 'sconn', 'scpustats', 'sdiskio', 'sdiskpart',
-    'sdiskusage', 'snetio', 'snic', 'snicstats', 'sswap', 'suser',
+    'FREEBSD', 'BSD', 'LINUX', 'NETBSD', 'OPENBSD', 'MACOS', 'OSX', 'POSIX',
+    'SUNOS', 'WINDOWS',
+    # other constants
+    'ENCODING', 'ENCODING_ERRS', 'AF_INET6',
     # utility functions
-    'conn_tmap', 'deprecated_method', 'isfile_strict', 'memoize',
+    'conn_tmap', 'deprecated_method', 'isfile_strict',
     'parse_environ_block', 'path_exists_strict', 'usage_percent',
-    'supports_ipv6', 'sockfam_to_enum', 'socktype_to_enum',
+    'supports_ipv6', 'sockfam_to_enum', 'socktype_to_enum', "wrap_numbers",
+    'open_text', 'open_binary', 'cat', 'bcat',
+    'bytes2human', 'conn_to_ntuple', 'debug', 'warn',
+    # shell utils
+    'hilite', 'term_supports_colors', 'print_color',
 ]
+# fmt: on
 
 
 # ===================================================================
@@ -65,125 +60,22 @@
 
 POSIX = os.name == "posix"
 WINDOWS = os.name == "nt"
-LINUX = sys.platform.startswith("linux")
-OSX = sys.platform.startswith("darwin")
-FREEBSD = sys.platform.startswith("freebsd")
+LINUX = sys.platform.startswith(("linux", "android"))
+MACOS = sys.platform.startswith("darwin")
+OSX = MACOS  # deprecated alias
+FREEBSD = sys.platform.startswith(("freebsd", "midnightbsd"))
 OPENBSD = sys.platform.startswith("openbsd")
 NETBSD = sys.platform.startswith("netbsd")
 BSD = FREEBSD or OPENBSD or NETBSD
-SUNOS = sys.platform.startswith("sunos") or sys.platform.startswith("solaris")
-
-
-# ===================================================================
-# --- API constants
-# ===================================================================
-
+SUNOS = sys.platform.startswith(("sunos", "solaris"))
+AIX = sys.platform.startswith("aix")
 
-# Process.status()
-STATUS_RUNNING = "running"
-STATUS_SLEEPING = "sleeping"
-STATUS_DISK_SLEEP = "disk-sleep"
-STATUS_STOPPED = "stopped"
-STATUS_TRACING_STOP = "tracing-stop"
-STATUS_ZOMBIE = "zombie"
-STATUS_DEAD = "dead"
-STATUS_WAKE_KILL = "wake-kill"
-STATUS_WAKING = "waking"
-STATUS_IDLE = "idle"  # FreeBSD, OSX
-STATUS_LOCKED = "locked"  # FreeBSD
-STATUS_WAITING = "waiting"  # FreeBSD
-STATUS_SUSPENDED = "suspended"  # NetBSD
-
-# Process.connections() and psutil.net_connections()
-CONN_ESTABLISHED = "ESTABLISHED"
-CONN_SYN_SENT = "SYN_SENT"
-CONN_SYN_RECV = "SYN_RECV"
-CONN_FIN_WAIT1 = "FIN_WAIT1"
-CONN_FIN_WAIT2 = "FIN_WAIT2"
-CONN_TIME_WAIT = "TIME_WAIT"
-CONN_CLOSE = "CLOSE"
-CONN_CLOSE_WAIT = "CLOSE_WAIT"
-CONN_LAST_ACK = "LAST_ACK"
-CONN_LISTEN = "LISTEN"
-CONN_CLOSING = "CLOSING"
-CONN_NONE = "NONE"
-
-# net_if_stats()
-if enum is None:
-    NIC_DUPLEX_FULL = 2
-    NIC_DUPLEX_HALF = 1
-    NIC_DUPLEX_UNKNOWN = 0
-else:
-    class NicDuplex(enum.IntEnum):
-        NIC_DUPLEX_FULL = 2
-        NIC_DUPLEX_HALF = 1
-        NIC_DUPLEX_UNKNOWN = 0
-
-    globals().update(NicDuplex.__members__)
+ENCODING = sys.getfilesystemencoding()
+ENCODING_ERRS = sys.getfilesystemencodeerrors()
 
 
 # ===================================================================
-# --- namedtuples
-# ===================================================================
-
-# --- for system functions
-
-# psutil.swap_memory()
-sswap = namedtuple('sswap', ['total', 'used', 'free', 'percent', 'sin',
-                             'sout'])
-# psutil.disk_usage()
-sdiskusage = namedtuple('sdiskusage', ['total', 'used', 'free', 'percent'])
-# psutil.disk_io_counters()
-sdiskio = namedtuple('sdiskio', ['read_count', 'write_count',
-                                 'read_bytes', 'write_bytes',
-                                 'read_time', 'write_time'])
-# psutil.disk_partitions()
-sdiskpart = namedtuple('sdiskpart', ['device', 'mountpoint', 'fstype', 'opts'])
-# psutil.net_io_counters()
-snetio = namedtuple('snetio', ['bytes_sent', 'bytes_recv',
-                               'packets_sent', 'packets_recv',
-                               'errin', 'errout',
-                               'dropin', 'dropout'])
-# psutil.users()
-suser = namedtuple('suser', ['name', 'terminal', 'host', 'started'])
-# psutil.net_connections()
-sconn = namedtuple('sconn', ['fd', 'family', 'type', 'laddr', 'raddr',
-                             'status', 'pid'])
-# psutil.net_if_addrs()
-snic = namedtuple('snic', ['family', 'address', 'netmask', 'broadcast', 'ptp'])
-# psutil.net_if_stats()
-snicstats = namedtuple('snicstats', ['isup', 'duplex', 'speed', 'mtu'])
-# psutil.cpu_stats()
-scpustats = namedtuple(
-    'scpustats', ['ctx_switches', 'interrupts', 'soft_interrupts', 'syscalls'])
-
-# --- for Process methods
-
-# psutil.Process.cpu_times()
-pcputimes = namedtuple('pcputimes',
-                       ['user', 'system', 'children_user', 'children_system'])
-# psutil.Process.open_files()
-popenfile = namedtuple('popenfile', ['path', 'fd'])
-# psutil.Process.threads()
-pthread = namedtuple('pthread', ['id', 'user_time', 'system_time'])
-# psutil.Process.uids()
-puids = namedtuple('puids', ['real', 'effective', 'saved'])
-# psutil.Process.gids()
-pgids = namedtuple('pgids', ['real', 'effective', 'saved'])
-# psutil.Process.io_counters()
-pio = namedtuple('pio', ['read_count', 'write_count',
-                         'read_bytes', 'write_bytes'])
-# psutil.Process.ionice()
-pionice = namedtuple('pionice', ['ioclass', 'value'])
-# psutil.Process.ctx_switches()
-pctxsw = namedtuple('pctxsw', ['voluntary', 'involuntary'])
-# psutil.Process.connections()
-pconn = namedtuple('pconn', ['fd', 'family', 'type', 'laddr', 'raddr',
-                             'status'])
-
-
-# ===================================================================
-# --- Process.connections() 'kind' parameter mapping
+# --- Process.net_connections() 'kind' parameter mapping
 # ===================================================================
 
 
@@ -204,12 +96,114 @@ class NicDuplex(enum.IntEnum):
         "udp6": ([AF_INET6], [SOCK_DGRAM]),
     })
 
-if AF_UNIX is not None:
-    conn_tmap.update({
-        "unix": ([AF_UNIX], [SOCK_STREAM, SOCK_DGRAM]),
-    })
+if AF_UNIX is not None and not SUNOS:
+    conn_tmap.update({"unix": ([AF_UNIX], [SOCK_STREAM, SOCK_DGRAM])})
+
+
+# =====================================================================
+# --- Exceptions
+# =====================================================================
+
+
+class Error(Exception):
+    """Base exception class. All other psutil exceptions inherit
+    from this one.
+    """
+
+    __module__ = 'psutil'
+
+    def _infodict(self, attrs):
+        info = {}
+        for name in attrs:
+            value = getattr(self, name, None)
+            if value or (name == "pid" and value == 0):
+                info[name] = value
+        return info
+
+    def __str__(self):
+        # invoked on `raise Error`
+        if info := self._infodict(("pid", "ppid", "name")):
+            details = "({})".format(
+                ", ".join([f"{k}={v!r}" for k, v in info.items()])
+            )
+        else:
+            details = None
+        return " ".join([x for x in (getattr(self, "msg", ""), details) if x])
+
+    def __repr__(self):
+        # invoked on `repr(Error)`
+        info = self._infodict(("pid", "ppid", "name", "seconds", "msg"))
+        details = ", ".join([f"{k}={v!r}" for k, v in info.items()])
+        return f"psutil.{self.__class__.__name__}({details})"
+
+
+class NoSuchProcess(Error):
+    """Exception raised when a process with a certain PID doesn't
+    or no longer exists.
+    """
+
+    __module__ = 'psutil'
+
+    def __init__(self, pid, name=None, msg=None):
+        Error.__init__(self)
+        self.pid = pid
+        self.name = name
+        self.msg = msg or "process no longer exists"
+
+    def __reduce__(self):
+        return (self.__class__, (self.pid, self.name, self.msg))
+
+
+class ZombieProcess(NoSuchProcess):
+    """Exception raised when querying a zombie process. This is
+    raised on macOS, BSD and Solaris only, and not always: depending
+    on the query the OS may be able to succeed anyway.
+    On Linux all zombie processes are querable (hence this is never
+    raised). Windows doesn't have zombie processes.
+    """
 
-del AF_INET, AF_INET6, AF_UNIX, SOCK_STREAM, SOCK_DGRAM
+    __module__ = 'psutil'
+
+    def __init__(self, pid, name=None, ppid=None, msg=None):
+        NoSuchProcess.__init__(self, pid, name, msg)
+        self.ppid = ppid
+        self.msg = msg or "PID still exists but it's a zombie"
+
+    def __reduce__(self):
+        return (self.__class__, (self.pid, self.name, self.ppid, self.msg))
+
+
+class AccessDenied(Error):
+    """Exception raised when permission to perform an action is denied."""
+
+    __module__ = 'psutil'
+
+    def __init__(self, pid=None, name=None, msg=None):
+        Error.__init__(self)
+        self.pid = pid
+        self.name = name
+        self.msg = msg or ""
+
+    def __reduce__(self):
+        return (self.__class__, (self.pid, self.name, self.msg))
+
+
+class TimeoutExpired(Error):
+    """Raised on Process.wait(timeout) if timeout expires and process
+    is still alive.
+    """
+
+    __module__ = 'psutil'
+
+    def __init__(self, seconds, pid=None, name=None):
+        Error.__init__(self)
+        self.seconds = seconds
+        self.pid = pid
+        self.name = name
+        self.msg = f"timeout after {seconds} seconds"
+
+    def __reduce__(self):
+        return (self.__class__, (self.seconds, self.pid, self.name))
 
 
 # ===================================================================
@@ -217,60 +211,99 @@ class NicDuplex(enum.IntEnum):
 # ===================================================================
 
 
-def usage_percent(used, total, _round=None):
+def usage_percent(used, total, round_=None):
     """Calculate percentage usage of 'used' against 'total'."""
     try:
-        ret = (used / total) * 100
+        ret = (float(used) / total) * 100
     except ZeroDivisionError:
-        ret = 0.0 if isinstance(used, float) or isinstance(total, float) else 0
-    if _round is not None:
-        return round(ret, _round)
+        return 0.0
     else:
+        if round_ is not None:
+            ret = round(ret, round_)
         return ret
 
 
-def memoize(fun):
-    """A simple memoize decorator for functions supporting (hashable)
-    positional arguments.
-    It also provides a cache_clear() function for clearing the cache:
+def memoize_when_activated(fun):
+    """A memoize decorator which is disabled by default. It can be
+    activated and deactivated on request.
+    For efficiency reasons it can be used only against class methods
+    accepting no arguments.
 
-    >>> @memoize
-    ... def foo()
-    ...     return 1
-        ...
+    >>> class Foo:
+    ...     @memoize_when_activated
+    ...     def foo()
+    ...         print(1)
+    ...
+    >>> f = Foo()
+    >>> # deactivated (default)
+    >>> foo()
+    1
     >>> foo()
     1
-    >>> foo.cache_clear()
+    >>>
+    >>> # activated
+    >>> foo.cache_activate(self)
+    >>> foo()
+    1
+    >>> foo()
+    >>> foo()
     >>>
     """
+
     @functools.wraps(fun)
-    def wrapper(*args, **kwargs):
-        key = (args, frozenset(sorted(kwargs.items())))
+    def wrapper(self):
         try:
-            return cache[key]
+            # case 1: we previously entered oneshot() ctx
+            ret = self._cache[fun]
+        except AttributeError:
+            # case 2: we never entered oneshot() ctx
+            try:
+                return fun(self)
+            except Exception as err:
+                raise err from None
         except KeyError:
-            ret = cache[key] = fun(*args, **kwargs)
-            return ret
+            # case 3: we entered oneshot() ctx but there's no cache
+            # for this entry yet
+            try:
+                ret = fun(self)
+            except Exception as err:
+                raise err from None
+            try:
+                self._cache[fun] = ret
+            except AttributeError:
+                # multi-threading race condition, see:
+                # https://github.com/giampaolo/psutil/issues/1948
+                pass
+        return ret
+
+    def cache_activate(proc):
+        """Activate cache. Expects a Process instance. Cache will be
+        stored as a "_cache" instance attribute.
+        """
+        proc._cache = {}
 
-    def cache_clear():
-        """Clear cache."""
-        cache.clear()
+    def cache_deactivate(proc):
+        """Deactivate and clear cache."""
+        try:
+            del proc._cache
+        except AttributeError:
+            pass
 
-    cache = {}
-    wrapper.cache_clear = cache_clear
+    wrapper.cache_activate = cache_activate
+    wrapper.cache_deactivate = cache_deactivate
     return wrapper
 
 
 def isfile_strict(path):
     """Same as os.path.isfile() but does not swallow EACCES / EPERM
     exceptions, see:
-    http://mail.python.org/pipermail/python-dev/2012-June/120787.html
+    http://mail.python.org/pipermail/python-dev/2012-June/120787.html.
     """
     try:
         st = os.stat(path)
-    except OSError as err:
-        if err.errno in (errno.EPERM, errno.EACCES):
-            raise
+    except PermissionError:
+        raise
+    except OSError:
         return False
     else:
         return stat.S_ISREG(st.st_mode)
@@ -278,14 +311,14 @@ def isfile_strict(path):
 
 def path_exists_strict(path):
     """Same as os.path.exists() but does not swallow EACCES / EPERM
-    exceptions, see:
-    http://mail.python.org/pipermail/python-dev/2012-June/120787.html
+    exceptions. See:
+    http://mail.python.org/pipermail/python-dev/2012-June/120787.html.
     """
     try:
         os.stat(path)
-    except OSError as err:
-        if err.errno in (errno.EPERM, errno.EACCES):
-            raise
+    except PermissionError:
+        raise
+    except OSError:
         return False
     else:
         return True
@@ -293,14 +326,13 @@ def path_exists_strict(path):
 
 def supports_ipv6():
     """Return True if IPv6 is supported on this platform."""
-    if not socket.has_ipv6 or not hasattr(socket, "AF_INET6"):
+    if not socket.has_ipv6 or AF_INET6 is None:
         return False
     try:
-        sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
-        with contextlib.closing(sock):
+        with socket.socket(AF_INET6, socket.SOCK_STREAM) as sock:
             sock.bind(("::1", 0))
         return True
-    except socket.error:
+    except OSError:
         return False
 
 
@@ -322,7 +354,7 @@ def parse_environ_block(data):
         equal_pos = data.find("=", pos, next_pos)
         if equal_pos > pos:
             key = data[pos:equal_pos]
-            value = data[equal_pos + 1:next_pos]
+            value = data[equal_pos + 1 : next_pos]
             # Windows expects environment variables to be uppercase only
             if WINDOWS_:
                 key = key.upper()
@@ -336,35 +368,78 @@ def sockfam_to_enum(num):
     """Convert a numeric socket family value to an IntEnum member.
     If it's not a known member, return the numeric value itself.
     """
-    if enum is None:
+    try:
+        return socket.AddressFamily(num)
+    except ValueError:
         return num
-    else:  # pragma: no cover
-        try:
-            return socket.AddressFamily(num)
-        except (ValueError, AttributeError):
-            return num
 
 
 def socktype_to_enum(num):
     """Convert a numeric socket type value to an IntEnum member.
     If it's not a known member, return the numeric value itself.
     """
-    if enum is None:
+    try:
+        return socket.SocketKind(num)
+    except ValueError:
         return num
-    else:  # pragma: no cover
-        try:
-            return socket.AddressType(num)
-        except (ValueError, AttributeError):
-            return num
+
+
+def conn_to_ntuple(fd, fam, type_, laddr, raddr, status, status_map, pid=None):
+    """Convert a raw connection tuple to a proper ntuple."""
+    from . import _ntuples as ntp
+    from ._enums import ConnectionStatus
+
+    if fam in {socket.AF_INET, AF_INET6}:
+        if laddr:
+            laddr = ntp.addr(*laddr)
+        if raddr:
+            raddr = ntp.addr(*raddr)
+    if type_ == socket.SOCK_STREAM and fam in {AF_INET, AF_INET6}:
+        status = status_map.get(status, ConnectionStatus.CONN_NONE)
+    else:
+        status = ConnectionStatus.CONN_NONE  # ignore whatever C returned to us
+    fam = sockfam_to_enum(fam)
+    type_ = socktype_to_enum(type_)
+    if pid is None:
+        return ntp.pconn(fd, fam, type_, laddr, raddr, status)
+    else:
+        return ntp.sconn(fd, fam, type_, laddr, raddr, status, pid)
+
+
+def broadcast_addr(addr):
+    """Given the address ntuple returned by ``net_if_addrs()``
+    calculates the broadcast address. Returns None for a single-host
+    network (/32 or /128), which has no broadcast address.
+    """
+    import ipaddress
+
+    if not addr.address or not addr.netmask:
+        return None
+    if addr.family == socket.AF_INET:
+        net = ipaddress.IPv4Network(
+            f"{addr.address}/{addr.netmask}", strict=False
+        )
+    elif addr.family == socket.AF_INET6:
+        net = ipaddress.IPv6Network(
+            f"{addr.address}/{addr.netmask}", strict=False
+        )
+    else:
+        return None
+    if net.prefixlen == net.max_prefixlen:
+        return None
+    return str(net.broadcast_address)
 
 
 def deprecated_method(replacement):
     """A decorator which can be used to mark a method as deprecated
-    'replcement' is the method name which will be called instead.
+    'replacement' is the method name which will be called instead.
     """
+
     def outer(fun):
-        msg = "%s() is deprecated; use %s() instead" % (
-            fun.__name__, replacement)
+        msg = (
+            f"{fun.__name__}() is deprecated and will be removed; use"
+            f" {replacement}() instead"
+        )
         if fun.__doc__ is None:
             fun.__doc__ = msg
 
@@ -372,5 +447,296 @@ def outer(fun):
         def inner(self, *args, **kwargs):
             warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
             return getattr(self, replacement)(*args, **kwargs)
+
         return inner
+
     return outer
+
+
+class _WrapNumbers:
+    """Watches numbers so that they don't overflow and wrap
+    (reset to zero).
+    """
+
+    def __init__(self):
+        self.lock = threading.Lock()
+        self.cache = {}
+        self.reminders = {}
+        self.reminder_keys = {}
+
+    def _add_dict(self, input_dict, name):
+        assert name not in self.cache
+        assert name not in self.reminders
+        assert name not in self.reminder_keys
+        self.cache[name] = input_dict
+        self.reminders[name] = collections.defaultdict(int)
+        self.reminder_keys[name] = collections.defaultdict(set)
+
+    def _remove_dead_reminders(self, input_dict, name):
+        """In case the number of keys changed between calls (e.g. a
+        disk disappears) this removes the entry from self.reminders.
+        """
+        old_dict = self.cache[name]
+        gone_keys = set(old_dict) - set(input_dict)
+        for gone_key in gone_keys:
+            for remkey in self.reminder_keys[name][gone_key]:
+                del self.reminders[name][remkey]
+            del self.reminder_keys[name][gone_key]
+
+    def run(self, input_dict, name):
+        """Cache dict and sum numbers which overflow and wrap.
+        Return an updated copy of `input_dict`.
+        """
+        if name not in self.cache:
+            # This was the first call.
+            self._add_dict(input_dict, name)
+            return input_dict
+
+        self._remove_dead_reminders(input_dict, name)
+
+        old_dict = self.cache[name]
+        new_dict = {}
+        for key in input_dict:
+            input_tuple = input_dict[key]
+            try:
+                old_tuple = old_dict[key]
+            except KeyError:
+                # The input dict has a new key (e.g. a new disk or NIC)
+                # which didn't exist in the previous call.
+                new_dict[key] = input_tuple
+                continue
+
+            bits = []
+            for i in range(len(input_tuple)):
+                input_value = input_tuple[i]
+                old_value = old_tuple[i]
+                remkey = (key, i)
+                if input_value < old_value:
+                    # it wrapped!
+                    self.reminders[name][remkey] += old_value
+                    self.reminder_keys[name][key].add(remkey)
+                bits.append(input_value + self.reminders[name][remkey])
+
+            new_dict[key] = tuple(bits)
+
+        self.cache[name] = input_dict
+        return new_dict
+
+    def cache_clear(self, name=None):
+        """Clear the internal cache, optionally only for function 'name'."""
+        with self.lock:
+            if name is None:
+                self.cache.clear()
+                self.reminders.clear()
+                self.reminder_keys.clear()
+            else:
+                self.cache.pop(name, None)
+                self.reminders.pop(name, None)
+                self.reminder_keys.pop(name, None)
+
+    def cache_info(self):
+        """Return internal cache dicts as a tuple of 3 elements."""
+        with self.lock:
+            return (self.cache, self.reminders, self.reminder_keys)
+
+
+def wrap_numbers(input_dict, name):
+    """Given an `input_dict` and a function `name`, adjust the numbers
+    which "wrap" (restart from zero) across different calls by adding
+    "old value" to "new value" and return an updated dict.
+    """
+    with _wn.lock:
+        return _wn.run(input_dict, name)
+
+
+_wn = _WrapNumbers()
+wrap_numbers.cache_clear = _wn.cache_clear
+wrap_numbers.cache_info = _wn.cache_info
+
+
+# The read buffer size for open() builtin. This (also) dictates how
+# much data we read(2) when iterating over file lines as in:
+#   >>> with open(file) as f:
+#   ...    for line in f:
+#   ...        ...
+# Default per-line buffer size for binary files is 1K. For text files
+# is 8K. We use a bigger buffer (32K) in order to have more consistent
+# results when reading /proc pseudo files on Linux, see:
+# https://github.com/giampaolo/psutil/issues/2050
+# https://github.com/giampaolo/psutil/issues/708
+FILE_READ_BUFFER_SIZE = 32 * 1024
+
+
+def open_binary(fname):
+    return open(fname, "rb", buffering=FILE_READ_BUFFER_SIZE)
+
+
+def open_text(fname):
+    """Open a file in text mode by using the proper FS encoding and
+    en/decoding error handlers.
+    """
+    # See:
+    # https://github.com/giampaolo/psutil/issues/675
+    # https://github.com/giampaolo/psutil/pull/733
+    fobj = open(  # noqa: SIM115
+        fname,
+        buffering=FILE_READ_BUFFER_SIZE,
+        encoding=ENCODING,
+        errors=ENCODING_ERRS,
+    )
+    try:
+        # Dictates per-line read(2) buffer size. Defaults is 8k. See:
+        # https://github.com/giampaolo/psutil/issues/2050#issuecomment-1013387546
+        fobj._CHUNK_SIZE = FILE_READ_BUFFER_SIZE
+    except AttributeError:
+        pass
+    except Exception:
+        fobj.close()
+        raise
+
+    return fobj
+
+
+def cat(fname, fallback=_DEFAULT, _open=open_text):
+    """Read entire file content and return it as a string. File is
+    opened in text mode. If specified, `fallback` is the value
+    returned in case of error, either if the file does not exist or
+    it can't be read().
+    """
+    if fallback is _DEFAULT:
+        with _open(fname) as f:
+            return f.read()
+    else:
+        try:
+            with _open(fname) as f:
+                return f.read()
+        except OSError:
+            return fallback
+
+
+def bcat(fname, fallback=_DEFAULT):
+    """Same as above but opens file in binary mode."""
+    return cat(fname, fallback=fallback, _open=open_binary)
+
+
+def bytes2human(n):
+    """Convert n bytes to a human-readable string.
+
+    >>> bytes2human(10000)
+    '9.8K'
+    >>> bytes2human(100001221)
+    '95.4M'
+    """
+    symbols = ('B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
+    prefix = {}
+    for i, s in enumerate(symbols[1:]):
+        prefix[s] = 1 << (i + 1) * 10
+    for symbol in reversed(symbols[1:]):
+        if abs(n) >= prefix[symbol]:
+            value = float(n) / prefix[symbol]
+            return f"{value:.1f}{symbol}"
+    return f"{float(n):.1f}{symbols[0]}"
+
+
+def get_procfs_path():
+    """Return updated psutil.PROCFS_PATH constant."""
+    return sys.modules['psutil'].PROCFS_PATH
+
+
+def decode(s):
+    return s.decode(encoding=ENCODING, errors=ENCODING_ERRS)
+
+
+# =====================================================================
+# --- shell utils
+# =====================================================================
+
+
+@functools.lru_cache
+def term_supports_colors(force_color=False):
+    if WINDOWS:
+        return False
+    if force_color:
+        return True
+    if not hasattr(sys.stdout, "isatty") or not sys.stdout.isatty():
+        return False
+    try:
+        sys.stdout.fileno()
+    except Exception:  # noqa: BLE001
+        return False
+    return True
+
+
+def hilite(s, color=None, bold=False, force_color=False):
+    """Return an highlighted version of 'string'."""
+    if not term_supports_colors(force_color=force_color):
+        return s
+    attr = []
+    colors = dict(
+        blue='34',
+        brown='33',
+        darkgrey='30',
+        green='32',
+        grey='37',
+        lightblue='36',
+        red='31',
+        violet='35',
+        yellow='93',
+    )
+    colors[None] = '29'
+    try:
+        color = colors[color]
+    except KeyError:
+        msg = f"invalid color {color!r}; choose amongst {list(colors)}"
+        raise ValueError(msg) from None
+    attr.append(color)
+    if bold:
+        attr.append('1')
+    return f"\x1b[{';'.join(attr)}m{s}\x1b[0m"
+
+
+def print_color(
+    s, color=None, bold=False, file=sys.stdout
+):  # pragma: no cover
+    """Print a colorized version of string."""
+    if term_supports_colors():
+        s = hilite(s, color=color, bold=bold)
+    print(s, file=file, flush=True)
+
+
+def debug(msg):
+    """If PSUTIL_DEBUG env var is set, print a debug message to stderr."""
+    if PSUTIL_DEBUG:
+        import inspect
+
+        fname, lineno, _, _lines, _index = inspect.getframeinfo(
+            inspect.currentframe().f_back
+        )
+        if isinstance(msg, Exception):
+            if isinstance(msg, OSError):
+                # ...because str(exc) may contain info about the file name
+                msg = f"ignoring {msg}"
+            else:
+                msg = f"ignoring {msg!r}"
+        print(  # noqa: T201
+            f"psutil-debug [{fname}:{lineno}]> {msg}", file=sys.stderr
+        )
+
+
+def warn(msg):
+    """Emit a RuntimeWarning. Use it for events which are never
+    supposed to happen, and imply a psutil bug.
+    """
+    import inspect
+
+    fname, lineno, _, _lines, _index = inspect.getframeinfo(
+        inspect.currentframe().f_back
+    )
+    msg = f"{msg} (originated from {fname}:{lineno})"
+    if PSUTIL_TESTING:
+        msg = f"CRITICAL: {msg}"
+        raise RuntimeError(msg)
+    try:
+        warnings.warn(msg, RuntimeWarning, stacklevel=2)
+    except RuntimeWarning:
+        pass  # -W error: we never want to fail because of a warning
diff --git a/psutil/_compat.py b/psutil/_compat.py
deleted file mode 100644
index de91638f6f..0000000000
--- a/psutil/_compat.py
+++ /dev/null
@@ -1,249 +0,0 @@
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Module which provides compatibility with older Python versions."""
-
-import collections
-import functools
-import os
-import sys
-
-__all__ = ["PY3", "long", "xrange", "unicode", "basestring", "u", "b",
-           "callable", "lru_cache", "which"]
-
-PY3 = sys.version_info[0] == 3
-
-if PY3:
-    long = int
-    xrange = range
-    unicode = str
-    basestring = str
-
-    def u(s):
-        return s
-
-    def b(s):
-        return s.encode("latin-1")
-else:
-    long = long
-    xrange = xrange
-    unicode = unicode
-    basestring = basestring
-
-    def u(s):
-        return unicode(s, "unicode_escape")
-
-    def b(s):
-        return s
-
-
-# removed in 3.0, reintroduced in 3.2
-try:
-    callable = callable
-except NameError:
-    def callable(obj):
-        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
-
-
-# --- stdlib additions
-
-
-# py 3.2 functools.lru_cache
-# Taken from: http://code.activestate.com/recipes/578078
-# Credit: Raymond Hettinger
-try:
-    from functools import lru_cache
-except ImportError:
-    try:
-        from threading import RLock
-    except ImportError:
-        from dummy_threading import RLock
-
-    _CacheInfo = collections.namedtuple(
-        "CacheInfo", ["hits", "misses", "maxsize", "currsize"])
-
-    class _HashedSeq(list):
-        __slots__ = 'hashvalue'
-
-        def __init__(self, tup, hash=hash):
-            self[:] = tup
-            self.hashvalue = hash(tup)
-
-        def __hash__(self):
-            return self.hashvalue
-
-    def _make_key(args, kwds, typed,
-                  kwd_mark=(object(), ),
-                  fasttypes=set((int, str, frozenset, type(None))),
-                  sorted=sorted, tuple=tuple, type=type, len=len):
-        key = args
-        if kwds:
-            sorted_items = sorted(kwds.items())
-            key += kwd_mark
-            for item in sorted_items:
-                key += item
-        if typed:
-            key += tuple(type(v) for v in args)
-            if kwds:
-                key += tuple(type(v) for k, v in sorted_items)
-        elif len(key) == 1 and type(key[0]) in fasttypes:
-            return key[0]
-        return _HashedSeq(key)
-
-    def lru_cache(maxsize=100, typed=False):
-        """Least-recently-used cache decorator, see:
-        http://docs.python.org/3/library/functools.html#functools.lru_cache
-        """
-        def decorating_function(user_function):
-            cache = dict()
-            stats = [0, 0]
-            HITS, MISSES = 0, 1
-            make_key = _make_key
-            cache_get = cache.get
-            _len = len
-            lock = RLock()
-            root = []
-            root[:] = [root, root, None, None]
-            nonlocal_root = [root]
-            PREV, NEXT, KEY, RESULT = 0, 1, 2, 3
-            if maxsize == 0:
-                def wrapper(*args, **kwds):
-                    result = user_function(*args, **kwds)
-                    stats[MISSES] += 1
-                    return result
-            elif maxsize is None:
-                def wrapper(*args, **kwds):
-                    key = make_key(args, kwds, typed)
-                    result = cache_get(key, root)
-                    if result is not root:
-                        stats[HITS] += 1
-                        return result
-                    result = user_function(*args, **kwds)
-                    cache[key] = result
-                    stats[MISSES] += 1
-                    return result
-            else:
-                def wrapper(*args, **kwds):
-                    if kwds or typed:
-                        key = make_key(args, kwds, typed)
-                    else:
-                        key = args
-                    lock.acquire()
-                    try:
-                        link = cache_get(key)
-                        if link is not None:
-                            root, = nonlocal_root
-                            link_prev, link_next, key, result = link
-                            link_prev[NEXT] = link_next
-                            link_next[PREV] = link_prev
-                            last = root[PREV]
-                            last[NEXT] = root[PREV] = link
-                            link[PREV] = last
-                            link[NEXT] = root
-                            stats[HITS] += 1
-                            return result
-                    finally:
-                        lock.release()
-                    result = user_function(*args, **kwds)
-                    lock.acquire()
-                    try:
-                        root, = nonlocal_root
-                        if key in cache:
-                            pass
-                        elif _len(cache) >= maxsize:
-                            oldroot = root
-                            oldroot[KEY] = key
-                            oldroot[RESULT] = result
-                            root = nonlocal_root[0] = oldroot[NEXT]
-                            oldkey = root[KEY]
-                            root[KEY] = root[RESULT] = None
-                            del cache[oldkey]
-                            cache[key] = oldroot
-                        else:
-                            last = root[PREV]
-                            link = [last, root, key, result]
-                            last[NEXT] = root[PREV] = cache[key] = link
-                        stats[MISSES] += 1
-                    finally:
-                        lock.release()
-                    return result
-
-            def cache_info():
-                """Report cache statistics"""
-                lock.acquire()
-                try:
-                    return _CacheInfo(stats[HITS], stats[MISSES], maxsize,
-                                      len(cache))
-                finally:
-                    lock.release()
-
-            def cache_clear():
-                """Clear the cache and cache statistics"""
-                lock.acquire()
-                try:
-                    cache.clear()
-                    root = nonlocal_root[0]
-                    root[:] = [root, root, None, None]
-                    stats[:] = [0, 0]
-                finally:
-                    lock.release()
-
-            wrapper.__wrapped__ = user_function
-            wrapper.cache_info = cache_info
-            wrapper.cache_clear = cache_clear
-            return functools.update_wrapper(wrapper, user_function)
-
-        return decorating_function
-
-
-# python 3.3
-try:
-    from shutil import which
-except ImportError:
-    def which(cmd, mode=os.F_OK | os.X_OK, path=None):
-        """Given a command, mode, and a PATH string, return the path which
-        conforms to the given mode on the PATH, or None if there is no such
-        file.
-
-        `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result
-        of os.environ.get("PATH"), or can be overridden with a custom search
-        path.
-        """
-        def _access_check(fn, mode):
-            return (os.path.exists(fn) and os.access(fn, mode) and
-                    not os.path.isdir(fn))
-
-        if os.path.dirname(cmd):
-            if _access_check(cmd, mode):
-                return cmd
-            return None
-
-        if path is None:
-            path = os.environ.get("PATH", os.defpath)
-        if not path:
-            return None
-        path = path.split(os.pathsep)
-
-        if sys.platform == "win32":
-            if os.curdir not in path:
-                path.insert(0, os.curdir)
-
-            pathext = os.environ.get("PATHEXT", "").split(os.pathsep)
-            if any(cmd.lower().endswith(ext.lower()) for ext in pathext):
-                files = [cmd]
-            else:
-                files = [cmd + ext for ext in pathext]
-        else:
-            files = [cmd]
-
-        seen = set()
-        for dir in path:
-            normdir = os.path.normcase(dir)
-            if normdir not in seen:
-                seen.add(normdir)
-                for thefile in files:
-                    name = os.path.join(dir, thefile)
-                    if _access_check(name, mode):
-                        return name
-        return None
diff --git a/psutil/_enums.py b/psutil/_enums.py
new file mode 100644
index 0000000000..a20deba84a
--- /dev/null
+++ b/psutil/_enums.py
@@ -0,0 +1,145 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Enum containers backing psutil constants.
+
+This module groups constants used by psutil APIs into Enum classes.
+These enums mainly act as containers for related values and are useful
+for type annotations and introspection.
+
+In normal usage constants should be accessed directly from the psutil
+namespace instead of importing these enums, e.g.:
+
+    import psutil
+    if proc.status() == psutil.STATUS_RUNNING:
+        ...
+
+The top-level constants (e.g. ``psutil.STATUS_RUNNING``) are aliases of
+the enum members defined here and represent the primary public API.
+"""
+
+import enum
+
+from ._common import FREEBSD
+from ._common import LINUX
+from ._common import SUNOS
+from ._common import WINDOWS
+
+if WINDOWS or LINUX or FREEBSD:
+    from . import _psutil
+else:
+    _psutil = None
+
+if hasattr(enum, "StrEnum"):  # Python >= 3.11
+    StrEnum = enum.StrEnum
+else:
+
+    # A backport of Python 3.11 StrEnum class for >= Python 3.8
+    class StrEnum(str, enum.Enum):
+        def __new__(cls, *values):
+            value = str(*values)
+            member = str.__new__(cls, value)
+            member._value_ = value
+            return member
+
+        __str__ = str.__str__
+
+        @staticmethod
+        def _generate_next_value_(name, _start, _count, _last_values):
+            return name.lower()
+
+
+# psutil.Process.status()
+class ProcessStatus(StrEnum):
+    STATUS_DEAD = "dead"
+    STATUS_DISK_SLEEP = "disk-sleep"
+    STATUS_IDLE = "idle"  # Linux, macOS, FreeBSD
+    STATUS_LOCKED = "locked"  # FreeBSD
+    STATUS_PARKED = "parked"  # Linux
+    STATUS_RUNNING = "running"
+    STATUS_SLEEPING = "sleeping"
+    STATUS_STOPPED = "stopped"
+    STATUS_SUSPENDED = "suspended"  # NetBSD
+    STATUS_TRACING_STOP = "tracing-stop"
+    STATUS_WAITING = "waiting"  # FreeBSD
+    STATUS_WAKE_KILL = "wake-kill"
+    STATUS_WAKING = "waking"
+    STATUS_ZOMBIE = "zombie"
+
+
+# psutil.Process.net_connections() and psutil.net_connections()
+class ConnectionStatus(StrEnum):
+    CONN_CLOSE = "CLOSE"
+    CONN_CLOSE_WAIT = "CLOSE_WAIT"
+    CONN_CLOSING = "CLOSING"
+    CONN_ESTABLISHED = "ESTABLISHED"
+    CONN_FIN_WAIT1 = "FIN_WAIT1"
+    CONN_FIN_WAIT2 = "FIN_WAIT2"
+    CONN_LAST_ACK = "LAST_ACK"
+    CONN_LISTEN = "LISTEN"
+    CONN_NONE = "NONE"
+    CONN_SYN_RECV = "SYN_RECV"
+    CONN_SYN_SENT = "SYN_SENT"
+    CONN_TIME_WAIT = "TIME_WAIT"
+    if WINDOWS:
+        CONN_DELETE_TCB = "DELETE_TCB"
+    if SUNOS:
+        CONN_BOUND = "CONN_BOUND"
+        CONN_IDLE = "CONN_IDLE"
+
+
+# psutil.net_if_stats()
+class NicDuplex(enum.IntEnum):
+    NIC_DUPLEX_FULL = 2
+    NIC_DUPLEX_HALF = 1
+    NIC_DUPLEX_UNKNOWN = 0
+
+
+# psutil.sensors_battery()
+class BatteryTime(enum.IntEnum):
+    POWER_TIME_UNKNOWN = -1
+    POWER_TIME_UNLIMITED = -2
+
+
+if LINUX:
+
+    # psutil.Process.ionice(ioclass=…)
+    class ProcessIOPriority(enum.IntEnum):
+        # ioprio_* constants http://linux.die.net/man/2/ioprio_get
+        IOPRIO_CLASS_NONE = 0
+        IOPRIO_CLASS_RT = 1
+        IOPRIO_CLASS_BE = 2
+        IOPRIO_CLASS_IDLE = 3
+
+
+if WINDOWS:
+
+    # psutil.Process.ionice(ioclass=…)
+    class ProcessIOPriority(enum.IntEnum):
+        IOPRIO_VERYLOW = 0
+        IOPRIO_LOW = 1
+        IOPRIO_NORMAL = 2
+        IOPRIO_HIGH = 3
+
+    # psutil.Process.nice()
+    class ProcessPriority(enum.IntEnum):
+        ABOVE_NORMAL_PRIORITY_CLASS = _psutil.ABOVE_NORMAL_PRIORITY_CLASS
+        BELOW_NORMAL_PRIORITY_CLASS = _psutil.BELOW_NORMAL_PRIORITY_CLASS
+        HIGH_PRIORITY_CLASS = _psutil.HIGH_PRIORITY_CLASS
+        IDLE_PRIORITY_CLASS = _psutil.IDLE_PRIORITY_CLASS
+        NORMAL_PRIORITY_CLASS = _psutil.NORMAL_PRIORITY_CLASS
+        REALTIME_PRIORITY_CLASS = _psutil.REALTIME_PRIORITY_CLASS
+
+
+if LINUX or FREEBSD:
+
+    # psutil.Process.rlimit()
+    ProcessRlimit = enum.IntEnum(
+        "ProcessRlimit",
+        (
+            (name, getattr(_psutil, name))
+            for name in dir(_psutil)
+            if name.startswith("RLIM") and name.isupper()
+        ),
+    )
diff --git a/psutil/_ntuples.py b/psutil/_ntuples.py
new file mode 100644
index 0000000000..6b12257e82
--- /dev/null
+++ b/psutil/_ntuples.py
@@ -0,0 +1,505 @@
+# Copyright (c) 2009, Giampaolo Rodola". All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+from __future__ import annotations
+
+import warnings
+from collections import namedtuple
+from typing import TYPE_CHECKING
+from typing import NamedTuple
+
+if TYPE_CHECKING:
+    import socket
+
+    from ._enums import BatteryTime
+    from ._enums import ConnectionStatus
+    from ._enums import NicDuplex
+    from ._enums import ProcessIOPriority
+
+from ._common import AIX
+from ._common import BSD
+from ._common import FREEBSD
+from ._common import LINUX
+from ._common import MACOS
+from ._common import NETBSD
+from ._common import OPENBSD
+from ._common import SUNOS
+from ._common import WINDOWS
+
+# ===================================================================
+# --- system functions
+# ===================================================================
+
+
+# psutil.swap_memory()
+class sswap(NamedTuple):
+    total: int
+    used: int
+    free: int
+    percent: float
+    sin: int
+    sout: int
+
+
+# psutil.disk_usage()
+class sdiskusage(NamedTuple):
+    total: int
+    used: int
+    free: int
+    percent: float
+
+
+# psutil.disk_io_counters()
+class sdiskio(NamedTuple):
+    read_count: int
+    write_count: int
+    read_bytes: int
+    write_bytes: int
+    if not (NETBSD or OPENBSD):
+        read_time: int
+        write_time: int
+    if LINUX:
+        read_merged_count: int
+        write_merged_count: int
+        busy_time: int
+    if FREEBSD:
+        busy_time: int
+
+
+# psutil.disk_partitions()
+class sdiskpart(NamedTuple):
+    device: str
+    mountpoint: str
+    fstype: str
+    opts: str
+
+
+# psutil.net_io_counters()
+class snetio(NamedTuple):
+    bytes_sent: int
+    bytes_recv: int
+    packets_sent: int
+    packets_recv: int
+    errin: int
+    errout: int
+    dropin: int
+    dropout: int
+
+
+# psutil.users()
+class suser(NamedTuple):
+    name: str
+    terminal: str | None
+    host: str | None
+    started: float
+    pid: int | None
+
+
+# psutil.net_connections() and psutil.Process.net_connections()
+class addr(NamedTuple):
+    ip: str
+    port: int
+
+
+# psutil.net_connections()
+class sconn(NamedTuple):
+    fd: int
+    family: socket.AddressFamily
+    type: socket.SocketKind
+    laddr: addr | tuple | str
+    raddr: addr | tuple | str
+    status: ConnectionStatus
+    pid: int | None
+
+
+# psutil.net_if_addrs()
+class snicaddr(NamedTuple):
+    family: socket.AddressFamily
+    address: str | None
+    netmask: str | None
+    broadcast: str | None
+    ptp: str | None
+
+
+# psutil.net_if_stats()
+class snicstats(NamedTuple):
+    isup: bool
+    duplex: NicDuplex
+    speed: int
+    mtu: int
+    flags: str
+
+
+# psutil.cpu_times()
+class scputimes(NamedTuple):
+    user: float
+    system: float
+    idle: float
+    if LINUX or MACOS or BSD:
+        nice: float
+    if LINUX:
+        iowait: float
+        irq: float
+        softirq: float
+        steal: float
+        guest: float
+        guest_nice: float
+    if BSD:
+        irq: float
+    if SUNOS or AIX:
+        iowait: float
+    if WINDOWS:
+        irq: float
+        dpc: float
+
+        @property
+        def interrupt(self):
+            msg = "'interrupt' field is deprecated, use 'irq' instead"
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            return self.irq
+
+
+# psutil.cpu_stats()
+class scpustats(NamedTuple):
+    ctx_switches: int
+    interrupts: int
+    soft_interrupts: int
+    syscalls: int
+
+
+# psutil.cpu_freq()
+class scpufreq(NamedTuple):
+    current: float
+    min: float | None
+    max: float | None
+
+
+# psutil.sensors_temperatures()
+class shwtemp(NamedTuple):
+    label: str
+    current: float | None
+    high: float | None
+    critical: float | None
+
+
+# psutil.sensors_battery()
+class sbattery(NamedTuple):
+    percent: float
+    secsleft: int | BatteryTime
+    power_plugged: bool | None
+
+
+# psutil.sensors_fans()
+class sfan(NamedTuple):
+    label: str
+    current: int
+
+
+if LINUX or WINDOWS or MACOS or BSD:
+
+    # psutil.heap_info()
+    class pheap(NamedTuple):
+        heap_used: int
+        mmap_used: int
+        if WINDOWS:
+            heap_count: int
+
+
+# psutil.virtual_memory()
+class svmem(NamedTuple):
+    total: int
+    available: int
+    percent: float
+    used: int
+    free: int
+    if LINUX:
+        active: int
+        inactive: int
+        buffers: int
+        cached: int
+        shared: int
+        slab: int
+    elif BSD:
+        active: int
+        inactive: int
+        buffers: int
+        cached: int
+        shared: int
+        wired: int
+    elif WINDOWS:
+        cached: int
+        wired: int
+    elif MACOS:
+        active: int
+        inactive: int
+        wired: int
+
+
+# ===================================================================
+# --- Process class
+# ===================================================================
+
+
+# psutil.Process.cpu_times()
+class pcputimes(NamedTuple):
+    user: float
+    system: float
+    children_user: float
+    children_system: float
+    if LINUX:
+        iowait: float
+
+
+# psutil.Process.open_files()
+class popenfile(NamedTuple):
+    path: str
+    fd: int
+    if LINUX:
+        position: int
+        mode: str
+        flags: int
+
+
+# psutil.Process.threads()
+class pthread(NamedTuple):
+    id: int
+    user_time: float
+    system_time: float
+
+
+# psutil.Process.uids()
+class puids(NamedTuple):
+    real: int
+    effective: int
+    saved: int
+
+
+# psutil.Process.gids()
+class pgids(NamedTuple):
+    real: int
+    effective: int
+    saved: int
+
+
+# psutil.Process.io_counters()
+class pio(NamedTuple):
+    read_count: int
+    write_count: int
+    read_bytes: int
+    write_bytes: int
+    if LINUX:
+        read_chars: int
+        write_chars: int
+    elif WINDOWS:
+        other_count: int
+        other_bytes: int
+
+
+# psutil.Process.ionice()
+class pionice(NamedTuple):
+    ioclass: ProcessIOPriority
+    value: int
+
+
+# psutil.Process.ctx_switches()
+class pctxsw(NamedTuple):
+    voluntary: int
+    involuntary: int
+
+
+# psutil.Process.page_faults()
+class ppagefaults(NamedTuple):
+    minor: int
+    major: int
+
+
+# psutil.Process().memory_footprint()
+if LINUX or MACOS or WINDOWS:
+
+    class pfootprint(NamedTuple):
+        uss: int
+        if LINUX:
+            pss: int
+            swap: int
+
+
+# psutil.Process.net_connections()
+class pconn(NamedTuple):
+    fd: int
+    family: socket.AddressFamily
+    type: socket.SocketKind
+    laddr: addr | tuple | str
+    raddr: addr | tuple | str
+    status: ConnectionStatus
+
+
+# psutil.Process.memory_maps(grouped=True)
+class pmmap_grouped(NamedTuple):
+    path: str
+    rss: int
+    if LINUX:
+        size: int
+        pss: int
+        shared_clean: int
+        shared_dirty: int
+        private_clean: int
+        private_dirty: int
+        referenced: int
+        anonymous: int
+        swap: int
+    elif BSD:
+        private: int
+        ref_count: int
+        shadow_count: int
+    elif SUNOS:
+        anonymous: int
+        locked: int
+
+
+# psutil.Process.memory_maps(grouped=False)
+class pmmap_ext(NamedTuple):
+    addr: str
+    perms: str
+    path: str
+    rss: int
+    if LINUX:
+        size: int
+        pss: int
+        shared_clean: int
+        shared_dirty: int
+        private_clean: int
+        private_dirty: int
+        referenced: int
+        anonymous: int
+        swap: int
+    elif BSD:
+        private: int
+        ref_count: int
+        shadow_count: int
+    elif SUNOS:
+        anonymous: int
+        locked: int
+
+
+# ===================================================================
+# --- Process memory_info() / memory_extras() / memory_full_info()
+# ===================================================================
+
+if LINUX:
+
+    # psutil.Process().memory_info()
+    class pmem(NamedTuple):
+        rss: int
+        vms: int
+        shared: int
+        text: int
+        data: int
+
+        @property
+        def lib(self):
+            # It has always been 0 since Linux 2.6.
+            msg = "'lib' field is deprecated and will be removed"
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            return 0
+
+        @property
+        def dirty(self):
+            # It has always been 0 since Linux 2.6.
+            msg = "'dirty' field is deprecated and will be removed"
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            return 0
+
+    # psutil.Process().memory_extras()
+    class pmem_extras(NamedTuple):
+        peak_rss: int
+        peak_vms: int
+        rss_anon: int
+        rss_file: int
+        rss_shmem: int
+        swap_anon: int
+        hugetlb: int
+
+    # psutil.Process().memory_full_info()
+    pfullmem = namedtuple("pfullmem", pmem._fields + ("uss", "pss", "swap"))
+
+elif WINDOWS:
+
+    # psutil.Process.memory_info()
+    class pmem(  # noqa: SLOT002
+        namedtuple("pmem", ("rss", "vms", "peak_rss", "peak_vms"))
+    ):
+        def __new__(cls, rss, vms, peak_rss, peak_vms, _deprecated=None):
+            inst = super().__new__(cls, rss, vms, peak_rss, peak_vms)
+            inst.__dict__["_deprecated"] = _deprecated or {}
+            return inst
+
+        def __getattr__(self, name):
+            depr = self.__dict__["_deprecated"]
+            if name in depr:
+                msg = f"pmem.{name} is deprecated"
+                if name in {
+                    "paged_pool",
+                    "nonpaged_pool",
+                    "peak_paged_pool",
+                    "peak_nonpaged_pool",
+                }:
+                    msg += "; use memory_extras() instead"
+                elif name == "num_page_faults":
+                    msg += "; use page_faults() instead"
+                warnings.warn(msg, DeprecationWarning, stacklevel=2)
+                return depr[name]
+
+            msg = f"{self.__class__.__name__} object has no attribute {name!r}"
+            raise AttributeError(msg)
+
+    # psutil.Process.memory_extras()
+    class pmem_extras(NamedTuple):
+        virtual: int
+        peak_virtual: int
+        paged_pool: int
+        nonpaged_pool: int
+        peak_paged_pool: int
+        peak_nonpaged_pool: int
+
+    # psutil.Process.memory_full_info()
+    pfullmem = namedtuple("pfullmem", pmem._fields + ("uss",))
+
+elif MACOS:
+
+    # psutil.Process.memory_info()
+    class pmem(NamedTuple):
+        rss: int
+        vms: int
+
+    # psutil.Process.memory_extras()
+    class pmem_extras(NamedTuple):
+        phys_footprint: int
+        peak_footprint: int
+
+    # psutil.Process.memory_full_info()
+    pfullmem = namedtuple("pfullmem", pmem._fields + ("uss",))
+
+elif BSD:
+
+    # psutil.Process.memory_info()
+    class pmem(NamedTuple):
+        rss: int
+        vms: int
+        text: int
+        data: int
+        stack: int
+        peak_rss: int
+
+    # psutil.Process.memory_full_info()
+    pfullmem = pmem
+
+elif SUNOS or AIX:
+
+    # psutil.Process.memory_info()
+    class pmem(NamedTuple):
+        rss: int
+        vms: int
+
+    # psutil.Process.memory_full_info()
+    pfullmem = pmem
diff --git a/psutil/_psaix.py b/psutil/_psaix.py
new file mode 100644
index 0000000000..5d4ced1058
--- /dev/null
+++ b/psutil/_psaix.py
@@ -0,0 +1,547 @@
+# Copyright (c) 2009, Giampaolo Rodola'
+# Copyright (c) 2017, Arnon Yaari
+# All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""AIX platform implementation."""
+
+import functools
+import glob
+import os
+import re
+import subprocess
+import sys
+
+from . import _ntuples as ntp
+from . import _psposix
+from . import _psutil
+from ._common import AccessDenied
+from ._common import NoSuchProcess
+from ._common import ZombieProcess
+from ._common import conn_tmap
+from ._common import conn_to_ntuple
+from ._common import get_procfs_path
+from ._common import memoize_when_activated
+from ._common import usage_percent
+from ._enums import ConnectionStatus
+from ._enums import NicDuplex
+from ._enums import ProcessStatus
+
+__extra__all__ = ["PROCFS_PATH"]
+
+
+# =====================================================================
+# --- globals
+# =====================================================================
+
+
+HAS_THREADS = hasattr(_psutil, "proc_threads")
+HAS_NET_IO_COUNTERS = hasattr(_psutil, "net_io_counters")
+HAS_PROC_IO_COUNTERS = hasattr(_psutil, "proc_io_counters")
+
+PAGE_SIZE = _psutil.getpagesize()
+AF_LINK = _psutil.AF_LINK
+
+PROC_STATUSES = {
+    _psutil.SIDL: ProcessStatus.STATUS_IDLE,
+    _psutil.SZOMB: ProcessStatus.STATUS_ZOMBIE,
+    _psutil.SACTIVE: ProcessStatus.STATUS_RUNNING,
+    _psutil.SSWAP: ProcessStatus.STATUS_RUNNING,  # TODO what status is this?
+    _psutil.SSTOP: ProcessStatus.STATUS_STOPPED,
+}
+
+TCP_STATUSES = {
+    _psutil.TCPS_ESTABLISHED: ConnectionStatus.CONN_ESTABLISHED,
+    _psutil.TCPS_SYN_SENT: ConnectionStatus.CONN_SYN_SENT,
+    _psutil.TCPS_SYN_RCVD: ConnectionStatus.CONN_SYN_RECV,
+    _psutil.TCPS_FIN_WAIT_1: ConnectionStatus.CONN_FIN_WAIT1,
+    _psutil.TCPS_FIN_WAIT_2: ConnectionStatus.CONN_FIN_WAIT2,
+    _psutil.TCPS_TIME_WAIT: ConnectionStatus.CONN_TIME_WAIT,
+    _psutil.TCPS_CLOSED: ConnectionStatus.CONN_CLOSE,
+    _psutil.TCPS_CLOSE_WAIT: ConnectionStatus.CONN_CLOSE_WAIT,
+    _psutil.TCPS_LAST_ACK: ConnectionStatus.CONN_LAST_ACK,
+    _psutil.TCPS_LISTEN: ConnectionStatus.CONN_LISTEN,
+    _psutil.TCPS_CLOSING: ConnectionStatus.CONN_CLOSING,
+    _psutil.PSUTIL_CONN_NONE: ConnectionStatus.CONN_NONE,
+}
+
+proc_info_map = dict(
+    ppid=0,
+    rss=1,
+    vms=2,
+    create_time=3,
+    nice=4,
+    num_threads=5,
+    status=6,
+    ttynr=7,
+)
+
+
+# =====================================================================
+# --- memory
+# =====================================================================
+
+
+def virtual_memory():
+    total, avail, free, _pinned, inuse = _psutil.virtual_mem()
+    percent = usage_percent((total - avail), total, round_=1)
+    return ntp.svmem(total, avail, percent, inuse, free)
+
+
+def swap_memory():
+    """Swap system memory as a (total, used, free, sin, sout) tuple."""
+    total, free, sin, sout = _psutil.swap_mem()
+    used = total - free
+    percent = usage_percent(used, total, round_=1)
+    return ntp.sswap(total, used, free, percent, sin, sout)
+
+
+# =====================================================================
+# --- CPU
+# =====================================================================
+
+
+def cpu_times():
+    """Return system-wide CPU times as a named tuple."""
+    ret = _psutil.per_cpu_times()
+    return ntp.scputimes(*[sum(x) for x in zip(*ret)])
+
+
+def per_cpu_times():
+    """Return system per-CPU times as a list of named tuples."""
+    ret = _psutil.per_cpu_times()
+    return [ntp.scputimes(*x) for x in ret]
+
+
+def cpu_count_logical():
+    """Return the number of logical CPUs in the system."""
+    try:
+        return os.sysconf("SC_NPROCESSORS_ONLN")
+    except ValueError:
+        # mimic os.cpu_count() behavior
+        return None
+
+
+def cpu_count_cores():
+    cmd = ["lsdev", "-Cc", "processor"]
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    stdout, stderr = p.communicate()
+    stdout, stderr = (x.decode(sys.stdout.encoding) for x in (stdout, stderr))
+    if p.returncode != 0:
+        msg = f"{cmd!r} command error\n{stderr}"
+        raise RuntimeError(msg)
+    processors = stdout.strip().splitlines()
+    return len(processors) or None
+
+
+def cpu_stats():
+    """Return various CPU stats as a named tuple."""
+    ctx_switches, interrupts, soft_interrupts, syscalls = _psutil.cpu_stats()
+    return ntp.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls)
+
+
+# =====================================================================
+# --- disks
+# =====================================================================
+
+
+disk_io_counters = _psutil.disk_io_counters
+disk_usage = _psposix.disk_usage
+
+
+def disk_partitions(all=False):
+    """Return system disk partitions."""
+    # TODO - the filtering logic should be better checked so that
+    # it tries to reflect 'df' as much as possible
+    retlist = []
+    partitions = _psutil.disk_partitions()
+    for partition in partitions:
+        device, mountpoint, fstype, opts = partition
+        if device == 'none':
+            device = ''
+        if not all:
+            # Differently from, say, Linux, we don't have a list of
+            # common fs types so the best we can do, AFAIK, is to
+            # filter by filesystem having a total size > 0.
+            if not disk_usage(mountpoint).total:
+                continue
+        ntuple = ntp.sdiskpart(device, mountpoint, fstype, opts)
+        retlist.append(ntuple)
+    return retlist
+
+
+# =====================================================================
+# --- network
+# =====================================================================
+
+
+net_if_addrs = _psutil.net_if_addrs
+
+if HAS_NET_IO_COUNTERS:
+    net_io_counters = _psutil.net_io_counters
+
+
+def net_connections(kind, _pid=-1):
+    """Return socket connections.  If pid == -1 return system-wide
+    connections (as opposed to connections opened by one process only).
+    """
+    families, types = conn_tmap[kind]
+    rawlist = _psutil.net_connections(_pid)
+    ret = []
+    for item in rawlist:
+        fd, fam, type_, laddr, raddr, status, pid = item
+        if fam not in families:
+            continue
+        if type_ not in types:
+            continue
+        nt = conn_to_ntuple(
+            fd,
+            fam,
+            type_,
+            laddr,
+            raddr,
+            status,
+            TCP_STATUSES,
+            pid=pid if _pid == -1 else None,
+        )
+        ret.append(nt)
+    return ret
+
+
+def net_if_stats():
+    """Get NIC stats (isup, duplex, speed, mtu)."""
+    duplex_map = {
+        "Full": NicDuplex.NIC_DUPLEX_FULL,
+        "Half": NicDuplex.NIC_DUPLEX_HALF,
+    }
+    names = {x[0] for x in net_if_addrs()}
+    ret = {}
+    for name in names:
+        mtu = _psutil.net_if_mtu(name)
+        flags = _psutil.net_if_flags(name)
+
+        # try to get speed and duplex
+        # TODO: rewrite this in C (entstat forks, so use truss -f to follow.
+        # looks like it is using an undocumented ioctl?)
+        duplex = ""
+        speed = 0
+        p = subprocess.Popen(
+            ["/usr/bin/entstat", "-d", name],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        stdout, stderr = p.communicate()
+        stdout, stderr = (
+            x.decode(sys.stdout.encoding) for x in (stdout, stderr)
+        )
+        if p.returncode == 0:
+            re_result = re.search(
+                r"Running: (\d+) Mbps.*?(\w+) Duplex", stdout
+            )
+            if re_result is not None:
+                speed = int(re_result.group(1))
+                duplex = re_result.group(2)
+
+        output_flags = ','.join(flags)
+        isup = 'running' in flags
+        duplex = duplex_map.get(duplex, NicDuplex.NIC_DUPLEX_UNKNOWN)
+        ret[name] = ntp.snicstats(isup, duplex, speed, mtu, output_flags)
+    return ret
+
+
+# =====================================================================
+# --- other system functions
+# =====================================================================
+
+
+def boot_time():
+    """The system boot time expressed in seconds since the epoch."""
+    return _psutil.boot_time()
+
+
+def users():
+    """Return currently connected users as a list of named tuples."""
+    retlist = []
+    rawlist = _psutil.users()
+    localhost = (':0.0', ':0')
+    for item in rawlist:
+        user, tty, hostname, tstamp, user_process, pid = item
+        # note: the underlying C function includes entries about
+        # system boot, run level and others.  We might want
+        # to use them in the future.
+        if not user_process:
+            continue
+        if hostname in localhost:
+            hostname = 'localhost'
+        nt = ntp.suser(user, tty, hostname, tstamp, pid)
+        retlist.append(nt)
+    return retlist
+
+
+# =====================================================================
+# --- processes
+# =====================================================================
+
+
+def pids():
+    """Returns a list of PIDs currently running on the system."""
+    return [int(x) for x in os.listdir(get_procfs_path()) if x.isdigit()]
+
+
+def pid_exists(pid):
+    """Check for the existence of a unix pid."""
+    return os.path.exists(os.path.join(get_procfs_path(), str(pid), "psinfo"))
+
+
+def wrap_exceptions(fun):
+    """Call callable into a try/except clause and translate ENOENT,
+    EACCES and EPERM in NoSuchProcess or AccessDenied exceptions.
+    """
+
+    @functools.wraps(fun)
+    def wrapper(self, *args, **kwargs):
+        pid, ppid, name = self.pid, self._ppid, self._name
+        try:
+            return fun(self, *args, **kwargs)
+        except (FileNotFoundError, ProcessLookupError) as err:
+            # ENOENT (no such file or directory) gets raised on open().
+            # ESRCH (no such process) can get raised on read() if
+            # process is gone in meantime.
+            if not pid_exists(pid):
+                raise NoSuchProcess(pid, name) from err
+            raise ZombieProcess(pid, name, ppid) from err
+        except PermissionError as err:
+            raise AccessDenied(pid, name) from err
+
+    return wrapper
+
+
+class Process:
+    """Wrapper class around underlying C implementation."""
+
+    __slots__ = ["_cache", "_name", "_ppid", "_procfs_path", "pid"]
+
+    def __init__(self, pid):
+        self.pid = pid
+        self._name = None
+        self._ppid = None
+        self._procfs_path = get_procfs_path()
+
+    def oneshot_enter(self):
+        self._proc_oneshot.cache_activate(self)
+        self._proc_cred.cache_activate(self)
+
+    def oneshot_exit(self):
+        self._proc_oneshot.cache_deactivate(self)
+        self._proc_cred.cache_deactivate(self)
+
+    @wrap_exceptions
+    @memoize_when_activated
+    def _proc_oneshot(self):
+        return _psutil.proc_oneshot(self.pid, self._procfs_path)
+
+    @wrap_exceptions
+    @memoize_when_activated
+    def _proc_cred(self):
+        return _psutil.proc_cred(self.pid, self._procfs_path)
+
+    @wrap_exceptions
+    def name(self):
+        if self.pid == 0:
+            return "swapper"
+        # note: max 16 characters
+        return _psutil.proc_name(self.pid, self._procfs_path).rstrip("\x00")
+
+    @wrap_exceptions
+    def exe(self):
+        # there is no way to get executable path in AIX other than to guess,
+        # and guessing is more complex than what's in the wrapping class
+        cmdline = self.cmdline()
+        if not cmdline:
+            return ''
+        exe = cmdline[0]
+        if os.path.sep in exe:
+            # relative or absolute path
+            if not os.path.isabs(exe):
+                # if cwd has changed, we're out of luck - this may be wrong!
+                exe = os.path.abspath(os.path.join(self.cwd(), exe))
+            if (
+                os.path.isabs(exe)
+                and os.path.isfile(exe)
+                and os.access(exe, os.X_OK)
+            ):
+                return exe
+            # not found, move to search in PATH using basename only
+            exe = os.path.basename(exe)
+        # search for exe name PATH
+        for path in os.environ["PATH"].split(":"):
+            possible_exe = os.path.abspath(os.path.join(path, exe))
+            if os.path.isfile(possible_exe) and os.access(
+                possible_exe, os.X_OK
+            ):
+                return possible_exe
+        return ''
+
+    @wrap_exceptions
+    def cmdline(self):
+        return _psutil.proc_args(self.pid)
+
+    @wrap_exceptions
+    def environ(self):
+        return _psutil.proc_environ(self.pid)
+
+    @wrap_exceptions
+    def create_time(self):
+        return self._proc_oneshot()[proc_info_map['create_time']]
+
+    @wrap_exceptions
+    def num_threads(self):
+        return self._proc_oneshot()[proc_info_map['num_threads']]
+
+    if HAS_THREADS:
+
+        @wrap_exceptions
+        def threads(self):
+            rawlist = _psutil.proc_threads(self.pid)
+            retlist = []
+            for thread_id, utime, stime in rawlist:
+                ntuple = ntp.pthread(thread_id, utime, stime)
+                retlist.append(ntuple)
+            # The underlying C implementation retrieves all OS threads
+            # and filters them by PID.  At this point we can't tell whether
+            # an empty list means there were no connections for process or
+            # process is no longer active so we force NSP in case the PID
+            # is no longer there.
+            if not retlist:
+                # will raise NSP if process is gone
+                os.stat(f"{self._procfs_path}/{self.pid}")
+            return retlist
+
+    @wrap_exceptions
+    def net_connections(self, kind='inet'):
+        ret = net_connections(kind, _pid=self.pid)
+        # The underlying C implementation retrieves all OS connections
+        # and filters them by PID.  At this point we can't tell whether
+        # an empty list means there were no connections for process or
+        # process is no longer active so we force NSP in case the PID
+        # is no longer there.
+        if not ret:
+            # will raise NSP if process is gone
+            os.stat(f"{self._procfs_path}/{self.pid}")
+        return ret
+
+    @wrap_exceptions
+    def nice_get(self):
+        return _psutil.proc_priority_get(self.pid)
+
+    @wrap_exceptions
+    def nice_set(self, value):
+        return _psutil.proc_priority_set(self.pid, value)
+
+    @wrap_exceptions
+    def ppid(self):
+        self._ppid = self._proc_oneshot()[proc_info_map['ppid']]
+        return self._ppid
+
+    @wrap_exceptions
+    def uids(self):
+        real, effective, saved, _, _, _ = self._proc_cred()
+        return ntp.puids(real, effective, saved)
+
+    @wrap_exceptions
+    def gids(self):
+        _, _, _, real, effective, saved = self._proc_cred()
+        return ntp.puids(real, effective, saved)
+
+    @wrap_exceptions
+    def cpu_times(self):
+        t = _psutil.proc_cpu_times(self.pid, self._procfs_path)
+        return ntp.pcputimes(*t)
+
+    @wrap_exceptions
+    def terminal(self):
+        ttydev = self._proc_oneshot()[proc_info_map['ttynr']]
+        # convert from 64-bit dev_t to 32-bit dev_t and then map the device
+        ttydev = ((ttydev & 0x0000FFFF00000000) >> 16) | (ttydev & 0xFFFF)
+        # try to match rdev of /dev/pts/* files ttydev
+        for dev in glob.glob("/dev/**/*"):
+            if os.stat(dev).st_rdev == ttydev:
+                return dev
+        return None
+
+    @wrap_exceptions
+    def cwd(self):
+        procfs_path = self._procfs_path
+        try:
+            result = os.readlink(f"{procfs_path}/{self.pid}/cwd")
+            return result.rstrip('/')
+        except FileNotFoundError:
+            os.stat(f"{procfs_path}/{self.pid}")  # raise NSP or AD
+            return ""
+
+    @wrap_exceptions
+    def memory_info(self):
+        ret = self._proc_oneshot()
+        rss = ret[proc_info_map['rss']] * 1024
+        vms = ret[proc_info_map['vms']] * 1024
+        return ntp.pmem(rss, vms)
+
+    @wrap_exceptions
+    def status(self):
+        code = self._proc_oneshot()[proc_info_map['status']]
+        # XXX is '?' legit? (we're not supposed to return it anyway)
+        return PROC_STATUSES.get(code, '?')
+
+    def open_files(self):
+        # TODO rewrite without using procfiles (stat /proc/pid/fd/* and then
+        # find matching name of the inode)
+        p = subprocess.Popen(
+            ["/usr/bin/procfiles", "-n", str(self.pid)],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        stdout, stderr = p.communicate()
+        stdout, stderr = (
+            x.decode(sys.stdout.encoding) for x in (stdout, stderr)
+        )
+        if "no such process" in stderr.lower():
+            raise NoSuchProcess(self.pid, self._name)
+        procfiles = re.findall(r"(\d+): S_IFREG.*name:(.*)\n", stdout)
+        retlist = []
+        for fd, path in procfiles:
+            path = path.strip()
+            if path.startswith("//"):
+                path = path[1:]
+            if path.lower() == "cannot be retrieved":
+                continue
+            retlist.append(ntp.popenfile(path, int(fd)))
+        return retlist
+
+    @wrap_exceptions
+    def num_fds(self):
+        if self.pid == 0:  # no /proc/0/fd
+            return 0
+        return len(os.listdir(f"{self._procfs_path}/{self.pid}/fd"))
+
+    @wrap_exceptions
+    def num_ctx_switches(self):
+        return ntp.pctxsw(*_psutil.proc_num_ctx_switches(self.pid))
+
+    @wrap_exceptions
+    def wait(self, timeout=None):
+        return _psposix.wait_pid(self.pid, timeout)
+
+    if HAS_PROC_IO_COUNTERS:
+
+        @wrap_exceptions
+        def io_counters(self):
+            try:
+                rc, wc, rb, wb = _psutil.proc_io_counters(self.pid)
+            except OSError as err:
+                # if process is terminated, proc_io_counters returns OSError
+                # instead of NSP
+                if not pid_exists(self.pid):
+                    raise NoSuchProcess(self.pid, self._name) from err
+                raise
+            return ntp.pio(rc, wc, rb, wb)
diff --git a/psutil/_psbsd.py b/psutil/_psbsd.py
index f868a212c4..bb4def5291 100644
--- a/psutil/_psbsd.py
+++ b/psutil/_psbsd.py
@@ -4,56 +4,60 @@
 
 """FreeBSD, OpenBSD and NetBSD platforms implementation."""
 
-import contextlib
 import errno
 import functools
-import os
-import xml.etree.ElementTree as ET
+from collections import defaultdict
 from collections import namedtuple
 
-from . import _common
+from . import _ntuples as ntp
 from . import _psposix
-from . import _psutil_bsd as cext
-from . import _psutil_posix as cext_posix
-from ._common import conn_tmap
+from . import _psutil
 from ._common import FREEBSD
 from ._common import NETBSD
 from ._common import OPENBSD
-from ._common import sockfam_to_enum
-from ._common import socktype_to_enum
-from ._common import usage_percent
-from ._compat import which
+from ._common import AccessDenied
+from ._common import NoSuchProcess
+from ._common import ZombieProcess
+from ._common import conn_tmap
+from ._common import conn_to_ntuple
+from ._common import debug
+from ._common import memoize_when_activated
+from ._common import warn
+from ._enums import BatteryTime
+from ._enums import ConnectionStatus
+from ._enums import NicDuplex
+from ._enums import ProcessStatus
 
 __extra__all__ = []
 
 
 # =====================================================================
-# --- constants
+# --- globals
 # =====================================================================
 
 
 if FREEBSD:
     PROC_STATUSES = {
-        cext.SIDL: _common.STATUS_IDLE,
-        cext.SRUN: _common.STATUS_RUNNING,
-        cext.SSLEEP: _common.STATUS_SLEEPING,
-        cext.SSTOP: _common.STATUS_STOPPED,
-        cext.SZOMB: _common.STATUS_ZOMBIE,
-        cext.SWAIT: _common.STATUS_WAITING,
-        cext.SLOCK: _common.STATUS_LOCKED,
+        _psutil.SIDL: ProcessStatus.STATUS_IDLE,
+        _psutil.SRUN: ProcessStatus.STATUS_RUNNING,
+        _psutil.SSLEEP: ProcessStatus.STATUS_SLEEPING,
+        _psutil.SSTOP: ProcessStatus.STATUS_STOPPED,
+        _psutil.SZOMB: ProcessStatus.STATUS_ZOMBIE,
+        _psutil.SWAIT: ProcessStatus.STATUS_WAITING,
+        _psutil.SLOCK: ProcessStatus.STATUS_LOCKED,
     }
-elif OPENBSD or NETBSD:
+elif OPENBSD:
     PROC_STATUSES = {
-        cext.SIDL: _common.STATUS_IDLE,
-        cext.SSLEEP: _common.STATUS_SLEEPING,
-        cext.SSTOP: _common.STATUS_STOPPED,
+        _psutil.SIDL: ProcessStatus.STATUS_IDLE,
+        _psutil.SSLEEP: ProcessStatus.STATUS_SLEEPING,
+        _psutil.SSTOP: ProcessStatus.STATUS_STOPPED,
         # According to /usr/include/sys/proc.h SZOMB is unused.
         # test_zombie_process() shows that SDEAD is the right
         # equivalent. Also it appears there's no equivalent of
         # psutil.STATUS_DEAD. SDEAD really means STATUS_ZOMBIE.
-        # cext.SZOMB: _common.STATUS_ZOMBIE,
-        cext.SDEAD: _common.STATUS_ZOMBIE,
-        cext.SZOMB: _common.STATUS_ZOMBIE,
+        # _psutil.SZOMB: ProcStatus.STATUS_ZOMBIE,
+        _psutil.SDEAD: ProcessStatus.STATUS_ZOMBIE,
+        _psutil.SZOMB: ProcessStatus.STATUS_ZOMBIE,
         # From http://www.eecs.harvard.edu/~margo/cs161/videos/proc.h.txt
         # OpenBSD has SRUN and SONPROC: SRUN indicates that a process
         # is runnable but *not* yet running, i.e. is on a run queue.
@@ -61,81 +65,39 @@
         # a CPU, i.e. it is no longer on a run queue.
         # As such we'll map SRUN to STATUS_WAKING and SONPROC to
         # STATUS_RUNNING
-        cext.SRUN: _common.STATUS_WAKING,
-        cext.SONPROC: _common.STATUS_RUNNING,
+        _psutil.SRUN: ProcessStatus.STATUS_WAKING,
+        _psutil.SONPROC: ProcessStatus.STATUS_RUNNING,
     }
 elif NETBSD:
     PROC_STATUSES = {
-        cext.SIDL: _common.STATUS_IDLE,
-        cext.SACTIVE: _common.STATUS_RUNNING,
-        cext.SDYING: _common.STATUS_ZOMBIE,
-        cext.SSTOP: _common.STATUS_STOPPED,
-        cext.SZOMB: _common.STATUS_ZOMBIE,
-        cext.SDEAD: _common.STATUS_DEAD,
-        cext.SSUSPENDED: _common.STATUS_SUSPENDED,  # unique to NetBSD
+        _psutil.SIDL: ProcessStatus.STATUS_IDLE,
+        _psutil.SSLEEP: ProcessStatus.STATUS_SLEEPING,
+        _psutil.SSTOP: ProcessStatus.STATUS_STOPPED,
+        _psutil.SZOMB: ProcessStatus.STATUS_ZOMBIE,
+        _psutil.SRUN: ProcessStatus.STATUS_WAKING,
+        _psutil.SONPROC: ProcessStatus.STATUS_RUNNING,
+        _psutil.SSUSPENDED: ProcessStatus.STATUS_SUSPENDED,
     }
 
 TCP_STATUSES = {
-    cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
-    cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
-    cext.TCPS_SYN_RECEIVED: _common.CONN_SYN_RECV,
-    cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
-    cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
-    cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
-    cext.TCPS_CLOSED: _common.CONN_CLOSE,
-    cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
-    cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
-    cext.TCPS_LISTEN: _common.CONN_LISTEN,
-    cext.TCPS_CLOSING: _common.CONN_CLOSING,
-    cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
+    _psutil.TCPS_ESTABLISHED: ConnectionStatus.CONN_ESTABLISHED,
+    _psutil.TCPS_SYN_SENT: ConnectionStatus.CONN_SYN_SENT,
+    _psutil.TCPS_SYN_RECEIVED: ConnectionStatus.CONN_SYN_RECV,
+    _psutil.TCPS_FIN_WAIT_1: ConnectionStatus.CONN_FIN_WAIT1,
+    _psutil.TCPS_FIN_WAIT_2: ConnectionStatus.CONN_FIN_WAIT2,
+    _psutil.TCPS_TIME_WAIT: ConnectionStatus.CONN_TIME_WAIT,
+    _psutil.TCPS_CLOSED: ConnectionStatus.CONN_CLOSE,
+    _psutil.TCPS_CLOSE_WAIT: ConnectionStatus.CONN_CLOSE_WAIT,
+    _psutil.TCPS_LAST_ACK: ConnectionStatus.CONN_LAST_ACK,
+    _psutil.TCPS_LISTEN: ConnectionStatus.CONN_LISTEN,
+    _psutil.TCPS_CLOSING: ConnectionStatus.CONN_CLOSING,
+    _psutil.PSUTIL_CONN_NONE: ConnectionStatus.CONN_NONE,
 }
 
-if NETBSD:
-    PAGESIZE = os.sysconf("SC_PAGESIZE")
-else:
-    PAGESIZE = os.sysconf("SC_PAGE_SIZE")
-AF_LINK = cext_posix.AF_LINK
-
-
-# =====================================================================
-# --- named tuples
-# =====================================================================
+PAGESIZE = _psutil.getpagesize()
+AF_LINK = _psutil.AF_LINK
 
-
-# extend base mem ntuple with BSD-specific memory metrics
-svmem = namedtuple(
-    'svmem', ['total', 'available', 'percent', 'used', 'free',
-              'active', 'inactive', 'buffers', 'cached', 'shared', 'wired'])
-scputimes = namedtuple(
-    'scputimes', ['user', 'nice', 'system', 'idle', 'irq'])
-pmem = namedtuple('pmem', ['rss', 'vms', 'text', 'data', 'stack'])
-pfullmem = pmem
-pcputimes = namedtuple('pcputimes',
-                       ['user', 'system', 'children_user', 'children_system'])
-pmmap_grouped = namedtuple(
-    'pmmap_grouped', 'path rss, private, ref_count, shadow_count')
-pmmap_ext = namedtuple(
-    'pmmap_ext', 'addr, perms path rss, private, ref_count, shadow_count')
-if FREEBSD:
-    sdiskio = namedtuple('sdiskio', ['read_count', 'write_count',
-                                     'read_bytes', 'write_bytes',
-                                     'read_time', 'write_time',
-                                     'busy_time'])
-else:
-    sdiskio = namedtuple('sdiskio', ['read_count', 'write_count',
-                                     'read_bytes', 'write_bytes'])
-
-
-# =====================================================================
-# --- exceptions
-# =====================================================================
-
-
-# these get overwritten on "import psutil" from the __init__.py file
-NoSuchProcess = None
-ZombieProcess = None
-AccessDenied = None
-TimeoutExpired = None
+HAS_PROC_NUM_THREADS = hasattr(_psutil, "proc_num_threads")
 
 
 # =====================================================================
@@ -144,31 +106,22 @@
 
 
 def virtual_memory():
-    """System virtual memory as a namedtuple."""
-    mem = cext.virtual_mem()
-    total, free, active, inactive, wired, cached, buffers, shared = mem
-    if NETBSD:
-        # On NetBSD buffers and shared mem is determined via /proc.
-        # The C ext set them to 0.
-        with open('/proc/meminfo', 'rb') as f:
-            for line in f:
-                if line.startswith(b'Buffers:'):
-                    buffers = int(line.split()[1]) * 1024
-                elif line.startswith(b'MemShared:'):
-                    shared = int(line.split()[1]) * 1024
-    avail = inactive + cached + free
-    used = active + wired + cached
-    percent = usage_percent((total - avail), total, _round=1)
-    return svmem(total, avail, percent, used, free,
-                 active, inactive, buffers, cached, shared, wired)
+    d = _psutil.virtual_mem()
+    return ntp.svmem(**d)
 
 
 def swap_memory():
-    """System swap memory as (total, used, free, sin, sout) namedtuple."""
-    pagesize = 1 if OPENBSD else PAGESIZE
-    total, used, free, sin, sout = [x * pagesize for x in cext.swap_mem()]
-    percent = usage_percent(used, total, _round=1)
-    return _common.sswap(total, used, free, percent, sin, sout)
+    """System swap memory as a (total, used, free, percent, sin, sout)
+    named tuple. sin and sout are always 0 on OpenBSD
+    """
+    d = _psutil.swap_mem()
+    return ntp.sswap(**d)
+
+
+# malloc / heap functions (FreeBSD / NetBSD)
+if hasattr(_psutil, "heap_info"):
+    heap_info = _psutil.heap_info
+    heap_trim = _psutil.heap_trim
 
 
 # =====================================================================
@@ -177,104 +130,86 @@ def swap_memory():
 
 
 def cpu_times():
-    """Return system per-CPU times as a namedtuple"""
-    user, nice, system, idle, irq = cext.cpu_times()
-    return scputimes(user, nice, system, idle, irq)
-
-
-if hasattr(cext, "per_cpu_times"):
-    def per_cpu_times():
-        """Return system CPU times as a namedtuple"""
-        ret = []
-        for cpu_t in cext.per_cpu_times():
-            user, nice, system, idle, irq = cpu_t
-            item = scputimes(user, nice, system, idle, irq)
-            ret.append(item)
-        return ret
-else:
-    # XXX
-    # Ok, this is very dirty.
-    # On FreeBSD < 8 we cannot gather per-cpu information, see:
-    # https://github.com/giampaolo/psutil/issues/226
-    # If num cpus > 1, on first call we return single cpu times to avoid a
-    # crash at psutil import time.
-    # Next calls will fail with NotImplementedError
-    def per_cpu_times():
-        if cpu_count_logical() == 1:
-            return [cpu_times()]
-        if per_cpu_times.__called__:
-            raise NotImplementedError("supported only starting from FreeBSD 8")
-        per_cpu_times.__called__ = True
-        return [cpu_times()]
-
-    per_cpu_times.__called__ = False
+    """Return system per-CPU times as a named tuple."""
+    user, nice, system, idle, irq = _psutil.cpu_times()
+    return ntp.scputimes(user, system, idle, nice, irq)
+
+
+def per_cpu_times():
+    """Return system CPU times as a named tuple."""
+    ret = []
+    for cpu_t in _psutil.per_cpu_times():
+        user, nice, system, idle, irq = cpu_t
+        item = ntp.scputimes(user, system, idle, nice, irq)
+        ret.append(item)
+    return ret
 
 
 def cpu_count_logical():
     """Return the number of logical CPUs in the system."""
-    return cext.cpu_count_logical()
+    return _psutil.cpu_count_logical()
 
 
 if OPENBSD or NETBSD:
-    def cpu_count_physical():
+
+    def cpu_count_cores():
         # OpenBSD and NetBSD do not implement this.
         return 1 if cpu_count_logical() == 1 else None
+
 else:
-    def cpu_count_physical():
-        """Return the number of physical CPUs in the system."""
-        # From the C module we'll get an XML string similar to this:
-        # http://manpages.ubuntu.com/manpages/precise/man4/smp.4freebsd.html
-        # We may get None in case "sysctl kern.sched.topology_spec"
-        # is not supported on this BSD version, in which case we'll mimic
-        # os.cpu_count() and return None.
-        ret = None
-        s = cext.cpu_count_phys()
-        if s is not None:
-            # get rid of padding chars appended at the end of the string
-            index = s.rfind("</groups>")
-            if index != -1:
-                s = s[:index + 9]
-                root = ET.fromstring(s)
-                try:
-                    ret = len(root.findall('group/children/group/cpu')) or None
-                finally:
-                    # needed otherwise it will memleak
-                    root.clear()
-        if not ret:
-            # If logical CPUs are 1 it's obvious we'll have only 1
-            # physical CPU.
-            if cpu_count_logical() == 1:
-                return 1
-        return ret
+
+    def cpu_count_cores():
+        """Return the number of CPU cores in the system."""
+        return _psutil.cpu_count_cores()
 
 
 def cpu_stats():
+    """Return various CPU stats as a named tuple."""
     if FREEBSD:
         # Note: the C ext is returning some metrics we are not exposing:
         # traps.
-        ctxsw, intrs, soft_intrs, syscalls, traps = cext.cpu_stats()
-    elif NETBSD:
-        # XXX
-        # Note about intrs: the C extension returns 0. intrs
-        # can be determined via /proc/stat; it has the same value as
-        # soft_intrs thought so the kernel is faking it (?).
-        #
-        # Note about syscalls: the C extension always sets it to 0 (?).
-        #
+        ctxsw, intrs, soft_intrs, syscalls, _traps = _psutil.cpu_stats()
+    elif NETBSD or OPENBSD:
         # Note: the C ext is returning some metrics we are not exposing:
         # traps, faults and forks.
-        ctxsw, intrs, soft_intrs, syscalls, traps, faults, forks = \
-            cext.cpu_stats()
-        with open('/proc/stat', 'rb') as f:
-            for line in f:
-                if line.startswith(b'intr'):
-                    intrs = int(line.split()[1])
-    elif OPENBSD:
-        # Note: the C ext is returning some metrics we are not exposing:
-        # traps, faults and forks.
-        ctxsw, intrs, soft_intrs, syscalls, traps, faults, forks = \
-            cext.cpu_stats()
-    return _common.scpustats(ctxsw, intrs, soft_intrs, syscalls)
+        ctxsw, intrs, soft_intrs, syscalls, _traps, _faults, _forks = (
+            _psutil.cpu_stats()
+        )
+    return ntp.scpustats(ctxsw, intrs, soft_intrs, syscalls)
+
+
+if FREEBSD:
+
+    def cpu_freq():
+        """Return frequency metrics for CPUs. As of Dec 2018 only
+        CPU 0 appears to be supported by FreeBSD and all other cores
+        match the frequency of CPU 0.
+        """
+        ret = []
+        num_cpus = cpu_count_logical()
+        for cpu in range(num_cpus):
+            try:
+                current, available_freq = _psutil.cpu_freq(cpu)
+            except NotImplementedError:
+                continue
+            min_freq = max_freq = None
+            if available_freq:
+                try:
+                    min_freq = int(available_freq.split(" ")[-1].split("/")[0])
+                except (IndexError, ValueError):
+                    min_freq = None
+                try:
+                    max_freq = int(available_freq.split(" ")[0].split("/")[0])
+                except (IndexError, ValueError):
+                    max_freq = None
+            ret.append(ntp.scpufreq(current, min_freq, max_freq))
+        return ret
+
+elif OPENBSD:
+
+    def cpu_freq():
+        curr = float(_psutil.cpu_freq())
+        return [ntp.scpufreq(curr, 0.0, 0.0)]
 
 
 # =====================================================================
@@ -283,22 +218,21 @@ def cpu_stats():
 
 
 def disk_partitions(all=False):
+    """Return mounted disk partitions as a list of named tuples.
+    'all' argument is ignored, see:
+    https://github.com/giampaolo/psutil/issues/906.
+    """
     retlist = []
-    partitions = cext.disk_partitions()
+    partitions = _psutil.disk_partitions()
     for partition in partitions:
         device, mountpoint, fstype, opts = partition
-        if device == 'none':
-            device = ''
-        if not all:
-            if not os.path.isabs(device) or not os.path.exists(device):
-                continue
-        ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
+        ntuple = ntp.sdiskpart(device, mountpoint, fstype, opts)
         retlist.append(ntuple)
     return retlist
 
 
 disk_usage = _psposix.disk_usage
-disk_io_counters = cext.disk_io_counters
+disk_io_counters = _psutil.disk_io_counters
 
 
 # =====================================================================
@@ -306,8 +240,8 @@ def disk_partitions(all=False):
 # =====================================================================
 
 
-net_io_counters = cext.net_io_counters
-net_if_addrs = cext_posix.net_if_addrs
+net_io_counters = _psutil.net_io_counters
+net_if_addrs = _psutil.net_if_addrs
 
 
 def net_if_stats():
@@ -315,53 +249,82 @@ def net_if_stats():
     names = net_io_counters().keys()
     ret = {}
     for name in names:
-        isup, duplex, speed, mtu = cext_posix.net_if_stats(name)
-        if hasattr(_common, 'NicDuplex'):
-            duplex = _common.NicDuplex(duplex)
-        ret[name] = _common.snicstats(isup, duplex, speed, mtu)
+        try:
+            mtu = _psutil.net_if_mtu(name)
+            flags = _psutil.net_if_flags(name)
+            duplex, speed = _psutil.net_if_duplex_speed(name)
+        except OSError as err:
+            # https://github.com/giampaolo/psutil/issues/1279
+            if err.errno != errno.ENODEV:
+                raise
+        else:
+            duplex = NicDuplex(duplex)
+            output_flags = ','.join(flags)
+            isup = 'running' in flags
+            ret[name] = ntp.snicstats(isup, duplex, speed, mtu, output_flags)
     return ret
 
 
 def net_connections(kind):
-    if OPENBSD:
-        ret = []
-        for pid in pids():
-            try:
-                cons = Process(pid).connections(kind)
-            except (NoSuchProcess, ZombieProcess):
-                continue
-            else:
-                for conn in cons:
-                    conn = list(conn)
-                    conn.append(pid)
-                    ret.append(_common.sconn(*conn))
-        return ret
-
-    if kind not in _common.conn_tmap:
-        raise ValueError("invalid %r kind argument; choose between %s"
-                         % (kind, ', '.join([repr(x) for x in conn_tmap])))
+    """System-wide network connections."""
     families, types = conn_tmap[kind]
     ret = set()
-    rawlist = cext.net_connections()
+    if OPENBSD:
+        rawlist = _psutil.net_connections(-1, families, types)
+    elif NETBSD:
+        rawlist = _psutil.net_connections(-1, kind)
+    else:  # FreeBSD
+        rawlist = _psutil.net_connections(families, types)
+
     for item in rawlist:
         fd, fam, type, laddr, raddr, status, pid = item
-        # TODO: apply filter at C level
-        if fam in families and type in types:
-            try:
-                status = TCP_STATUSES[status]
-            except KeyError:
-                # XXX: Not sure why this happens. I saw this occurring
-                # with IPv6 sockets opened by 'vim'. Those sockets
-                # have a very short lifetime so maybe the kernel
-                # can't initialize their status?
-                status = TCP_STATUSES[cext.PSUTIL_CONN_NONE]
-            fam = sockfam_to_enum(fam)
-            type = socktype_to_enum(type)
-            nt = _common.sconn(fd, fam, type, laddr, raddr, status, pid)
-            ret.add(nt)
+        nt = conn_to_ntuple(
+            fd, fam, type, laddr, raddr, status, TCP_STATUSES, pid
+        )
+        ret.add(nt)
     return list(ret)
 
 
+# =====================================================================
+#  --- sensors
+# =====================================================================
+
+
+if FREEBSD:
+
+    def sensors_battery():
+        """Return battery info."""
+        try:
+            percent, minsleft, power_plugged = _psutil.sensors_battery()
+        except NotImplementedError:
+            # See: https://github.com/giampaolo/psutil/issues/1074
+            return None
+        power_plugged = power_plugged == 1
+        if power_plugged:
+            secsleft = BatteryTime.POWER_TIME_UNLIMITED
+        elif minsleft == -1:
+            secsleft = BatteryTime.POWER_TIME_UNKNOWN
+        else:
+            secsleft = minsleft * 60
+        return ntp.sbattery(percent, secsleft, power_plugged)
+
+    def sensors_temperatures():
+        """Return CPU cores temperatures if available, else an empty dict."""
+        ret = defaultdict(list)
+        num_cpus = cpu_count_logical()
+        for cpu in range(num_cpus):
+            try:
+                current, high = _psutil.sensors_cpu_temperature(cpu)
+                if high <= 0:
+                    high = None
+                name = f"Core {cpu}"
+                ret["coretemp"].append(ntp.shwtemp(name, current, high, high))
+            except NotImplementedError:
+                pass
+
+        return ret
+
+
 # =====================================================================
 #  --- other system functions
 # =====================================================================
@@ -369,17 +332,42 @@ def net_connections(kind):
 
 def boot_time():
     """The system boot time expressed in seconds since the epoch."""
-    return cext.boot_time()
+    return _psutil.boot_time()
+
+
+if NETBSD:
+
+    try:
+        INIT_BOOT_TIME = boot_time()
+    except Exception as err:  # noqa: BLE001
+        # Don't want to crash at import time.
+        warn(f"boot_time() failed on import: {err!r}")
+        INIT_BOOT_TIME = 0
+
+    def adjust_proc_create_time(ctime):
+        """Account for system clock updates."""
+        if INIT_BOOT_TIME == 0:
+            return ctime
+
+        diff = INIT_BOOT_TIME - boot_time()
+        if diff == 0 or abs(diff) < 1:
+            return ctime
+
+        debug("system clock was updated; adjusting process create_time()")
+        if diff < 0:
+            return ctime - diff
+        return ctime + diff
 
 
 def users():
+    """Return currently connected users as a list of named tuples."""
     retlist = []
-    rawlist = cext.users()
+    rawlist = _psutil.users()
     for item in rawlist:
-        user, tty, hostname, tstamp = item
+        user, tty, hostname, tstamp, pid = item
         if tty == '~':
             continue  # reboot or shutdown
-        nt = _common.suser(user, tty or None, hostname, tstamp)
+        nt = ntp.suser(user, tty or None, hostname, tstamp, pid)
         retlist.append(nt)
     return retlist
 
@@ -389,9 +377,30 @@ def users():
 # =====================================================================
 
 
-pids = cext.pids
+@functools.lru_cache
+def _pid_0_exists():
+    try:
+        Process(0).name()
+    except NoSuchProcess:
+        return False
+    except AccessDenied:
+        return True
+    else:
+        return True
+
+
+def pids():
+    """Returns a list of PIDs currently running on the system."""
+    ret = _psutil.pids()
+    if OPENBSD and (0 not in ret) and _pid_0_exists():
+        # On OpenBSD the kernel does not return PID 0 (neither does
+        # ps) but it's actually querable (Process(0) will succeed).
+        ret.insert(0, 0)
+    return ret
+
+
+if NETBSD:
 
-if OPENBSD or NETBSD:
     def pid_exists(pid):
         exists = _psposix.pid_exists(pid)
         if not exists:
@@ -400,7 +409,20 @@ def pid_exists(pid):
             return pid in pids()
         else:
             return True
-else:
+
+elif OPENBSD:
+
+    def pid_exists(pid):
+        exists = _psposix.pid_exists(pid)
+        if not exists:
+            return False
+        else:
+            # OpenBSD seems to be the only BSD platform where
+            # _psposix.pid_exists() returns True for thread IDs (tids),
+            # so we can't use it.
+            return pid in pids()
+
+else:  # FreeBSD
     pid_exists = _psposix.pid_exists
 
 
@@ -408,232 +430,244 @@ def wrap_exceptions(fun):
     """Decorator which translates bare OSError exceptions into
     NoSuchProcess and AccessDenied.
     """
+
     @functools.wraps(fun)
     def wrapper(self, *args, **kwargs):
+        pid, ppid, name = self.pid, self._ppid, self._name
         try:
             return fun(self, *args, **kwargs)
+        except ProcessLookupError as err:
+            if _psutil.proc_is_zombie(pid):
+                raise ZombieProcess(pid, name, ppid) from err
+            raise NoSuchProcess(pid, name) from err
+        except PermissionError as err:
+            raise AccessDenied(pid, name) from err
+        except _psutil.ZombieProcessError as err:
+            raise ZombieProcess(pid, name, ppid) from err
         except OSError as err:
-            if err.errno == errno.ESRCH:
-                if not pid_exists(self.pid):
-                    raise NoSuchProcess(self.pid, self._name)
-                else:
-                    raise ZombieProcess(self.pid, self._name, self._ppid)
-            if err.errno in (errno.EPERM, errno.EACCES):
-                raise AccessDenied(self.pid, self._name)
-            raise
-    return wrapper
-
+            if pid == 0 and 0 in pids():
+                raise AccessDenied(pid, name) from err
+            raise err from None
 
-@contextlib.contextmanager
-def wrap_exceptions_procfs(inst):
-    try:
-        yield
-    except EnvironmentError as err:
-        # ENOENT (no such file or directory) gets raised on open().
-        # ESRCH (no such process) can get raised on read() if
-        # process is gone in meantime.
-        if err.errno in (errno.ENOENT, errno.ESRCH):
-            if not pid_exists(inst.pid):
-                raise NoSuchProcess(inst.pid, inst._name)
-            else:
-                raise ZombieProcess(inst.pid, inst._name, inst._ppid)
-        if err.errno in (errno.EPERM, errno.EACCES):
-            raise AccessDenied(inst.pid, inst._name)
-        raise
+    return wrapper
 
 
-class Process(object):
+class Process:
     """Wrapper class around underlying C implementation."""
 
-    __slots__ = ["pid", "_name", "_ppid"]
+    __slots__ = ["_cache", "_name", "_ppid", "pid"]
 
     def __init__(self, pid):
         self.pid = pid
         self._name = None
         self._ppid = None
 
+    def _assert_alive(self):
+        """Raise NSP if the process disappeared on us."""
+        # For those C function who do not raise NSP, possibly returning
+        # incorrect or incomplete result.
+        _psutil.proc_name(self.pid)
+
+    @wrap_exceptions
+    @memoize_when_activated
+    def oneshot(self):
+        """Retrieves multiple process info in one shot as a raw dict."""
+        return _psutil.proc_oneshot_kinfo(self.pid)
+
+    def oneshot_enter(self):
+        self.oneshot.cache_activate(self)
+
+    def oneshot_exit(self):
+        self.oneshot.cache_deactivate(self)
+
     @wrap_exceptions
     def name(self):
-        return cext.proc_name(self.pid)
+        name = self.oneshot()["name"]
+        return name if name is not None else _psutil.proc_name(self.pid)
 
     @wrap_exceptions
     def exe(self):
-        if FREEBSD:
-            return cext.proc_exe(self.pid)
-        elif NETBSD:
+        if FREEBSD or NETBSD:
             if self.pid == 0:
-                # /proc/0 dir exists but /proc/0/exe doesn't
-                return ""
-            with wrap_exceptions_procfs(self):
-                return os.readlink("/proc/%s/exe" % self.pid)
+                return ''  # else NSP
+            return _psutil.proc_exe(self.pid)
         else:
             # OpenBSD: exe cannot be determined; references:
-            # https://chromium.googlesource.com/chromium/src/base/+/
-            #     master/base_paths_posix.cc
+            # https://chromium.googlesource.com/chromium/src/base/+/master/base_paths_posix.cc
             # We try our best guess by using which against the first
             # cmdline arg (may return None).
+            import shutil
+
             cmdline = self.cmdline()
             if cmdline:
-                return which(cmdline[0])
+                return shutil.which(cmdline[0]) or ""
             else:
                 return ""
 
     @wrap_exceptions
     def cmdline(self):
         if OPENBSD and self.pid == 0:
-            return None  # ...else it crashes
-        elif NETBSD:
-            # XXX - most of the times the underlying sysctl() call on Net
-            # and Open BSD returns a truncated string.
-            # Also /proc/pid/cmdline behaves the same so it looks
-            # like this is a kernel bug.
+            return []  # ...else it crashes
+        elif NETBSD or OPENBSD:
+            # XXX - most of the times the underlying sysctl() call on
+            # NetBSD and OpenBSD returns a truncated string. Also
+            # /proc/pid/cmdline behaves the same so it looks like this
+            # is a kernel bug.
             try:
-                return cext.proc_cmdline(self.pid)
+                return _psutil.proc_cmdline(self.pid)
             except OSError as err:
-                if err.errno == errno.EINVAL:
+                if err.errno in {errno.EINVAL, errno.EFAULT}:
+                    debug(f"cmdline(): ignoring {err!r}")
+                    pid, name, ppid = self.pid, self._name, self._ppid
+                    if _psutil.proc_is_zombie(self.pid):
+                        raise ZombieProcess(pid, name, ppid) from err
                     if not pid_exists(self.pid):
-                        raise NoSuchProcess(self.pid, self._name)
-                    else:
-                        raise ZombieProcess(self.pid, self._name, self._ppid)
+                        raise NoSuchProcess(pid, name) from err
+                    return []
                 else:
                     raise
         else:
-            return cext.proc_cmdline(self.pid)
+            return _psutil.proc_cmdline(self.pid)
+
+    @wrap_exceptions
+    def environ(self):
+        return _psutil.proc_environ(self.pid)
 
     @wrap_exceptions
     def terminal(self):
-        tty_nr = cext.proc_tty_nr(self.pid)
-        tmap = _psposix.get_terminal_map()
-        try:
-            return tmap[tty_nr]
-        except KeyError:
+        tty_nr = self.oneshot()["ttynr"]
+        if tty_nr == _psutil.NODEV:
             return None
+        return _psposix.get_terminal(tty_nr)
 
     @wrap_exceptions
     def ppid(self):
-        self._ppid = cext.proc_ppid(self.pid)
+        self._ppid = self.oneshot()["ppid"]
         return self._ppid
 
     @wrap_exceptions
     def uids(self):
-        real, effective, saved = cext.proc_uids(self.pid)
-        return _common.puids(real, effective, saved)
+        d = self.oneshot()
+        return ntp.puids(d["real_uid"], d["effective_uid"], d["saved_uid"])
 
     @wrap_exceptions
     def gids(self):
-        real, effective, saved = cext.proc_gids(self.pid)
-        return _common.pgids(real, effective, saved)
+        d = self.oneshot()
+        return ntp.pgids(d["real_gid"], d["effective_gid"], d["saved_gid"])
 
     @wrap_exceptions
     def cpu_times(self):
-        return _common.pcputimes(*cext.proc_cpu_times(self.pid))
+        d = self.oneshot()
+        return ntp.pcputimes(
+            d["user_time"], d["sys_time"], d["ch_user_time"], d["ch_sys_time"]
+        )
+
+    if FREEBSD:
+
+        @wrap_exceptions
+        def cpu_num(self):
+            return self.oneshot()["cpunum"]
 
     @wrap_exceptions
     def memory_info(self):
-        return pmem(*cext.proc_memory_info(self.pid))
-
-    memory_full_info = memory_info
+        d = self.oneshot()
+        return ntp.pmem(
+            rss=d["rss"],
+            vms=d["vms"],
+            text=d["memtext"],
+            data=d["memdata"],
+            stack=d["memstack"],
+            peak_rss=d["peak_rss"],
+        )
 
     @wrap_exceptions
-    def create_time(self):
-        return cext.proc_create_time(self.pid)
+    def create_time(self, monotonic=False):
+        ctime = self.oneshot()["create_time"]
+        if NETBSD and not monotonic:
+            # NetBSD: ctime subject to system clock updates.
+            ctime = adjust_proc_create_time(ctime)
+        return ctime
 
     @wrap_exceptions
     def num_threads(self):
-        if hasattr(cext, "proc_num_threads"):
-            # FreeBSD
-            return cext.proc_num_threads(self.pid)
+        if HAS_PROC_NUM_THREADS:
+            # FreeBSD / NetBSD
+            return _psutil.proc_num_threads(self.pid)
         else:
             return len(self.threads())
 
     @wrap_exceptions
     def num_ctx_switches(self):
-        return _common.pctxsw(*cext.proc_num_ctx_switches(self.pid))
+        d = self.oneshot()
+        return ntp.pctxsw(d["ctx_switches_vol"], d["ctx_switches_unvol"])
+
+    @wrap_exceptions
+    def page_faults(self):
+        d = self.oneshot()
+        return ntp.ppagefaults(d["min_faults"], d["maj_faults"])
 
     @wrap_exceptions
     def threads(self):
         # Note: on OpenSBD this (/dev/mem) requires root access.
-        rawlist = cext.proc_threads(self.pid)
+        rawlist = _psutil.proc_threads(self.pid)
         retlist = []
         for thread_id, utime, stime in rawlist:
-            ntuple = _common.pthread(thread_id, utime, stime)
+            ntuple = ntp.pthread(thread_id, utime, stime)
             retlist.append(ntuple)
         if OPENBSD:
-            # On OpenBSD the underlying C function does not raise NSP
-            # in case the process is gone (and the returned list may
-            # incomplete).
-            self.name()  # raise NSP if the process disappeared on us
+            self._assert_alive()
         return retlist
 
     @wrap_exceptions
-    def connections(self, kind='inet'):
-        if kind not in conn_tmap:
-            raise ValueError("invalid %r kind argument; choose between %s"
-                             % (kind, ', '.join([repr(x) for x in conn_tmap])))
+    def net_connections(self, kind='inet'):
+        families, types = conn_tmap[kind]
+        ret = []
 
         if NETBSD:
-            families, types = conn_tmap[kind]
-            ret = set()
-            rawlist = cext.proc_connections(self.pid)
-            for item in rawlist:
-                fd, fam, type, laddr, raddr, status = item
-                if fam in families and type in types:
-                    try:
-                        status = TCP_STATUSES[status]
-                    except KeyError:
-                        status = TCP_STATUSES[cext.PSUTIL_CONN_NONE]
-                    fam = sockfam_to_enum(fam)
-                    type = socktype_to_enum(type)
-                    nt = _common.pconn(fd, fam, type, laddr, raddr, status)
-                    ret.add(nt)
-            # On NetBSD the underlying C function does not raise NSP
-            # in case the process is gone (and the returned list may
-            # incomplete).
-            self.name()  # raise NSP if the process disappeared on us
-            return list(ret)
+            rawlist = _psutil.net_connections(self.pid, kind)
+        elif OPENBSD:
+            rawlist = _psutil.net_connections(self.pid, families, types)
+        else:
+            rawlist = _psutil.proc_net_connections(self.pid, families, types)
 
-        families, types = conn_tmap[kind]
-        rawlist = cext.proc_connections(self.pid, families, types)
-        ret = []
         for item in rawlist:
-            fd, fam, type, laddr, raddr, status = item
-            fam = sockfam_to_enum(fam)
-            type = socktype_to_enum(type)
-            status = TCP_STATUSES[status]
-            nt = _common.pconn(fd, fam, type, laddr, raddr, status)
+            fd, fam, type, laddr, raddr, status = item[:6]
+            if FREEBSD:
+                if (fam not in families) or (type not in types):
+                    continue
+            nt = conn_to_ntuple(
+                fd, fam, type, laddr, raddr, status, TCP_STATUSES
+            )
             ret.append(nt)
-        if OPENBSD:
-            # On OpenBSD the underlying C function does not raise NSP
-            # in case the process is gone (and the returned list may
-            # incomplete).
-            self.name()  # raise NSP if the process disappeared on us
+
+        self._assert_alive()
         return ret
 
     @wrap_exceptions
     def wait(self, timeout=None):
-        try:
-            return _psposix.wait_pid(self.pid, timeout)
-        except _psposix.TimeoutExpired:
-            raise TimeoutExpired(timeout, self.pid, self._name)
+        return _psposix.wait_pid(self.pid, timeout)
 
     @wrap_exceptions
     def nice_get(self):
-        return cext_posix.getpriority(self.pid)
+        # Also available via POSIX getpriority(), but can raise NSP
+        # for not fully initialized processes in SIDL state, see:
+        # https://github.com/giampaolo/psutil/issues/2903
+        return self.oneshot()["nice"]
 
     @wrap_exceptions
     def nice_set(self, value):
-        return cext_posix.setpriority(self.pid, value)
+        return _psutil.proc_priority_set(self.pid, value)
 
     @wrap_exceptions
     def status(self):
-        code = cext.proc_status(self.pid)
+        code = self.oneshot()["status"]
         # XXX is '?' legit? (we're not supposed to return it anyway)
         return PROC_STATUSES.get(code, '?')
 
     @wrap_exceptions
     def io_counters(self):
-        rc, wc, rb, wb = cext.proc_io_counters(self.pid)
-        return _common.pio(rc, wc, rb, wb)
+        d = self.oneshot()
+        return ntp.pio(d["read_io_count"], d["write_io_count"], -1, -1)
 
     @wrap_exceptions
     def cwd(self):
@@ -641,52 +675,29 @@ def cwd(self):
         # sometimes we get an empty string, in which case we turn
         # it into None
         if OPENBSD and self.pid == 0:
-            return None  # ...else it would raise EINVAL
-        elif NETBSD:
-            with wrap_exceptions_procfs(self):
-                return os.readlink("/proc/%s/cwd" % self.pid)
-        elif hasattr(cext, 'proc_open_files'):
-            # FreeBSD < 8 does not support functions based on
-            # kinfo_getfile() and kinfo_getvmmap()
-            return cext.proc_cwd(self.pid) or None
-        else:
-            raise NotImplementedError(
-                "supported only starting from FreeBSD 8" if
-                FREEBSD else "")
+            return ""  # ...else it would raise EINVAL
+        return _psutil.proc_cwd(self.pid)
 
     nt_mmap_grouped = namedtuple(
-        'mmap', 'path rss, private, ref_count, shadow_count')
+        'mmap', 'path rss, private, ref_count, shadow_count'
+    )
     nt_mmap_ext = namedtuple(
-        'mmap', 'addr, perms path rss, private, ref_count, shadow_count')
-
-    def _not_implemented(self):
-        raise NotImplementedError
+        'mmap', 'addr, perms path rss, private, ref_count, shadow_count'
+    )
 
-    # FreeBSD < 8 does not support functions based on kinfo_getfile()
-    # and kinfo_getvmmap()
-    if hasattr(cext, 'proc_open_files'):
-        @wrap_exceptions
-        def open_files(self):
-            """Return files opened by process as a list of namedtuples."""
-            rawlist = cext.proc_open_files(self.pid)
-            return [_common.popenfile(path, fd) for path, fd in rawlist]
-    else:
-        open_files = _not_implemented
+    @wrap_exceptions
+    def open_files(self):
+        """Return files opened by process as a list of named tuples."""
+        rawlist = _psutil.proc_open_files(self.pid)
+        return [ntp.popenfile(path, fd) for path, fd in rawlist]
 
-    # FreeBSD < 8 does not support functions based on kinfo_getfile()
-    # and kinfo_getvmmap()
-    if hasattr(cext, 'proc_num_fds'):
-        @wrap_exceptions
-        def num_fds(self):
-            """Return the number of file descriptors opened by this process."""
-            ret = cext.proc_num_fds(self.pid)
-            if NETBSD:
-                # On NetBSD the underlying C function does not raise NSP
-                # in case the process is gone.
-                self.name()  # raise NSP if the process disappeared on us
-            return ret
-    else:
-        num_fds = _not_implemented
+    @wrap_exceptions
+    def num_fds(self):
+        """Return the number of file descriptors opened by this process."""
+        ret = _psutil.proc_num_fds(self.pid)
+        if NETBSD:
+            self._assert_alive()
+        return ret
 
     # --- FreeBSD only APIs
 
@@ -694,33 +705,49 @@ def num_fds(self):
 
         @wrap_exceptions
         def cpu_affinity_get(self):
-            return cext.proc_cpu_affinity_get(self.pid)
+            return _psutil.proc_cpu_affinity_get(self.pid)
 
         @wrap_exceptions
         def cpu_affinity_set(self, cpus):
-            # Pre-emptively check if CPUs are valid because the C
+            # preemptively check if CPUs are valid because the C
             # function has a weird behavior in case of invalid CPUs,
             # see: https://github.com/giampaolo/psutil/issues/586
-            allcpus = tuple(range(len(per_cpu_times())))
+            allcpus = set(range(len(per_cpu_times())))
             for cpu in cpus:
                 if cpu not in allcpus:
-                    raise ValueError("invalid CPU #%i (choose between %s)"
-                                     % (cpu, allcpus))
+                    msg = f"invalid CPU {cpu!r} (choose between {allcpus})"
+                    raise ValueError(msg)
             try:
-                cext.proc_cpu_affinity_set(self.pid, cpus)
+                _psutil.proc_cpu_affinity_set(self.pid, cpus)
             except OSError as err:
                 # 'man cpuset_setaffinity' about EDEADLK:
                 # <<the call would leave a thread without a valid CPU to run
                 # on because the set does not overlap with the thread's
                 # anonymous mask>>
-                if err.errno in (errno.EINVAL, errno.EDEADLK):
+                if err.errno in {errno.EINVAL, errno.EDEADLK}:
                     for cpu in cpus:
                         if cpu not in allcpus:
-                            raise ValueError(
-                                "invalid CPU #%i (choose between %s)" % (
-                                    cpu, allcpus))
+                            msg = (
+                                f"invalid CPU {cpu!r} (choose between"
+                                f" {allcpus})"
+                            )
+                            raise ValueError(msg) from err
                 raise
 
         @wrap_exceptions
         def memory_maps(self):
-            return cext.proc_memory_maps(self.pid)
+            return _psutil.proc_memory_maps(self.pid)
+
+        @wrap_exceptions
+        def rlimit(self, resource, limits=None):
+            if limits is None:
+                return _psutil.proc_getrlimit(self.pid, resource)
+            else:
+                if len(limits) != 2:
+                    msg = (
+                        "second argument must be a (soft, hard) tuple, got"
+                        f" {limits!r}"
+                    )
+                    raise ValueError(msg)
+                soft, hard = limits
+                return _psutil.proc_setrlimit(self.pid, resource, soft, hard)
diff --git a/psutil/_pslinux.py b/psutil/_pslinux.py
index 7f6e04057a..c3e7a3e636 100644
--- a/psutil/_pslinux.py
+++ b/psutil/_pslinux.py
@@ -4,211 +4,134 @@
 
 """Linux platform implementation."""
 
-from __future__ import division
-
 import base64
+import collections
+import enum
 import errno
 import functools
+import glob
 import os
 import re
+import resource
 import socket
 import struct
 import sys
-import traceback
 import warnings
 from collections import defaultdict
-from collections import namedtuple
 
-from . import _common
+from . import _ntuples as ntp
 from . import _psposix
-from . import _psutil_linux as cext
-from . import _psutil_posix as cext_posix
+from . import _psutil
+from ._common import ENCODING
+from ._common import AccessDenied
+from ._common import NoSuchProcess
+from ._common import ZombieProcess
+from ._common import bcat
+from ._common import cat
+from ._common import debug
+from ._common import decode
+from ._common import get_procfs_path
 from ._common import isfile_strict
-from ._common import memoize
+from ._common import memoize_when_activated
+from ._common import open_binary
+from ._common import open_text
 from ._common import parse_environ_block
-from ._common import NIC_DUPLEX_FULL
-from ._common import NIC_DUPLEX_HALF
-from ._common import NIC_DUPLEX_UNKNOWN
 from ._common import path_exists_strict
+from ._common import socktype_to_enum
 from ._common import supports_ipv6
 from ._common import usage_percent
-from ._compat import b
-from ._compat import basestring
-from ._compat import long
-from ._compat import PY3
-
-if sys.version_info >= (3, 4):
-    import enum
-else:
-    enum = None
+from ._enums import BatteryTime
+from ._enums import ConnectionStatus
+from ._enums import NicDuplex
+from ._enums import ProcessIOPriority
+from ._enums import ProcessStatus
 
-
-__extra__all__ = [
-    #
-    'PROCFS_PATH',
-    # io prio constants
-    "IOPRIO_CLASS_NONE", "IOPRIO_CLASS_RT", "IOPRIO_CLASS_BE",
-    "IOPRIO_CLASS_IDLE",
-    # connection status constants
-    "CONN_ESTABLISHED", "CONN_SYN_SENT", "CONN_SYN_RECV", "CONN_FIN_WAIT1",
-    "CONN_FIN_WAIT2", "CONN_TIME_WAIT", "CONN_CLOSE", "CONN_CLOSE_WAIT",
-    "CONN_LAST_ACK", "CONN_LISTEN", "CONN_CLOSING", ]
+__extra__all__ = ['PROCFS_PATH']
 
 
 # =====================================================================
-# --- constants
+# --- globals
 # =====================================================================
 
 
-HAS_SMAPS = os.path.exists('/proc/%s/smaps' % os.getpid())
-HAS_PRLIMIT = hasattr(cext, "linux_prlimit")
-
-# RLIMIT_* constants, not guaranteed to be present on all kernels
-if HAS_PRLIMIT:
-    for name in dir(cext):
-        if name.startswith('RLIM'):
-            __extra__all__.append(name)
+POWER_SUPPLY_PATH = "/sys/class/power_supply"
+HAS_PROC_SMAPS = os.path.exists(f"/proc/{os.getpid()}/smaps")
+HAS_PROC_SMAPS_ROLLUP = os.path.exists(f"/proc/{os.getpid()}/smaps_rollup")
+HAS_PROC_IO_PRIORITY = hasattr(_psutil, "proc_ioprio_get")
+HAS_CPU_AFFINITY = hasattr(_psutil, "proc_cpu_affinity_get")
 
 # Number of clock ticks per second
 CLOCK_TICKS = os.sysconf("SC_CLK_TCK")
-PAGESIZE = os.sysconf("SC_PAGE_SIZE")
-BOOT_TIME = None  # set later
-# Used when reading "big" files, namely /proc/{pid}/smaps and /proc/net/*.
-# On Python 2, using a buffer with open() for such files may result in a
-# speedup, see: https://github.com/giampaolo/psutil/issues/708
-BIGGER_FILE_BUFFERING = -1 if PY3 else 8192
+PAGESIZE = _psutil.getpagesize()
 LITTLE_ENDIAN = sys.byteorder == 'little'
-if PY3:
-    FS_ENCODING = sys.getfilesystemencoding()
-    ENCODING_ERRORS_HANDLER = 'surrogateescape'
-if enum is None:
-    AF_LINK = socket.AF_PACKET
-else:
-    AddressFamily = enum.IntEnum('AddressFamily',
-                                 {'AF_LINK': int(socket.AF_PACKET)})
-    AF_LINK = AddressFamily.AF_LINK
-
-# ioprio_* constants http://linux.die.net/man/2/ioprio_get
-if enum is None:
-    IOPRIO_CLASS_NONE = 0
-    IOPRIO_CLASS_RT = 1
-    IOPRIO_CLASS_BE = 2
-    IOPRIO_CLASS_IDLE = 3
-else:
-    class IOPriority(enum.IntEnum):
-        IOPRIO_CLASS_NONE = 0
-        IOPRIO_CLASS_RT = 1
-        IOPRIO_CLASS_BE = 2
-        IOPRIO_CLASS_IDLE = 3
-
-    globals().update(IOPriority.__members__)
-
-# taken from /fs/proc/array.c
+UNSET = object()
+
+# Python 3.15 changed resource.prlimit() to return RLIM_INFINITY as the
+# unsigned 2**64-1 instead of -1; used to map it back to -1.
+RLIM_INFINITY_UNSIGNED = _psutil.RLIM_INFINITY & 0xFFFFFFFFFFFFFFFF
+
+# "man iostat" states that sectors are equivalent with blocks and have
+# a size of 512 bytes. Despite this value can be queried at runtime
+# via /sys/block/{DISK}/queue/hw_sector_size and results may vary
+# between 1k, 2k, or 4k... 512 appears to be a magic constant used
+# throughout Linux source code:
+# * https://stackoverflow.com/a/38136179/376587
+# * https://lists.gt.net/linux/kernel/2241060
+# * https://github.com/giampaolo/psutil/issues/1305
+# * https://github.com/torvalds/linux/blob/
+#     4f671fe2f9523a1ea206f63fe60a7c7b3a56d5c7/include/linux/bio.h#L99
+# * https://lkml.org/lkml/2015/8/17/234
+DISK_SECTOR_SIZE = 512
+
+AddressFamily = enum.IntEnum(
+    'AddressFamily', {'AF_LINK': int(socket.AF_PACKET)}
+)
+AF_LINK = AddressFamily.AF_LINK
+
+
+# See:
+# https://github.com/torvalds/linux/blame/master/fs/proc/array.c
+# ...and (TASK_* constants):
+# https://github.com/torvalds/linux/blob/master/include/linux/sched.h
 PROC_STATUSES = {
-    "R": _common.STATUS_RUNNING,
-    "S": _common.STATUS_SLEEPING,
-    "D": _common.STATUS_DISK_SLEEP,
-    "T": _common.STATUS_STOPPED,
-    "t": _common.STATUS_TRACING_STOP,
-    "Z": _common.STATUS_ZOMBIE,
-    "X": _common.STATUS_DEAD,
-    "x": _common.STATUS_DEAD,
-    "K": _common.STATUS_WAKE_KILL,
-    "W": _common.STATUS_WAKING
+    "R": ProcessStatus.STATUS_RUNNING,
+    "S": ProcessStatus.STATUS_SLEEPING,
+    "D": ProcessStatus.STATUS_DISK_SLEEP,
+    "T": ProcessStatus.STATUS_STOPPED,
+    "t": ProcessStatus.STATUS_TRACING_STOP,
+    "Z": ProcessStatus.STATUS_ZOMBIE,
+    "X": ProcessStatus.STATUS_DEAD,
+    "x": ProcessStatus.STATUS_DEAD,
+    "K": ProcessStatus.STATUS_WAKE_KILL,
+    "W": ProcessStatus.STATUS_WAKING,
+    "I": ProcessStatus.STATUS_IDLE,
+    "P": ProcessStatus.STATUS_PARKED,
 }
 
-# http://students.mimuw.edu.pl/lxr/source/include/net/tcp_states.h
+# https://github.com/torvalds/linux/blob/master/include/net/tcp_states.h
 TCP_STATUSES = {
-    "01": _common.CONN_ESTABLISHED,
-    "02": _common.CONN_SYN_SENT,
-    "03": _common.CONN_SYN_RECV,
-    "04": _common.CONN_FIN_WAIT1,
-    "05": _common.CONN_FIN_WAIT2,
-    "06": _common.CONN_TIME_WAIT,
-    "07": _common.CONN_CLOSE,
-    "08": _common.CONN_CLOSE_WAIT,
-    "09": _common.CONN_LAST_ACK,
-    "0A": _common.CONN_LISTEN,
-    "0B": _common.CONN_CLOSING
+    "01": ConnectionStatus.CONN_ESTABLISHED,
+    "02": ConnectionStatus.CONN_SYN_SENT,
+    "03": ConnectionStatus.CONN_SYN_RECV,
+    "04": ConnectionStatus.CONN_FIN_WAIT1,
+    "05": ConnectionStatus.CONN_FIN_WAIT2,
+    "06": ConnectionStatus.CONN_TIME_WAIT,
+    "07": ConnectionStatus.CONN_CLOSE,
+    "08": ConnectionStatus.CONN_CLOSE_WAIT,
+    "09": ConnectionStatus.CONN_LAST_ACK,
+    "0A": ConnectionStatus.CONN_LISTEN,
+    "0B": ConnectionStatus.CONN_CLOSING,
 }
 
 
-# =====================================================================
-# -- exceptions
-# =====================================================================
-
-
-# these get overwritten on "import psutil" from the __init__.py file
-NoSuchProcess = None
-ZombieProcess = None
-AccessDenied = None
-TimeoutExpired = None
-
-
-# =====================================================================
-# --- named tuples
-# =====================================================================
-
-
-svmem = namedtuple(
-    'svmem', ['total', 'available', 'percent', 'used', 'free',
-              'active', 'inactive', 'buffers', 'cached', 'shared'])
-sdiskio = namedtuple(
-    'sdiskio', ['read_count', 'write_count',
-                'read_bytes', 'write_bytes',
-                'read_time', 'write_time',
-                'read_merged_count', 'write_merged_count',
-                'busy_time'])
-popenfile = namedtuple(
-    'popenfile', ['path', 'fd', 'position', 'mode', 'flags'])
-pmem = namedtuple('pmem', 'rss vms shared text lib data dirty')
-pfullmem = namedtuple('pfullmem', pmem._fields + ('uss', 'pss', 'swap'))
-pmmap_grouped = namedtuple(
-    'pmmap_grouped',
-    ['path', 'rss', 'size', 'pss', 'shared_clean', 'shared_dirty',
-     'private_clean', 'private_dirty', 'referenced', 'anonymous', 'swap'])
-pmmap_ext = namedtuple(
-    'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields))
-
-
 # =====================================================================
 # --- utils
 # =====================================================================
 
 
-def open_binary(fname, **kwargs):
-    return open(fname, "rb", **kwargs)
-
-
-def open_text(fname, **kwargs):
-    """On Python 3 opens a file in text mode by using fs encoding and
-    a proper en/decoding errors handler.
-    On Python 2 this is just an alias for open(name, 'rt').
-    """
-    if PY3:
-        # See:
-        # https://github.com/giampaolo/psutil/issues/675
-        # https://github.com/giampaolo/psutil/pull/733
-        kwargs.setdefault('encoding', FS_ENCODING)
-        kwargs.setdefault('errors', ENCODING_ERRORS_HANDLER)
-    return open(fname, "rt", **kwargs)
-
-
-if PY3:
-    def decode(s):
-        return s.decode(encoding=FS_ENCODING, errors=ENCODING_ERRORS_HANDLER)
-else:
-    def decode(s):
-        return s
-
-
-def get_procfs_path():
-    return sys.modules['psutil'].PROCFS_PATH
-
-
 def readlink(path):
     """Wrapper around os.readlink()."""
-    assert isinstance(path, basestring), path
+    assert isinstance(path, str), path
     path = os.readlink(path)
     # readlink() might return paths containing null bytes ('\x00')
     # resulting in "TypeError: must be encoded string without NULL
@@ -227,6 +150,9 @@ def readlink(path):
 
 
 def file_flags_to_mode(flags):
+    """Convert file's open() flags into a readable string.
+    Used by Process.open_files().
+    """
     modes_map = {os.O_RDONLY: 'r', os.O_WRONLY: 'w', os.O_RDWR: 'w+'}
     mode = modes_map[flags & (os.O_RDONLY | os.O_WRONLY | os.O_RDWR)]
     if flags & os.O_APPEND:
@@ -236,132 +162,252 @@ def file_flags_to_mode(flags):
     return mode
 
 
-def get_sector_size():
-    try:
-        with open(b"/sys/block/sda/queue/hw_sector_size") as f:
-            return int(f.read())
-    except (IOError, ValueError):
-        # man iostat states that sectors are equivalent with blocks and
-        # have a size of 512 bytes since 2.4 kernels. This value is
-        # needed to calculate the amount of disk I/O in bytes.
-        return 512
+def is_storage_device(name):
+    """Return True if the given name refers to a root device (e.g.
+    "sda", "nvme0n1") as opposed to a logical partition (e.g.  "sda1",
+    "nvme0n1p1"). If name is a virtual device (e.g. "loop1", "ram")
+    return True.
+    """
+    # Re-adapted from iostat source code, see:
+    # https://github.com/sysstat/sysstat/blob/97912938cd476/common.c#L208
+    # Some devices may have a slash in their name (e.g. cciss/c0d0...).
+    name = name.replace('/', '!')
+    including_virtual = True
+    if including_virtual:
+        path = f"/sys/block/{name}"
+    else:
+        path = f"/sys/block/{name}/device"
+    return os.access(path, os.F_OK)
 
 
-SECTOR_SIZE = get_sector_size()
+# =====================================================================
+# --- system memory
+# =====================================================================
+
+
+def calculate_avail_vmem(mems):
+    """Fallback for kernels < 3.14 where /proc/meminfo does not provide
+    "MemAvailable", see:
+    https://blog.famzah.net/2014/09/24/.
 
+    This code reimplements the algorithm outlined here:
+    https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/
+        commit/?id=34e431b0ae398fc54ea69ff85ec700722c9da773
 
-@memoize
-def set_scputimes_ntuple(procfs_path):
-    """Return a namedtuple of variable fields depending on the
-    CPU times available on this Linux kernel version which may be:
-    (user, nice, system, idle, iowait, irq, softirq, [steal, [guest,
-     [guest_nice]]])
+    We use this function also when "MemAvailable" returns 0 (possibly a
+    kernel bug, see: https://github.com/giampaolo/psutil/issues/1915).
+    In that case this routine matches "free" CLI tool result ("available"
+    column).
+
+    XXX: on recent kernels this calculation may differ by ~1.5% compared
+    to "MemAvailable:", as it's calculated slightly differently.
+    It is still way more realistic than doing (free + cached) though.
+    See:
+    * https://gitlab.com/procps-ng/procps/issues/42
+    * https://github.com/famzah/linux-memavailable-procfs/issues/2
     """
-    global scputimes
-    with open_binary('%s/stat' % procfs_path) as f:
-        values = f.readline().split()[1:]
-    fields = ['user', 'nice', 'system', 'idle', 'iowait', 'irq', 'softirq']
-    vlen = len(values)
-    if vlen >= 8:
-        # Linux >= 2.6.11
-        fields.append('steal')
-    if vlen >= 9:
-        # Linux >= 2.6.24
-        fields.append('guest')
-    if vlen >= 10:
-        # Linux >= 3.2.0
-        fields.append('guest_nice')
-    scputimes = namedtuple('scputimes', fields)
-    return scputimes
-
-
-try:
-    scputimes = set_scputimes_ntuple("/proc")
-except Exception:
-    # Don't want to crash at import time.
-    traceback.print_exc()
-    scputimes = namedtuple('scputimes', 'user system idle')(0.0, 0.0, 0.0)
+    # Note about "fallback" value. According to:
+    # https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=34e431b0ae398
+    # ...long ago "available" memory was calculated as (free + cached),
+    # We use fallback when one of these is missing from /proc/meminfo:
+    # "Active(file)": introduced in 2.6.28 / Dec 2008
+    # "Inactive(file)": introduced in 2.6.28 / Dec 2008
+    # "SReclaimable": introduced in 2.6.19 / Nov 2006
+    # /proc/zoneinfo: introduced in 2.6.13 / Aug 2005
+    free = mems[b'MemFree:']
+    fallback = free + mems.get(b"Cached:", 0)
+    try:
+        lru_active_file = mems[b'Active(file):']
+        lru_inactive_file = mems[b'Inactive(file):']
+        slab_reclaimable = mems[b'SReclaimable:']
+    except KeyError as err:
+        debug(
+            f"{err.args[0]} is missing from /proc/meminfo; using an"
+            " approximation for calculating available memory"
+        )
+        return fallback
+    try:
+        f = open_binary(f"{get_procfs_path()}/zoneinfo")
+    except OSError:
+        return fallback  # kernel 2.6.13
 
+    watermark_low = 0
+    with f:
+        for line in f:
+            line = line.strip()
+            if line.startswith(b'low'):
+                watermark_low += int(line.split()[1])
+    watermark_low *= PAGESIZE
 
-# =====================================================================
-# --- system memory
-# =====================================================================
+    avail = free - watermark_low
+    pagecache = lru_active_file + lru_inactive_file
+    pagecache -= min(pagecache / 2, watermark_low)
+    avail += pagecache
+    avail += slab_reclaimable - min(slab_reclaimable / 2.0, watermark_low)
+    return int(avail)
 
 
 def virtual_memory():
-    total, free, buffers, shared, _, _, unit_multiplier = cext.linux_sysinfo()
-    total *= unit_multiplier
-    free *= unit_multiplier
-    buffers *= unit_multiplier
-    # Note: this (on my Ubuntu 14.04, kernel 3.13 at least) may be 0.
-    # If so, it will be determined from /proc/meminfo.
-    shared *= unit_multiplier or None
-    if shared == 0:
-        shared = None
-
-    cached = active = inactive = None
-    with open_binary('%s/meminfo' % get_procfs_path()) as f:
+    """Report virtual memory stats.
+    This implementation mimics procps-ng-3.3.12, aka "free" CLI tool:
+    https://gitlab.com/procps-ng/procps/blob/
+        24fd2605c51fccc375ab0287cec33aa767f06718/proc/sysinfo.c#L778-791
+    The returned values are supposed to match both "free" and "vmstat -s"
+    CLI tools.
+    """
+    missing_fields = []
+    mems = {}
+    with open_binary(f"{get_procfs_path()}/meminfo") as f:
         for line in f:
-            if cached is None and line.startswith(b"Cached:"):
-                cached = int(line.split()[1]) * 1024
-            elif active is None and line.startswith(b"Active:"):
-                active = int(line.split()[1]) * 1024
-            elif inactive is None and line.startswith(b"Inactive:"):
-                inactive = int(line.split()[1]) * 1024
-            # From "man free":
-            # The shared memory column represents either the MemShared
-            # value (2.4 kernels) or the Shmem value (2.6+ kernels) taken
-            # from the /proc/meminfo file. The value is zero if none of
-            # the entries is exported by the kernel.
-            elif shared is None and \
-                    line.startswith(b"MemShared:") or \
-                    line.startswith(b"Shmem:"):
-                shared = int(line.split()[1]) * 1024
-
-    missing = []
-    if cached is None:
-        missing.append('cached')
+            key, value = line.split(b':', 1)
+            mems[key + b':'] = int(value.split()[0]) * 1024
+
+    # /proc doc states that the available fields in /proc/meminfo vary
+    # by architecture and compile options, but these 3 values are also
+    # returned by sysinfo(2); as such we assume they are always there.
+    total = mems[b'MemTotal:']
+    free = mems[b'MemFree:']
+    try:
+        buffers = mems[b'Buffers:']
+    except KeyError:
+        # https://github.com/giampaolo/psutil/issues/1010
+        buffers = 0
+        missing_fields.append('buffers')
+    try:
+        cached = mems[b"Cached:"]
+    except KeyError:
         cached = 0
-    if active is None:
-        missing.append('active')
+        missing_fields.append('cached')
+    else:
+        # "free" cmdline utility sums reclaimable to cached.
+        # Older versions of procps used to add slab memory instead.
+        # This got changed in:
+        # https://gitlab.com/procps-ng/procps/-/commit/05d751c4f
+        cached += mems.get(b"SReclaimable:", 0)  # since kernel 2.6.19
+
+    try:
+        shared = mems[b'Shmem:']  # since kernel 2.6.32
+    except KeyError:
+        try:
+            shared = mems[b'MemShared:']  # kernels 2.4
+        except KeyError:
+            shared = 0
+            missing_fields.append('shared')
+
+    try:
+        active = mems[b"Active:"]
+    except KeyError:
         active = 0
-    if inactive is None:
-        missing.append('inactive')
-        inactive = 0
-    if shared is None:
-        missing.append('shared')
-        shared = 0
-    if missing:
-        msg = "%s memory stats couldn't be determined and %s set to 0" % (
-            ", ".join(missing),
-            "was" if len(missing) == 1 else "were")
-        warnings.warn(msg, RuntimeWarning)
-
-    # Note: this value matches "htop" perfectly.
-    avail = free + buffers + cached
-    # Note: this value matches "free", but not all the time, see:
-    # https://github.com/giampaolo/psutil/issues/685#issuecomment-202914057
-    used = total - free
-    # Note: this value matches "htop" perfectly.
-    percent = usage_percent((total - avail), total, _round=1)
-    return svmem(total, avail, percent, used, free,
-                 active, inactive, buffers, cached, shared)
+        missing_fields.append('active')
+
+    try:
+        inactive = mems[b"Inactive:"]
+    except KeyError:
+        try:
+            inactive = (
+                mems[b"Inact_dirty:"]
+                + mems[b"Inact_clean:"]
+                + mems[b"Inact_laundry:"]
+            )
+        except KeyError:
+            inactive = 0
+            missing_fields.append('inactive')
+
+    try:
+        slab = mems[b"Slab:"]
+    except KeyError:
+        slab = 0
+
+    # - starting from 4.4.0 we match free's "available" column.
+    #   Before 4.4.0 we calculated it as (free + buffers + cached)
+    #   which matched htop.
+    # - free and htop available memory differs as per:
+    #   http://askubuntu.com/a/369589
+    #   http://unix.stackexchange.com/a/65852/168884
+    # - MemAvailable has been introduced in kernel 3.14
+    try:
+        avail = mems[b'MemAvailable:']
+    except KeyError:
+        avail = calculate_avail_vmem(mems)
+    else:
+        if avail == 0:
+            # Yes, it can happen (probably a kernel bug):
+            # https://github.com/giampaolo/psutil/issues/1915
+            # In this case "free" CLI tool makes an estimate. We do the same,
+            # and it matches "free" CLI tool.
+            avail = calculate_avail_vmem(mems)
+
+    if avail < 0:
+        avail = 0
+        missing_fields.append('available')
+    elif avail > total:
+        # If avail is greater than total or our calculation overflows,
+        # that's symptomatic of running within a LCX container where such
+        # values will be dramatically distorted over those of the host.
+        # https://gitlab.com/procps-ng/procps/blob/24fd2605c51fcc/proc/sysinfo.c#L764
+        avail = free
+
+    used = total - avail
+
+    percent = usage_percent((total - avail), total, round_=1)
+
+    # Warn about missing metrics which are set to 0.
+    if missing_fields:
+        msg = "{} memory stats couldn't be determined and {} set to 0".format(
+            ", ".join(missing_fields),
+            "was" if len(missing_fields) == 1 else "were",
+        )
+        warnings.warn(msg, RuntimeWarning, stacklevel=2)
+
+    return ntp.svmem(
+        total,
+        avail,
+        percent,
+        used,
+        free,
+        active,
+        inactive,
+        buffers,
+        cached,
+        shared,
+        slab,
+    )
 
 
 def swap_memory():
-    _, _, _, _, total, free, unit_multiplier = cext.linux_sysinfo()
-    total *= unit_multiplier
-    free *= unit_multiplier
+    """Return swap memory metrics."""
+    mems = {}
+    with open_binary(f"{get_procfs_path()}/meminfo") as f:
+        for line in f:
+            # Note: some fields (e.g. "ShadowCallStack:10373888 kB")
+            # may not have a space after the colon, see:
+            # https://github.com/giampaolo/psutil/issues/2809
+            key, value = line.split(b':', 1)
+            mems[key + b':'] = int(value.split()[0]) * 1024
+    # We prefer /proc/meminfo over sysinfo() syscall so that
+    # psutil.PROCFS_PATH can be used in order to allow retrieval
+    # for linux containers, see:
+    # https://github.com/giampaolo/psutil/issues/1015
+    try:
+        total = mems[b'SwapTotal:']
+        free = mems[b'SwapFree:']
+    except KeyError:
+        _, _, _, _, total, free, unit_multiplier = _psutil.linux_sysinfo()
+        total *= unit_multiplier
+        free *= unit_multiplier
+
     used = total - free
-    percent = usage_percent(used, total, _round=1)
+    percent = usage_percent(used, total, round_=1)
     # get pgin/pgouts
     try:
-        f = open_binary("%s/vmstat" % get_procfs_path())
-    except IOError as err:
+        f = open_binary(f"{get_procfs_path()}/vmstat")
+    except OSError as err:
         # see https://github.com/giampaolo/psutil/issues/722
-        msg = "'sin' and 'sout' swap memory stats couldn't " \
-              "be determined and were set to 0 (%s)" % str(err)
-        warnings.warn(msg, RuntimeWarning)
+        msg = (
+            "'sin' and 'sout' swap memory stats couldn't "
+            f"be determined and were set to 0 ({err})"
+        )
+        warnings.warn(msg, RuntimeWarning, stacklevel=2)
         sin = sout = 0
     else:
         with f:
@@ -379,54 +425,97 @@ def swap_memory():
                 # we might get here when dealing with exotic Linux
                 # flavors, see:
                 # https://github.com/giampaolo/psutil/issues/313
-                msg = "'sin' and 'sout' swap memory stats couldn't " \
-                      "be determined and were set to 0"
-                warnings.warn(msg, RuntimeWarning)
+                msg = "'sin' and 'sout' swap memory stats couldn't "
+                msg += "be determined and were set to 0"
+                warnings.warn(msg, RuntimeWarning, stacklevel=2)
                 sin = sout = 0
-    return _common.sswap(total, used, free, percent, sin, sout)
+    return ntp.sswap(total, used, free, percent, sin, sout)
+
+
+# malloc / heap functions; require glibc
+if hasattr(_psutil, "heap_info"):
+    heap_info = _psutil.heap_info
+    heap_trim = _psutil.heap_trim
 
 
 # =====================================================================
-# --- CPUs
+# --- CPU
 # =====================================================================
 
 
 def cpu_times():
-    """Return a named tuple representing the following system-wide
-    CPU times:
-    (user, nice, system, idle, iowait, irq, softirq [steal, [guest,
-     [guest_nice]]])
-    Last 3 fields may not be available on all Linux kernel versions.
-    """
+    """Return a named tuple representing system-wide CPU times."""
+
+    def lsget(lst, idx, field_name):
+        try:
+            return lst[idx]
+        except IndexError:
+            debug(f"can't get {field_name} CPU time; set it to 0")
+            return 0
+
     procfs_path = get_procfs_path()
-    set_scputimes_ntuple(procfs_path)
-    with open_binary('%s/stat' % procfs_path) as f:
+    with open_binary(f"{procfs_path}/stat") as f:
         values = f.readline().split()
-    fields = values[1:len(scputimes._fields) + 1]
-    fields = [float(x) / CLOCK_TICKS for x in fields]
-    return scputimes(*fields)
+    nfields = len(ntp.scputimes._fields)
+    raw = [float(x) / CLOCK_TICKS for x in values[1 : nfields + 1]]
+    user, nice, system, idle = raw[:4]
+    return ntp.scputimes(
+        user,
+        system,
+        idle,
+        nice,
+        lsget(raw, 4, "iowait"),  # Linux >= 2.5.41
+        lsget(raw, 5, "irq"),  # Linux >= 2.6.0
+        lsget(raw, 6, "softirq"),  # Linux >= 2.6.0
+        lsget(raw, 7, "steal"),  # Linux >= 2.6.11
+        lsget(raw, 8, "guest"),  # Linux >= 2.6.24
+        lsget(raw, 9, "guest_nice"),  # Linux >= 2.6.33
+    )
 
 
 def per_cpu_times():
-    """Return a list of namedtuple representing the CPU times
+    """Return a list of named tuples representing the CPU times
     for every CPU available on the system.
     """
     procfs_path = get_procfs_path()
-    set_scputimes_ntuple(procfs_path)
     cpus = []
-    with open_binary('%s/stat' % procfs_path) as f:
+    nfields = len(ntp.scputimes._fields)
+    with open_binary(f"{procfs_path}/stat") as f:
         # get rid of the first line which refers to system wide CPU stats
         f.readline()
         for line in f:
             if line.startswith(b'cpu'):
                 values = line.split()
-                fields = values[1:len(scputimes._fields) + 1]
-                fields = [float(x) / CLOCK_TICKS for x in fields]
-                entry = scputimes(*fields)
+                raw = [float(x) / CLOCK_TICKS for x in values[1 : nfields + 1]]
+                user, nice, system, idle = raw[0], raw[1], raw[2], raw[3]
+                entry = ntp.scputimes(user, system, idle, nice, *raw[4:])
                 cpus.append(entry)
         return cpus
 
 
+def _parse_cpulist(cpulist):
+    """Parse Linux CPU list string (e.g "0-3,8,10-11")"""
+    cpulist = cpulist.strip()
+    if not cpulist:
+        return []
+    cpus = []
+    for chunk in cpulist.split(','):
+        chunk = chunk.strip()
+        if not chunk:
+            continue
+        if '-' in chunk:
+            start, _, end = chunk.partition('-')
+            start = int(start)
+            end = int(end)
+            if start > end:
+                msg = f"invalid CPU range {chunk!r}"
+                raise ValueError(msg)
+            cpus.extend(range(start, end + 1))
+        else:
+            cpus.append(int(chunk))
+    return cpus
+
+
 def cpu_count_logical():
     """Return the number of logical CPUs in the system."""
     try:
@@ -434,7 +523,7 @@ def cpu_count_logical():
     except ValueError:
         # as a second fallback we try to parse /proc/cpuinfo
         num = 0
-        with open_binary('%s/cpuinfo' % get_procfs_path()) as f:
+        with open_binary(f"{get_procfs_path()}/cpuinfo") as f:
             for line in f:
                 if line.lower().startswith(b'processor'):
                     num += 1
@@ -443,8 +532,8 @@ def cpu_count_logical():
         # https://github.com/giampaolo/psutil/issues/200
         # try to parse /proc/stat as a last resort
         if num == 0:
-            search = re.compile('cpu\d')
-            with open_text('%s/stat' % get_procfs_path()) as f:
+            search = re.compile(r'cpu\d')
+            with open_text(f"{get_procfs_path()}/stat") as f:
                 for line in f:
                     line = line.split(' ')[0]
                     if search.match(line):
@@ -456,33 +545,51 @@ def cpu_count_logical():
         return num
 
 
-def cpu_count_physical():
-    """Return the number of physical cores in the system."""
+def cpu_count_cores():
+    """Return the number of CPU cores in the system."""
+    # Method #1
+    ls = set()
+    # These 2 files are the same but */core_cpus_list is newer while
+    # */thread_siblings_list is deprecated and may disappear in the future.
+    # https://www.kernel.org/doc/Documentation/admin-guide/cputopology.rst
+    # https://github.com/giampaolo/psutil/pull/1727#issuecomment-707624964
+    # https://lkml.org/lkml/2019/2/26/41
+    p1 = "/sys/devices/system/cpu/cpu[0-9]*/topology/core_cpus_list"
+    p2 = "/sys/devices/system/cpu/cpu[0-9]*/topology/thread_siblings_list"
+    for path in glob.glob(p1) or glob.glob(p2):
+        with open_binary(path) as f:
+            ls.add(f.read().strip())
+    result = len(ls)
+    if result != 0:
+        return result
+
+    # Method #2
     mapping = {}
     current_info = {}
-    with open_binary('%s/cpuinfo' % get_procfs_path()) as f:
+    with open_binary(f"{get_procfs_path()}/cpuinfo") as f:
         for line in f:
             line = line.strip().lower()
             if not line:
                 # new section
-                if (b'physical id' in current_info and
-                        b'cpu cores' in current_info):
-                    mapping[current_info[b'physical id']] = \
-                        current_info[b'cpu cores']
+                try:
+                    mapping[current_info[b'physical id']] = current_info[
+                        b'cpu cores'
+                    ]
+                except KeyError:
+                    pass
                 current_info = {}
-            else:
+            elif line.startswith((b'physical id', b'cpu cores')):
                 # ongoing section
-                if (line.startswith(b'physical id') or
-                        line.startswith(b'cpu cores')):
-                    key, value = line.split(b'\t:', 1)
-                    current_info[key] = int(value)
+                key, value = line.split(b':', 1)
+                current_info[key.strip()] = int(value)
 
-    # mimic os.cpu_count()
-    return sum(mapping.values()) or None
+    result = sum(mapping.values())
+    return result or None  # mimic os.cpu_count()
 
 
 def cpu_stats():
-    with open_binary('%s/stat' % get_procfs_path()) as f:
+    """Return various CPU stats as a named tuple."""
+    with open_binary(f"{get_procfs_path()}/stat") as f:
         ctx_switches = None
         interrupts = None
         soft_interrupts = None
@@ -493,12 +600,99 @@ def cpu_stats():
                 interrupts = int(line.split()[1])
             elif line.startswith(b'softirq'):
                 soft_interrupts = int(line.split()[1])
-            if ctx_switches is not None and soft_interrupts is not None \
-                    and interrupts is not None:
+            if (
+                ctx_switches is not None
+                and soft_interrupts is not None
+                and interrupts is not None
+            ):
                 break
     syscalls = 0
-    return _common.scpustats(
-        ctx_switches, interrupts, soft_interrupts, syscalls)
+    return ntp.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls)
+
+
+def _cpu_get_cpuinfo_freq():
+    """Return current CPU frequency from cpuinfo if available."""
+    ret = []
+    with open_binary(f"{get_procfs_path()}/cpuinfo") as f:
+        for line in f:
+            key, _, value = line.partition(b':')
+            key = key.strip().lower()
+            # x86 says "cpu MHz", ppc "clock" (with a MHz suffix),
+            # s390x "cpu MHz dynamic" plus a "static" one we skip.
+            # https://github.com/torvalds/linux/blob/master/arch/powerpc/kernel/setup-common.c
+            # https://github.com/torvalds/linux/blob/master/arch/s390/kernel/processor.c
+            if key in {b'cpu mhz', b'clock', b'cpu mhz dynamic'}:
+                value = value.strip()
+                if value.endswith(b"MHz"):
+                    value = value[:-3]
+                ret.append(float(value))
+    return ret
+
+
+if os.path.exists("/sys/devices/system/cpu/cpufreq/policy0") or os.path.exists(
+    "/sys/devices/system/cpu/cpu0/cpufreq"
+):
+
+    def cpu_freq():
+        """Return frequency metrics for all CPUs.
+        Contrarily to other OSes, Linux updates these values in
+        real-time.
+        """
+        pjoin = os.path.join
+        cpuinfo_freqs = _cpu_get_cpuinfo_freq()
+        paths = glob.glob(
+            "/sys/devices/system/cpu/cpufreq/policy[0-9]*"
+        ) or glob.glob("/sys/devices/system/cpu/cpu[0-9]*/cpufreq")
+
+        # One policy may govern more than one CPU, so ask each policy
+        # which CPUs it affects instead of assuming one per CPU. Offline
+        # CPUs are listed by no policy, and are therefore left out.
+        # https://github.com/giampaolo/psutil/issues/2512
+        cpu_to_path = {}
+        for path in paths:
+            affected = bcat(pjoin(path, "affected_cpus"), fallback=None)
+            if affected is None:
+                cpu_to_path[int(re.search(r"[0-9]+", path).group())] = path
+            else:
+                for cpu in affected.split():
+                    cpu_to_path[int(cpu)] = path
+
+        ret = []
+        for i, cpu in enumerate(sorted(cpu_to_path)):
+            path = cpu_to_path[cpu]
+            if len(cpu_to_path) == len(cpuinfo_freqs):
+                # take cached value from cpuinfo if available, see:
+                # https://github.com/giampaolo/psutil/issues/1851
+                curr = cpuinfo_freqs[i] * 1000
+            else:
+                curr = bcat(pjoin(path, "scaling_cur_freq"), fallback=None)
+            if curr is None:
+                # Likely an old RedHat, see:
+                # https://github.com/giampaolo/psutil/issues/1071
+                curr = bcat(pjoin(path, "cpuinfo_cur_freq"), fallback=None)
+                if curr is None:
+                    online_path = f"/sys/devices/system/cpu/cpu{cpu}/online"
+                    # If the CPU core is offline skip it instead of
+                    # reporting it as all zeroes, otherwise it drags
+                    # down the average frequency. See:
+                    # https://github.com/giampaolo/psutil/issues/2628
+                    if cat(online_path, fallback=None) == "0\n":
+                        continue
+                    msg = "can't find current frequency file"
+                    raise NotImplementedError(msg)
+            curr = int(curr) / 1000
+            max_ = int(bcat(pjoin(path, "scaling_max_freq"))) / 1000
+            min_ = int(bcat(pjoin(path, "scaling_min_freq"))) / 1000
+            ret.append(ntp.scpufreq(curr, min_, max_))
+        return ret
+
+else:
+
+    def cpu_freq():
+        """Alternate implementation using /proc/cpuinfo.
+        min and max frequencies are not available and are set to 0.
+        """
+        return [ntp.scpufreq(x, 0.0, 0.0) for x in _cpu_get_cpuinfo_freq()]
 
 
 # =====================================================================
@@ -506,14 +700,14 @@ def cpu_stats():
 # =====================================================================
 
 
-net_if_addrs = cext_posix.net_if_addrs
+net_if_addrs = _psutil.net_if_addrs
 
 
 class _Ipv6UnsupportedError(Exception):
     pass
 
 
-class Connections:
+class NetConnections:
     """A wrapper on top of /proc/net/* files, retrieving per-process
     and system-wide open connections (TCP, UDP, UNIX) similarly to
     "netstat -an".
@@ -526,6 +720,8 @@ class Connections:
     """
 
     def __init__(self):
+        # The string represents the basename of the corresponding
+        # /proc/net/{proto_name} file.
         tcp4 = ("tcp", socket.AF_INET, socket.SOCK_STREAM)
         tcp6 = ("tcp6", socket.AF_INET6, socket.SOCK_STREAM)
         udp4 = ("udp", socket.AF_INET, socket.SOCK_DGRAM)
@@ -548,20 +744,23 @@ def __init__(self):
 
     def get_proc_inodes(self, pid):
         inodes = defaultdict(list)
-        for fd in os.listdir("%s/%s/fd" % (self._procfs_path, pid)):
+        for fd in os.listdir(f"{self._procfs_path}/{pid}/fd"):
             try:
-                inode = readlink("%s/%s/fd/%s" % (self._procfs_path, pid, fd))
-            except OSError as err:
+                inode = readlink(f"{self._procfs_path}/{pid}/fd/{fd}")
+            except (FileNotFoundError, ProcessLookupError):
                 # ENOENT == file which is gone in the meantime;
-                # os.stat('/proc/%s' % self.pid) will be done later
+                # os.stat(f"/proc/{self.pid}") will be done later
                 # to force NSP (if it's the case)
-                if err.errno in (errno.ENOENT, errno.ESRCH):
-                    continue
-                elif err.errno == errno.EINVAL:
+                continue
+            except OSError as err:
+                if err.errno == errno.EINVAL:
                     # not a link
                     continue
-                else:
-                    raise
+                if err.errno == errno.ENAMETOOLONG:
+                    # file name too long
+                    debug(err)
+                    continue
+                raise
             else:
                 if inode.startswith('socket:['):
                     # the process is using a socket
@@ -574,7 +773,7 @@ def get_all_inodes(self):
         for pid in pids():
             try:
                 inodes.update(self.get_proc_inodes(pid))
-            except OSError as err:
+            except (FileNotFoundError, ProcessLookupError, PermissionError):
                 # os.listdir() is gonna raise a lot of access denied
                 # exceptions in case of unprivileged user; that's fine
                 # as we'll just end up returning a connection with PID
@@ -582,12 +781,11 @@ def get_all_inodes(self):
                 # Both netstat -an and lsof does the same so it's
                 # unlikely we can do any better.
                 # ENOENT just means a PID disappeared on us.
-                if err.errno not in (
-                        errno.ENOENT, errno.ESRCH, errno.EPERM, errno.EACCES):
-                    raise
+                continue
         return inodes
 
-    def decode_address(self, addr, family):
+    @staticmethod
+    def decode_address(addr, family):
         """Accept an "ip:port" address as displayed in /proc/net/*
         and convert it into a human readable form, like:
 
@@ -609,8 +807,7 @@ def decode_address(self, addr, family):
         # no end-points connected
         if not port:
             return ()
-        if PY3:
-            ip = ip.encode('ascii')
+        ip = ip.encode('ascii')
         if family == socket.AF_INET:
             # see: https://github.com/giampaolo/psutil/issues/201
             if LITTLE_ENDIAN:
@@ -618,50 +815,51 @@ def decode_address(self, addr, family):
             else:
                 ip = socket.inet_ntop(family, base64.b16decode(ip))
         else:  # IPv6
-            # old version - let's keep it, just in case...
-            # ip = ip.decode('hex')
-            # return socket.inet_ntop(socket.AF_INET6,
-            #          ''.join(ip[i:i+4][::-1] for i in xrange(0, 16, 4)))
             ip = base64.b16decode(ip)
             try:
                 # see: https://github.com/giampaolo/psutil/issues/201
                 if LITTLE_ENDIAN:
                     ip = socket.inet_ntop(
                         socket.AF_INET6,
-                        struct.pack('>4I', *struct.unpack('<4I', ip)))
+                        struct.pack('>4I', *struct.unpack('<4I', ip)),
+                    )
                 else:
                     ip = socket.inet_ntop(
                         socket.AF_INET6,
-                        struct.pack('<4I', *struct.unpack('<4I', ip)))
+                        struct.pack('<4I', *struct.unpack('<4I', ip)),
+                    )
             except ValueError:
                 # see: https://github.com/giampaolo/psutil/issues/623
                 if not supports_ipv6():
-                    raise _Ipv6UnsupportedError
-                else:
-                    raise
-        return (ip, port)
+                    raise _Ipv6UnsupportedError from None
+                raise
+        return ntp.addr(ip, port)
 
-    def process_inet(self, file, family, type_, inodes, filter_pid=None):
+    @staticmethod
+    def process_inet(file, family, type_, inodes, filter_pid=None):
         """Parse /proc/net/tcp* and /proc/net/udp* files."""
         if file.endswith('6') and not os.path.exists(file):
             # IPv6 not supported
             return
-        with open_text(file, buffering=BIGGER_FILE_BUFFERING) as f:
+        with open_text(file) as f:
             f.readline()  # skip the first line
             for lineno, line in enumerate(f, 1):
                 try:
-                    _, laddr, raddr, status, _, _, _, _, _, inode = \
+                    _, laddr, raddr, status, _, _, _, _, _, inode = (
                         line.split()[:10]
+                    )
                 except ValueError:
-                    raise RuntimeError(
-                        "error while parsing %s; malformed line %s %r" % (
-                            file, lineno, line))
+                    msg = (
+                        f"error while parsing {file}; malformed line"
+                        f" {lineno} {line!r}"
+                    )
+                    raise RuntimeError(msg) from None
                 if inode in inodes:
                     # # We assume inet sockets are unique, so we error
                     # # out if there are multiple references to the
                     # # same inode. We won't do this for UNIX sockets.
                     # if len(inodes[inode]) > 1 and family != socket.AF_UNIX:
-                    #     raise ValueError("ambiguos inode with multiple "
+                    #     raise ValueError("ambiguous inode with multiple "
                     #                      "PIDs references")
                     pid, fd = inodes[inode][0]
                 else:
@@ -672,17 +870,18 @@ def process_inet(self, file, family, type_, inodes, filter_pid=None):
                     if type_ == socket.SOCK_STREAM:
                         status = TCP_STATUSES[status]
                     else:
-                        status = _common.CONN_NONE
+                        status = ConnectionStatus.CONN_NONE
                     try:
-                        laddr = self.decode_address(laddr, family)
-                        raddr = self.decode_address(raddr, family)
+                        laddr = NetConnections.decode_address(laddr, family)
+                        raddr = NetConnections.decode_address(raddr, family)
                     except _Ipv6UnsupportedError:
                         continue
                     yield (fd, family, type_, laddr, raddr, status, pid)
 
-    def process_unix(self, file, family, inodes, filter_pid=None):
+    @staticmethod
+    def process_unix(file, family, inodes, filter_pid=None):
         """Parse /proc/net/unix files."""
-        with open_text(file, buffering=BIGGER_FILE_BUFFERING) as f:
+        with open_text(file) as f:
             f.readline()  # skip the first line
             for line in f:
                 tokens = line.split()
@@ -692,10 +891,11 @@ def process_unix(self, file, family, inodes, filter_pid=None):
                     if ' ' not in line:
                         # see: https://github.com/giampaolo/psutil/issues/766
                         continue
-                    raise RuntimeError(
-                        "error while parsing %s; malformed line %r" % (
-                            file, line))
-                if inode in inodes:
+                    msg = (
+                        f"error while parsing {file}; malformed line {line!r}"
+                    )
+                    raise RuntimeError(msg)  # noqa: B904
+                if inode in inodes:  # noqa: SIM108
                     # With UNIX sockets we can have a single inode
                     # referencing many file descriptors.
                     pairs = inodes[inode]
@@ -705,19 +905,16 @@ def process_unix(self, file, family, inodes, filter_pid=None):
                     if filter_pid is not None and filter_pid != pid:
                         continue
                     else:
-                        if len(tokens) == 8:
-                            path = tokens[-1]
-                        else:
-                            path = ""
-                        type_ = int(type_)
-                        raddr = None
-                        status = _common.CONN_NONE
+                        path = tokens[-1] if len(tokens) == 8 else ''
+                        type_ = socktype_to_enum(int(type_))
+                        # XXX: determining the remote endpoint of a
+                        # UNIX socket on Linux is not possible, see:
+                        # https://serverfault.com/questions/252723/
+                        raddr = ""
+                        status = ConnectionStatus.CONN_NONE
                         yield (fd, family, type_, path, raddr, status, pid)
 
     def retrieve(self, kind, pid=None):
-        if kind not in self.tmap:
-            raise ValueError("invalid %r kind argument; choose between %s"
-                             % (kind, ', '.join([repr(x) for x in self.tmap])))
         self._procfs_path = get_procfs_path()
         if pid is not None:
             inodes = self.get_proc_inodes(pid)
@@ -727,70 +924,105 @@ def retrieve(self, kind, pid=None):
         else:
             inodes = self.get_all_inodes()
         ret = set()
-        for f, family, type_ in self.tmap[kind]:
-            if family in (socket.AF_INET, socket.AF_INET6):
+        for proto_name, family, type_ in self.tmap[kind]:
+            path = f"{self._procfs_path}/net/{proto_name}"
+            if family in {socket.AF_INET, socket.AF_INET6}:
                 ls = self.process_inet(
-                    "%s/net/%s" % (self._procfs_path, f),
-                    family, type_, inodes, filter_pid=pid)
+                    path, family, type_, inodes, filter_pid=pid
+                )
             else:
-                ls = self.process_unix(
-                    "%s/net/%s" % (self._procfs_path, f),
-                    family, inodes, filter_pid=pid)
+                ls = self.process_unix(path, family, inodes, filter_pid=pid)
             for fd, family, type_, laddr, raddr, status, bound_pid in ls:
                 if pid:
-                    conn = _common.pconn(fd, family, type_, laddr, raddr,
-                                         status)
+                    conn = ntp.pconn(fd, family, type_, laddr, raddr, status)
                 else:
-                    conn = _common.sconn(fd, family, type_, laddr, raddr,
-                                         status, bound_pid)
+                    conn = ntp.sconn(
+                        fd, family, type_, laddr, raddr, status, bound_pid
+                    )
                 ret.add(conn)
         return list(ret)
 
 
-_connections = Connections()
+_net_connections = NetConnections()
 
 
 def net_connections(kind='inet'):
     """Return system-wide open connections."""
-    return _connections.retrieve(kind)
+    return _net_connections.retrieve(kind)
 
 
 def net_io_counters():
     """Return network I/O statistics for every network interface
     installed on the system as a dict of raw tuples.
     """
-    with open_text("%s/net/dev" % get_procfs_path()) as f:
+    with open_text(f"{get_procfs_path()}/net/dev") as f:
         lines = f.readlines()
     retdict = {}
     for line in lines[2:]:
         colon = line.rfind(':')
         assert colon > 0, repr(line)
         name = line[:colon].strip()
-        fields = line[colon + 1:].strip().split()
-        bytes_recv = int(fields[0])
-        packets_recv = int(fields[1])
-        errin = int(fields[2])
-        dropin = int(fields[3])
-        bytes_sent = int(fields[8])
-        packets_sent = int(fields[9])
-        errout = int(fields[10])
-        dropout = int(fields[11])
-        retdict[name] = (bytes_sent, bytes_recv, packets_sent, packets_recv,
-                         errin, errout, dropin, dropout)
+        fields = line[colon + 1 :].strip().split()
+
+        (
+            # in
+            bytes_recv,
+            packets_recv,
+            errin,
+            dropin,
+            _fifoin,  # unused
+            _framein,  # unused
+            _compressedin,  # unused
+            _multicastin,  # unused
+            # out
+            bytes_sent,
+            packets_sent,
+            errout,
+            dropout,
+            _fifoout,  # unused
+            _collisionsout,  # unused
+            _carrierout,  # unused
+            _compressedout,  # unused
+        ) = map(int, fields)
+
+        retdict[name] = (
+            bytes_sent,
+            bytes_recv,
+            packets_sent,
+            packets_recv,
+            errin,
+            errout,
+            dropin,
+            dropout,
+        )
     return retdict
 
 
 def net_if_stats():
     """Get NIC stats (isup, duplex, speed, mtu)."""
-    duplex_map = {cext.DUPLEX_FULL: NIC_DUPLEX_FULL,
-                  cext.DUPLEX_HALF: NIC_DUPLEX_HALF,
-                  cext.DUPLEX_UNKNOWN: NIC_DUPLEX_UNKNOWN}
+    duplex_map = {
+        _psutil.DUPLEX_FULL: NicDuplex.NIC_DUPLEX_FULL,
+        _psutil.DUPLEX_HALF: NicDuplex.NIC_DUPLEX_HALF,
+        _psutil.DUPLEX_UNKNOWN: NicDuplex.NIC_DUPLEX_UNKNOWN,
+    }
     names = net_io_counters().keys()
     ret = {}
     for name in names:
-        isup, duplex, speed, mtu = cext.net_if_stats(name)
-        duplex = duplex_map[duplex]
-        ret[name] = _common.snicstats(isup, duplex, speed, mtu)
+        try:
+            mtu = _psutil.net_if_mtu(name)
+            flags = _psutil.net_if_flags(name)
+            duplex, speed = _psutil.net_if_duplex_speed(name)
+        except OSError as err:
+            # https://github.com/giampaolo/psutil/issues/1279
+            if err.errno != errno.ENODEV:
+                raise
+            debug(err)
+        else:
+            output_flags = ','.join(flags)
+            isup = 'running' in flags
+            ret[name] = ntp.snicstats(
+                isup, duplex_map[duplex], speed, mtu, output_flags
+            )
     return ret
 
 
@@ -802,35 +1034,12 @@ def net_if_stats():
 disk_usage = _psposix.disk_usage
 
 
-def disk_io_counters():
+def disk_io_counters(perdisk=False):
     """Return disk I/O statistics for every disk installed on the
     system as a dict of raw tuples.
     """
-    # determine partitions we want to look for
-    def get_partitions():
-        partitions = []
-        with open_text("%s/partitions" % get_procfs_path()) as f:
-            lines = f.readlines()[2:]
-        for line in reversed(lines):
-            _, _, _, name = line.split()
-            if name[-1].isdigit():
-                # we're dealing with a partition (e.g. 'sda1'); 'sda' will
-                # also be around but we want to omit it
-                partitions.append(name)
-            else:
-                if not partitions or not partitions[-1].startswith(name):
-                    # we're dealing with a disk entity for which no
-                    # partitions have been defined (e.g. 'sda' but
-                    # 'sda1' was not around), see:
-                    # https://github.com/giampaolo/psutil/issues/338
-                    partitions.append(name)
-        return partitions
 
-    retdict = {}
-    partitions = get_partitions()
-    with open_text("%s/diskstats" % get_procfs_path()) as f:
-        lines = f.readlines()
-    for line in lines:
+    def read_procfs():
         # OK, this is a bit confusing. The format of /proc/diskstats can
         # have 3 variations.
         # On Linux 2.4 each line has always 15 fields, e.g.:
@@ -841,100 +1050,493 @@ def get_partitions():
         # ...unless (Linux 2.6) the line refers to a partition instead
         # of a disk, in which case the line has less fields (7):
         # "3    1   hda1 8 8 8 8"
+        # 4.18+ has 4 fields added:
+        # "3    0   hda 8 8 8 8 8 8 8 8 8 8 8 0 0 0 0"
+        # 5.5 has 2 more fields.
         # See:
         # https://www.kernel.org/doc/Documentation/iostats.txt
         # https://www.kernel.org/doc/Documentation/ABI/testing/procfs-diskstats
-        fields = line.split()
-        fields_len = len(fields)
-        if fields_len == 15:
-            # Linux 2.4
-            name = fields[3]
-            reads = int(fields[2])
-            (reads_merged, rbytes, rtime, writes, writes_merged,
-                wbytes, wtime, _, busy_time, _) = map(int, fields[4:14])
-        elif fields_len == 14:
-            # Linux 2.6+, line referring to a disk
-            name = fields[2]
-            (reads, reads_merged, rbytes, rtime, writes, writes_merged,
-                wbytes, wtime, _, busy_time, _) = map(int, fields[3:14])
-        elif fields_len == 7:
-            # Linux 2.6+, line referring to a partition
-            name = fields[2]
-            reads, rbytes, writes, wbytes = map(int, fields[3:])
-            rtime = wtime = reads_merged = writes_merged = busy_time = 0
-        else:
-            raise ValueError("not sure how to interpret line %r" % line)
+        with open_text(f"{get_procfs_path()}/diskstats") as f:
+            lines = f.readlines()
+        for line in lines:
+            fields = line.split()
+            flen = len(fields)
+            # fmt: off
+            if flen == 15:
+                # Linux 2.4
+                name = fields[3]
+                reads = int(fields[2])
+                (reads_merged, rbytes, rtime, writes, writes_merged,
+                    wbytes, wtime, _, busy_time, _) = map(int, fields[4:14])
+            elif flen == 14 or flen >= 18:
+                # Linux 2.6+, line referring to a disk
+                name = fields[2]
+                (reads, reads_merged, rbytes, rtime, writes, writes_merged,
+                    wbytes, wtime, _, busy_time, _) = map(int, fields[3:14])
+            elif flen == 7:
+                # Linux 2.6+, line referring to a partition
+                name = fields[2]
+                reads, rbytes, writes, wbytes = map(int, fields[3:])
+                rtime = wtime = reads_merged = writes_merged = busy_time = 0
+            else:
+                msg = f"not sure how to interpret line {line!r}"
+                raise ValueError(msg)
+            yield (name, reads, writes, rbytes, wbytes, rtime, wtime,
+                   reads_merged, writes_merged, busy_time)
+            # fmt: on
+
+    def read_sysfs():
+        for block in os.listdir('/sys/block'):
+            for root, _, files in os.walk(os.path.join('/sys/block', block)):
+                if 'stat' not in files:
+                    continue
+                with open_text(os.path.join(root, 'stat')) as f:
+                    fields = f.read().strip().split()
+                name = os.path.basename(root)
+                # fmt: off
+                (reads, reads_merged, rbytes, rtime, writes, writes_merged,
+                    wbytes, wtime, _, busy_time) = map(int, fields[:10])
+                yield (name, reads, writes, rbytes, wbytes, rtime,
+                       wtime, reads_merged, writes_merged, busy_time)
+                # fmt: on
+
+    if os.path.exists(f"{get_procfs_path()}/diskstats"):
+        gen = read_procfs()
+    elif os.path.exists('/sys/block'):
+        gen = read_sysfs()
+    else:
+        msg = (
+            f"{get_procfs_path()}/diskstats nor /sys/block are available on"
+            " this system"
+        )
+        raise NotImplementedError(msg)
+
+    retdict = {}
+    for entry in gen:
+        # fmt: off
+        (name, reads, writes, rbytes, wbytes, rtime, wtime, reads_merged,
+            writes_merged, busy_time) = entry
+        if not perdisk and not is_storage_device(name):
+            # perdisk=False means we want to calculate totals so we skip
+            # partitions (e.g. 'sda1', 'nvme0n1p1') and only include
+            # base disk devices (e.g. 'sda', 'nvme0n1'). Base disks
+            # include a total of all their partitions + some extra size
+            # of their own:
+            #     $ cat /proc/diskstats
+            #     259       0 sda 10485760 ...
+            #     259       1 sda1 5186039 ...
+            #     259       1 sda2 5082039 ...
+            # See:
+            # https://github.com/giampaolo/psutil/pull/1313
+            continue
+
+        rbytes *= DISK_SECTOR_SIZE
+        wbytes *= DISK_SECTOR_SIZE
+        retdict[name] = (reads, writes, rbytes, wbytes, rtime, wtime,
+                         reads_merged, writes_merged, busy_time)
+        # fmt: on
 
-        if name in partitions:
-            rbytes = rbytes * SECTOR_SIZE
-            wbytes = wbytes * SECTOR_SIZE
-            retdict[name] = (reads, writes, rbytes, wbytes, rtime, wtime,
-                             reads_merged, writes_merged, busy_time)
     return retdict
 
 
+class RootFsDeviceFinder:
+    """disk_partitions() may return partitions with device == "/dev/root"
+    or "rootfs". This container class uses different strategies to try to
+    obtain the real device path. Resources:
+    https://bootlin.com/blog/find-root-device/
+    https://www.systutorials.com/how-to-find-the-disk-where-root-is-on-in-bash-on-linux/.
+    """
+
+    __slots__ = ['major', 'minor']
+
+    def __init__(self):
+        dev = os.stat("/").st_dev
+        self.major = os.major(dev)
+        self.minor = os.minor(dev)
+
+    def ask_proc_partitions(self):
+        with open_text(f"{get_procfs_path()}/partitions") as f:
+            for line in f.readlines()[2:]:
+                fields = line.split()
+                if len(fields) < 4:  # just for extra safety
+                    continue
+                major = int(fields[0]) if fields[0].isdigit() else None
+                minor = int(fields[1]) if fields[1].isdigit() else None
+                name = fields[3]
+                if major == self.major and minor == self.minor:
+                    if name:  # just for extra safety
+                        return f"/dev/{name}"
+
+    def ask_sys_dev_block(self):
+        path = f"/sys/dev/block/{self.major}:{self.minor}/uevent"
+        with open_text(path) as f:
+            for line in f:
+                if line.startswith("DEVNAME="):
+                    # just for extra safety
+                    if name := line.strip().rpartition("DEVNAME=")[2]:
+                        return f"/dev/{name}"
+
+    def ask_sys_class_block(self):
+        needle = f"{self.major}:{self.minor}"
+        files = glob.iglob("/sys/class/block/*/dev")
+        for file in files:
+            try:
+                f = open_text(file)
+            except FileNotFoundError:  # race condition
+                continue
+            else:
+                with f:
+                    data = f.read().strip()
+                    if data == needle:
+                        name = os.path.basename(os.path.dirname(file))
+                        return f"/dev/{name}"
+
+    def find(self):
+        path = None
+        if path is None:
+            try:
+                path = self.ask_proc_partitions()
+            except OSError as err:
+                debug(err)
+        if path is None:
+            try:
+                path = self.ask_sys_dev_block()
+            except OSError as err:
+                debug(err)
+        if path is None:
+            try:
+                path = self.ask_sys_class_block()
+            except OSError as err:
+                debug(err)
+        # We use exists() because the "/dev/*" part of the path is hard
+        # coded, so we want to be sure.
+        if path is not None and os.path.exists(path):
+            return path
+
+
 def disk_partitions(all=False):
-    """Return mounted disk partitions as a list of namedtuples"""
+    """Return mounted disk partitions as a list of named tuples."""
     fstypes = set()
-    with open_text("%s/filesystems" % get_procfs_path()) as f:
-        for line in f:
-            line = line.strip()
-            if not line.startswith("nodev"):
-                fstypes.add(line.strip())
-            else:
-                # ignore all lines starting with "nodev" except "nodev zfs"
-                fstype = line.split("\t")[1]
-                if fstype == "zfs":
-                    fstypes.add("zfs")
+    procfs_path = get_procfs_path()
+
+    def fstypes_from_filesystems():
+        with open_text(f"{procfs_path}/filesystems") as f:
+            for line in f:
+                line = line.strip()
+                if not line.startswith("nodev"):
+                    fstypes.add(line.strip())
+                else:
+                    # ignore all lines starting with "nodev" except "nodev zfs"
+                    fstype = line.split("\t")[1]
+                    if fstype == "zfs":
+                        fstypes.add("zfs")
+        return fstypes
+
+    def fstypes_from_mountinfo():
+        with open_text(f"{procfs_path}/self/mountinfo") as f:
+            for line in f:
+                line = line.strip().split()
+                if len(line) > 1:
+                    for i in range(len(line) - 1):
+                        if line[i] == "-":
+                            fstypes.add(line[i + 1])
+        return fstypes
+
+    if not all:
+        try:
+            fstypes = fstypes_from_filesystems()
+        except PermissionError:
+            fstypes = fstypes_from_mountinfo()
+
+    # See: https://github.com/giampaolo/psutil/issues/1307
+    if procfs_path == "/proc" and os.path.isfile('/etc/mtab'):
+        mounts_path = os.path.realpath("/etc/mtab")
+    else:
+        mounts_path = os.path.realpath(f"{procfs_path}/self/mounts")
 
     retlist = []
-    partitions = cext.disk_partitions()
+    partitions = _psutil.disk_partitions(mounts_path)
     for partition in partitions:
         device, mountpoint, fstype, opts = partition
         if device == 'none':
             device = ''
+        if device in {"/dev/root", "rootfs"}:
+            device = RootFsDeviceFinder().find() or device
         if not all:
-            if device == '' or fstype not in fstypes:
+            if not device or fstype not in fstypes:
                 continue
-        ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
+        ntuple = ntp.sdiskpart(device, mountpoint, fstype, opts)
         retlist.append(ntuple)
+
     return retlist
 
 
+# =====================================================================
+# --- sensors
+# =====================================================================
+
+
+def sensors_temperatures():
+    """Return hardware (CPU and others) temperatures as a dict
+    including hardware name, label, current, max and critical
+    temperatures.
+
+    Implementation notes:
+    - /sys/class/hwmon looks like the most recent interface to
+      retrieve this info, and this implementation relies on it
+      only (old distros will probably use something else)
+    - lm-sensors on Ubuntu 16.04 relies on /sys/class/hwmon
+    - /sys/class/thermal/thermal_zone* is another one but it's more
+      difficult to parse
+    """
+    ret = collections.defaultdict(list)
+    basenames = glob.glob('/sys/class/hwmon/hwmon*/temp*_*')
+    # CentOS has an intermediate /device directory:
+    # https://github.com/giampaolo/psutil/issues/971
+    # https://github.com/nicolargo/glances/issues/1060
+    basenames.extend(glob.glob('/sys/class/hwmon/hwmon*/device/temp*_*'))
+    basenames = sorted({x.split('_')[0] for x in basenames})
+
+    # Only add the coretemp hwmon entries if they're not already in
+    # /sys/class/hwmon/
+    # https://github.com/giampaolo/psutil/issues/1708
+    # https://github.com/giampaolo/psutil/pull/1648
+    basenames2 = glob.glob(
+        '/sys/devices/platform/coretemp.*/hwmon/hwmon*/temp*_*'
+    )
+    repl = re.compile(r"/sys/devices/platform/coretemp.*/hwmon/")
+    for name in basenames2:
+        altname = repl.sub('/sys/class/hwmon/', name)
+        if altname not in basenames:
+            basenames.append(name)
+
+    for base in basenames:
+        try:
+            path = base + '_input'
+            current = float(bcat(path)) / 1000.0
+            path = os.path.join(os.path.dirname(base), 'name')
+            unit_name = cat(path).strip()
+        except (OSError, ValueError):
+            # A lot of things can go wrong here, so let's just skip the
+            # whole entry. Sure thing is Linux's /sys/class/hwmon really
+            # is a stinky broken mess.
+            # https://github.com/giampaolo/psutil/issues/1009
+            # https://github.com/giampaolo/psutil/issues/1101
+            # https://github.com/giampaolo/psutil/issues/1129
+            # https://github.com/giampaolo/psutil/issues/1245
+            # https://github.com/giampaolo/psutil/issues/1323
+            continue
+
+        high = bcat(base + '_max', fallback=None)
+        critical = bcat(base + '_crit', fallback=None)
+        label = cat(base + '_label', fallback='').strip()
+
+        if high is not None:
+            try:
+                high = float(high) / 1000.0
+            except ValueError:
+                high = None
+        if critical is not None:
+            try:
+                critical = float(critical) / 1000.0
+            except ValueError:
+                critical = None
+
+        ret[unit_name].append((label, current, high, critical))
+
+    # Indication that no sensors were detected in /sys/class/hwmon/
+    if not basenames:
+        basenames = glob.glob('/sys/class/thermal/thermal_zone*')
+        basenames = sorted(set(basenames))
+
+        for base in basenames:
+            try:
+                path = os.path.join(base, 'temp')
+                current = float(bcat(path)) / 1000.0
+                path = os.path.join(base, 'type')
+                unit_name = cat(path).strip()
+            except (OSError, ValueError) as err:
+                debug(err)
+                continue
+
+            trip_paths = glob.glob(base + '/trip_point*')
+            trip_points = {
+                '_'.join(os.path.basename(p).split('_')[0:3])
+                for p in trip_paths
+            }
+            critical = None
+            high = None
+            for trip_point in trip_points:
+                path = os.path.join(base, trip_point + "_type")
+                trip_type = cat(path, fallback='').strip()
+                if trip_type == 'critical':
+                    critical = bcat(
+                        os.path.join(base, trip_point + "_temp"), fallback=None
+                    )
+                elif trip_type == 'high':
+                    high = bcat(
+                        os.path.join(base, trip_point + "_temp"), fallback=None
+                    )
+
+                if high is not None:
+                    try:
+                        high = float(high) / 1000.0
+                    except ValueError:
+                        high = None
+                if critical is not None:
+                    try:
+                        critical = float(critical) / 1000.0
+                    except ValueError:
+                        critical = None
+
+            ret[unit_name].append(('', current, high, critical))
+
+    return dict(ret)
+
+
+def sensors_fans():
+    """Return hardware fans info (for CPU and other peripherals) as a
+    dict including hardware label and current speed.
+
+    Implementation notes:
+    - /sys/class/hwmon looks like the most recent interface to
+      retrieve this info, and this implementation relies on it
+      only (old distros will probably use something else)
+    - lm-sensors on Ubuntu 16.04 relies on /sys/class/hwmon
+    """
+    ret = collections.defaultdict(list)
+    basenames = glob.glob('/sys/class/hwmon/hwmon*/fan*_*')
+    if not basenames:
+        # CentOS has an intermediate /device directory:
+        # https://github.com/giampaolo/psutil/issues/971
+        basenames = glob.glob('/sys/class/hwmon/hwmon*/device/fan*_*')
+
+    basenames = sorted({x.split("_")[0] for x in basenames})
+    for base in basenames:
+        try:
+            current = int(bcat(base + '_input'))
+        except OSError as err:
+            debug(err)
+            continue
+        unit_name = cat(os.path.join(os.path.dirname(base), 'name')).strip()
+        label = cat(base + '_label', fallback='').strip()
+        ret[unit_name].append(ntp.sfan(label, current))
+
+    return dict(ret)
+
+
+def sensors_battery():
+    """Return battery information.
+    Implementation note: it appears /sys/class/power_supply/BAT0/
+    directory structure may vary and provide files with the same
+    meaning but under different names, see:
+    https://github.com/giampaolo/psutil/issues/966.
+    """
+    null = object()
+
+    def multi_bcat(*paths):
+        """Attempt to read the content of multiple files which may
+        not exist. If none of them exist return None.
+        """
+        for path in paths:
+            ret = bcat(path, fallback=null)
+            if ret != null:
+                try:
+                    return int(ret)
+                except ValueError:
+                    return ret.strip()
+        return None
+
+    bats = [
+        x
+        for x in os.listdir(POWER_SUPPLY_PATH)
+        if x.startswith('BAT') or 'battery' in x.lower()
+    ]
+    if not bats:
+        return None
+    # Get the first available battery. Usually this is "BAT0", except
+    # some rare exceptions:
+    # https://github.com/giampaolo/psutil/issues/1238
+    root = os.path.join(POWER_SUPPLY_PATH, min(bats))
+
+    # Base metrics.
+    energy_now = multi_bcat(root + "/energy_now", root + "/charge_now")
+    power_now = multi_bcat(root + "/power_now", root + "/current_now")
+    energy_full = multi_bcat(root + "/energy_full", root + "/charge_full")
+    time_to_empty = multi_bcat(root + "/time_to_empty_now")
+
+    # Percent. If we have energy_full the percentage will be more
+    # accurate compared to reading /capacity file (float vs. int).
+    if energy_full is not None and energy_now is not None:
+        try:
+            percent = 100.0 * energy_now / energy_full
+        except ZeroDivisionError:
+            percent = 0.0
+    else:
+        percent = float(cat(root + "/capacity", fallback=-1))
+        if percent == -1:
+            return None
+
+    # Is AC power cable plugged in?
+    # Note: AC0 is not always available and sometimes (e.g. CentOS7)
+    # it's called "AC".
+    power_plugged = None
+    online = multi_bcat(
+        os.path.join(POWER_SUPPLY_PATH, "AC0/online"),
+        os.path.join(POWER_SUPPLY_PATH, "AC/online"),
+    )
+    if online is not None:
+        power_plugged = online == 1
+    else:
+        status = cat(root + "/status", fallback="").strip().lower()
+        if status == "discharging":
+            power_plugged = False
+        elif status in {"charging", "full"}:
+            power_plugged = True
+
+    # Seconds left.
+    if power_plugged:
+        secsleft = BatteryTime.POWER_TIME_UNLIMITED
+    elif energy_now is not None and power_now is not None:
+        try:
+            secsleft = int(energy_now / abs(power_now) * 3600)
+        except ZeroDivisionError:
+            secsleft = BatteryTime.POWER_TIME_UNKNOWN
+    elif time_to_empty is not None:
+        secsleft = int(time_to_empty * 60)
+        if secsleft < 0:
+            secsleft = BatteryTime.POWER_TIME_UNKNOWN
+    else:
+        secsleft = BatteryTime.POWER_TIME_UNKNOWN
+
+    return ntp.sbattery(percent, secsleft, power_plugged)
+
+
 # =====================================================================
 # --- other system functions
 # =====================================================================
 
 
 def users():
-    """Return currently connected users as a list of namedtuples."""
+    """Return currently connected users as a list of named tuples."""
     retlist = []
-    rawlist = cext.users()
+    rawlist = _psutil.users()
     for item in rawlist:
-        user, tty, hostname, tstamp, user_process = item
-        # note: the underlying C function includes entries about
-        # system boot, run level and others.  We might want
-        # to use them in the future.
-        if not user_process:
-            continue
-        if hostname == ':0.0' or hostname == ':0':
-            hostname = 'localhost'
-        nt = _common.suser(user, tty or None, hostname, tstamp)
+        user, tty, hostname, tstamp, pid = item
+        nt = ntp.suser(user, tty or None, hostname, tstamp, pid)
         retlist.append(nt)
     return retlist
 
 
 def boot_time():
     """Return the system boot time expressed in seconds since the epoch."""
-    global BOOT_TIME
-    with open_binary('%s/stat' % get_procfs_path()) as f:
+    path = f"{get_procfs_path()}/stat"
+    with open_binary(path) as f:
         for line in f:
             if line.startswith(b'btime'):
-                ret = float(line.strip().split()[1])
-                BOOT_TIME = ret
-                return ret
-        raise RuntimeError(
-            "line 'btime' not found in %s/stat" % get_procfs_path())
+                return float(line.strip().split()[1])
+        msg = f"line 'btime' not found in {path}"
+        raise RuntimeError(msg)
 
 
 # =====================================================================
@@ -944,175 +1546,345 @@ def boot_time():
 
 def pids():
     """Returns a list of PIDs currently running on the system."""
-    return [int(x) for x in os.listdir(b(get_procfs_path())) if x.isdigit()]
+    path = get_procfs_path().encode(ENCODING)
+    return [int(x) for x in os.listdir(path) if x.isdigit()]
 
 
 def pid_exists(pid):
-    """Check For the existence of a unix pid."""
-    return _psposix.pid_exists(pid)
+    """Check for the existence of a unix PID. Linux TIDs are not
+    supported (always return False).
+    """
+    if not _psposix.pid_exists(pid):
+        return False
+    else:
+        # Linux's apparently does not distinguish between PIDs and TIDs
+        # (thread IDs).
+        # listdir("/proc") won't show any TID (only PIDs) but
+        # os.stat("/proc/{tid}") will succeed if {tid} exists.
+        # os.kill() can also be passed a TID. This is quite confusing.
+        # In here we want to enforce this distinction and support PIDs
+        # only, see:
+        # https://github.com/giampaolo/psutil/issues/687
+        try:
+            # Note: already checked that this is faster than using a
+            # regular expr. Also (a lot) faster than doing
+            # 'return pid in pids()'
+            path = f"{get_procfs_path()}/{pid}/status"
+            with open_binary(path) as f:
+                for line in f:
+                    if line.startswith(b"Tgid:"):
+                        tgid = int(line.split()[1])
+                        # If tgid and pid are the same then we're
+                        # dealing with a process PID.
+                        return tgid == pid
+                msg = f"'Tgid' line not found in {path}"
+                raise ValueError(msg)
+        except (OSError, ValueError):
+            return pid in pids()
+
+
+def ppid_map():
+    """Obtain a {pid: ppid, ...} dict for all running processes in
+    one shot. Used to speed up Process.children().
+    """
+    ret = {}
+    procfs_path = get_procfs_path()
+    for pid in pids():
+        try:
+            with open_binary(f"{procfs_path}/{pid}/stat") as f:
+                data = f.read()
+        except (FileNotFoundError, ProcessLookupError):
+            pass
+        except PermissionError as err:
+            raise AccessDenied(pid) from err
+        else:
+            rpar = data.rfind(b')')
+            dset = data[rpar + 2 :].split()
+            ppid = int(dset[1])
+            ret[pid] = ppid
+    return ret
 
 
 def wrap_exceptions(fun):
-    """Decorator which translates bare OSError and IOError exceptions
-    into NoSuchProcess and AccessDenied.
+    """Decorator which translates bare OSError exceptions into
+    NoSuchProcess and AccessDenied.
     """
+
     @functools.wraps(fun)
     def wrapper(self, *args, **kwargs):
+        pid, name = self.pid, self._name
         try:
             return fun(self, *args, **kwargs)
-        except EnvironmentError as err:
-            # ENOENT (no such file or directory) gets raised on open().
-            # ESRCH (no such process) can get raised on read() if
-            # process is gone in meantime.
-            if err.errno in (errno.ENOENT, errno.ESRCH):
-                raise NoSuchProcess(self.pid, self._name)
-            if err.errno in (errno.EPERM, errno.EACCES):
-                raise AccessDenied(self.pid, self._name)
+        except PermissionError as err:
+            raise AccessDenied(pid, name) from err
+        except ProcessLookupError as err:
+            self._raise_if_zombie()
+            raise NoSuchProcess(pid, name) from err
+        except FileNotFoundError as err:
+            self._raise_if_zombie()
+            # /proc/PID directory may still exist, but the files within
+            # it may not, indicating the process is gone, see:
+            # https://github.com/giampaolo/psutil/issues/2418
+            if not os.path.exists(f"{self._procfs_path}/{pid}/stat"):
+                raise NoSuchProcess(pid, name) from err
             raise
+
     return wrapper
 
 
-class Process(object):
+class Process:
     """Linux process implementation."""
 
-    __slots__ = ["pid", "_name", "_ppid", "_procfs_path"]
+    __slots__ = [
+        "_cache",
+        "_ctime",
+        "_name",
+        "_ppid",
+        "_procfs_path",
+        "pid",
+    ]
 
     def __init__(self, pid):
         self.pid = pid
         self._name = None
         self._ppid = None
+        self._ctime = None
         self._procfs_path = get_procfs_path()
 
+    def _is_zombie(self):
+        # Note: most of the times Linux is able to return info about the
+        # process even if it's a zombie, and /proc/{pid} will exist.
+        # There are some exceptions though, like exe(), cmdline() and
+        # memory_maps(). In these cases /proc/{pid}/{file} exists but
+        # it's empty. Instead of returning a "null" value we'll raise an
+        # exception.
+        try:
+            data = bcat(f"{self._procfs_path}/{self.pid}/stat")
+        except OSError:
+            return False
+        else:
+            rpar = data.rfind(b')')
+            status = data[rpar + 2 : rpar + 3]
+            return status == b"Z"
+
+    def _raise_if_zombie(self):
+        if self._is_zombie():
+            raise ZombieProcess(self.pid, self._name, self._ppid)
+
+    def _raise_if_not_alive(self):
+        """Raise NSP if the process disappeared on us."""
+        # For those C function who do not raise NSP, possibly returning
+        # incorrect or incomplete result.
+        os.stat(f"{self._procfs_path}/{self.pid}")
+
+    def _readlink(self, path, fallback=UNSET):
+        # * https://github.com/giampaolo/psutil/issues/503
+        #   os.readlink('/proc/pid/exe') may raise ESRCH (ProcessLookupError)
+        #   instead of ENOENT (FileNotFoundError) when it races.
+        # * ENOENT may occur also if the path actually exists if PID is
+        #   a low PID (~0-20 range).
+        # * https://github.com/giampaolo/psutil/issues/2514
+        try:
+            return readlink(path)
+        except (FileNotFoundError, ProcessLookupError):
+            if os.path.lexists(f"{self._procfs_path}/{self.pid}"):
+                self._raise_if_zombie()
+                if fallback is not UNSET:
+                    return fallback
+            raise
+
+    @wrap_exceptions
+    @memoize_when_activated
     def _parse_stat_file(self):
-        """Parse /proc/{pid}/stat file. Return a list of fields where
-        process name is in position 0.
+        """Parse /proc/{pid}/stat file and return a dict with various
+        process info.
         Using "man proc" as a reference: where "man proc" refers to
-        position N, always subscract 2 (e.g starttime pos 22 in
-        'man proc' == pos 20 in the list returned here).
+        position N always subtract 3 (e.g ppid position 4 in
+        'man proc' == position 1 in here).
+        The return value is cached in case oneshot() ctx manager is
+        in use.
         """
-        with open_binary("%s/%s/stat" % (self._procfs_path, self.pid)) as f:
-            data = f.read()
+        data = bcat(f"{self._procfs_path}/{self.pid}/stat")
         # Process name is between parentheses. It can contain spaces and
         # other parentheses. This is taken into account by looking for
-        # the first occurrence of "(" and the last occurence of ")".
+        # the first occurrence of "(" and the last occurrence of ")".
         rpar = data.rfind(b')')
-        name = data[data.find(b'(') + 1:rpar]
-        fields_after_name = data[rpar + 2:].split()
-        return [name] + fields_after_name
+        name = data[data.find(b'(') + 1 : rpar]
+        fields = data[rpar + 2 :].split()
+
+        ret = {}
+        ret['name'] = name
+        ret['status'] = fields[0]
+        ret['ppid'] = fields[1]
+        ret['ttynr'] = fields[4]
+        ret['minflt'] = fields[7]
+        ret['majflt'] = fields[9]
+        ret['utime'] = fields[11]
+        ret['stime'] = fields[12]
+        ret['children_utime'] = fields[13]
+        ret['children_stime'] = fields[14]
+        ret['create_time'] = fields[19]
+        ret['cpu_num'] = fields[36]
+        try:
+            ret['blkio_ticks'] = fields[39]  # aka 'delayacct_blkio_ticks'
+        except IndexError:
+            # https://github.com/giampaolo/psutil/issues/2455
+            debug("can't get blkio_ticks, set iowait to 0")
+            ret['blkio_ticks'] = 0
 
+        return ret
+
+    @wrap_exceptions
+    @memoize_when_activated
     def _read_status_file(self):
-        with open_binary("%s/%s/status" % (self._procfs_path, self.pid)) as f:
+        """Read /proc/{pid}/stat file and return its content.
+        The return value is cached in case oneshot() ctx manager is
+        in use.
+        """
+        with open_binary(f"{self._procfs_path}/{self.pid}/status") as f:
             return f.read()
 
+    @wrap_exceptions
+    @memoize_when_activated
     def _read_smaps_file(self):
-        with open_binary("%s/%s/smaps" % (self._procfs_path, self.pid),
-                         buffering=BIGGER_FILE_BUFFERING) as f:
+        with open_binary(f"{self._procfs_path}/{self.pid}/smaps") as f:
             return f.read().strip()
 
+    def oneshot_enter(self):
+        self._parse_stat_file.cache_activate(self)
+        self._read_status_file.cache_activate(self)
+        self._read_smaps_file.cache_activate(self)
+
+    def oneshot_exit(self):
+        self._parse_stat_file.cache_deactivate(self)
+        self._read_status_file.cache_deactivate(self)
+        self._read_smaps_file.cache_deactivate(self)
+
     @wrap_exceptions
     def name(self):
-        name = self._parse_stat_file()[0]
-        if PY3:
-            name = decode(name)
         # XXX - gets changed later and probably needs refactoring
-        return name
+        return decode(self._parse_stat_file()['name'])
 
+    @wrap_exceptions
     def exe(self):
-        try:
-            return readlink("%s/%s/exe" % (self._procfs_path, self.pid))
-        except OSError as err:
-            if err.errno in (errno.ENOENT, errno.ESRCH):
-                # no such file error; might be raised also if the
-                # path actually exists for system processes with
-                # low pids (about 0-20)
-                if os.path.lexists("%s/%s" % (self._procfs_path, self.pid)):
-                    return ""
-                else:
-                    if not pid_exists(self.pid):
-                        raise NoSuchProcess(self.pid, self._name)
-                    else:
-                        raise ZombieProcess(self.pid, self._name, self._ppid)
-            if err.errno in (errno.EPERM, errno.EACCES):
-                raise AccessDenied(self.pid, self._name)
-            raise
+        return self._readlink(
+            f"{self._procfs_path}/{self.pid}/exe", fallback=""
+        )
 
     @wrap_exceptions
     def cmdline(self):
-        with open_text("%s/%s/cmdline" % (self._procfs_path, self.pid)) as f:
+        with open_text(f"{self._procfs_path}/{self.pid}/cmdline") as f:
             data = f.read()
         if not data:
             # may happen in case of zombie process
+            self._raise_if_zombie()
             return []
-        if data.endswith('\x00'):
+        # 'man proc' states that args are separated by null bytes '\0'
+        # and last char is supposed to be a null byte. Nevertheless
+        # some processes may change their cmdline after being started
+        # (via setproctitle() or similar), they are usually not
+        # compliant with this rule and use spaces instead. Google
+        # Chrome process is an example. See:
+        # https://github.com/giampaolo/psutil/issues/1179
+        sep = '\x00' if data.endswith('\x00') else ' '
+        if data.endswith(sep):
             data = data[:-1]
-        return [x for x in data.split('\x00')]
+        cmdline = data.split(sep)
+        # Sometimes last char is a null byte '\0' but the args are
+        # separated by spaces, see: https://github.com/giampaolo/psutil/
+        # issues/1179#issuecomment-552984549
+        if sep == '\x00' and len(cmdline) == 1 and ' ' in data:
+            cmdline = data.split(' ')
+        return cmdline
 
     @wrap_exceptions
     def environ(self):
-        with open_text("%s/%s/environ" % (self._procfs_path, self.pid)) as f:
+        with open_text(f"{self._procfs_path}/{self.pid}/environ") as f:
             data = f.read()
         return parse_environ_block(data)
 
     @wrap_exceptions
     def terminal(self):
-        tty_nr = int(self._parse_stat_file()[5])
-        tmap = _psposix.get_terminal_map()
-        try:
-            return tmap[tty_nr]
-        except KeyError:
+        tty_nr = int(self._parse_stat_file()['ttynr'])
+        if tty_nr == 0:
             return None
+        return _psposix.get_terminal(tty_nr)
+
+    # May not be available on old kernels.
+    if os.path.exists(f"/proc/{os.getpid()}/io"):
 
-    if os.path.exists('/proc/%s/io' % os.getpid()):
         @wrap_exceptions
         def io_counters(self):
-            fname = "%s/%s/io" % (self._procfs_path, self.pid)
+            fname = f"{self._procfs_path}/{self.pid}/io"
+            fields = {}
             with open_binary(fname) as f:
-                rcount = wcount = rbytes = wbytes = None
                 for line in f:
-                    if rcount is None and line.startswith(b"syscr"):
-                        rcount = int(line.split()[1])
-                    elif wcount is None and line.startswith(b"syscw"):
-                        wcount = int(line.split()[1])
-                    elif rbytes is None and line.startswith(b"read_bytes"):
-                        rbytes = int(line.split()[1])
-                    elif wbytes is None and line.startswith(b"write_bytes"):
-                        wbytes = int(line.split()[1])
-                for x in (rcount, wcount, rbytes, wbytes):
-                    if x is None:
-                        raise NotImplementedError(
-                            "couldn't read all necessary info from %r" % fname)
-                return _common.pio(rcount, wcount, rbytes, wbytes)
-    else:
-        def io_counters(self):
-            raise NotImplementedError("couldn't find /proc/%s/io (kernel "
-                                      "too old?)" % self.pid)
+                    # https://github.com/giampaolo/psutil/issues/1004
+                    line = line.strip()
+                    if line:
+                        try:
+                            name, value = line.split(b': ')
+                        except ValueError:
+                            # https://github.com/giampaolo/psutil/issues/1004
+                            continue
+                        else:
+                            fields[name] = int(value)
+            if not fields:
+                msg = f"{fname} file was empty"
+                raise RuntimeError(msg)
+            try:
+                return ntp.pio(
+                    fields[b'syscr'],  # read syscalls
+                    fields[b'syscw'],  # write syscalls
+                    fields[b'read_bytes'],  # read bytes
+                    fields[b'write_bytes'],  # write bytes
+                    fields[b'rchar'],  # read chars
+                    fields[b'wchar'],  # write chars
+                )
+            except KeyError as err:
+                msg = (
+                    f"{err.args[0]!r} field was not found in {fname}; found"
+                    f" fields are {fields!r}"
+                )
+                raise ValueError(msg) from None
 
     @wrap_exceptions
     def cpu_times(self):
         values = self._parse_stat_file()
-        utime = float(values[12]) / CLOCK_TICKS
-        stime = float(values[13]) / CLOCK_TICKS
-        children_utime = float(values[14]) / CLOCK_TICKS
-        children_stime = float(values[15]) / CLOCK_TICKS
-        return _common.pcputimes(utime, stime, children_utime, children_stime)
+        utime = float(values['utime']) / CLOCK_TICKS
+        stime = float(values['stime']) / CLOCK_TICKS
+        children_utime = float(values['children_utime']) / CLOCK_TICKS
+        children_stime = float(values['children_stime']) / CLOCK_TICKS
+        iowait = float(values['blkio_ticks']) / CLOCK_TICKS
+        return ntp.pcputimes(
+            utime, stime, children_utime, children_stime, iowait
+        )
+
+    @wrap_exceptions
+    def cpu_num(self):
+        """What CPU the process is on."""
+        return int(self._parse_stat_file()['cpu_num'])
 
     @wrap_exceptions
     def wait(self, timeout=None):
-        try:
-            return _psposix.wait_pid(self.pid, timeout)
-        except _psposix.TimeoutExpired:
-            raise TimeoutExpired(timeout, self.pid, self._name)
+        return _psposix.wait_pid(self.pid, timeout)
 
     @wrap_exceptions
-    def create_time(self):
-        values = self._parse_stat_file()
-        # According to documentation, starttime is in field 21 and the
-        # unit is jiffies (clock ticks).
-        # We first divide it for clock ticks and then add uptime returning
-        # seconds since the epoch, in UTC.
-        # Also use cached value if available.
-        bt = BOOT_TIME or boot_time()
-        return (float(values[20]) / CLOCK_TICKS) + bt
+    def create_time(self, monotonic=False):
+        # The 'starttime' field in /proc/[pid]/stat is expressed in
+        # jiffies (clock ticks per second), a relative value which
+        # represents the number of clock ticks that have passed since
+        # the system booted until the process was created. It never
+        # changes and is unaffected by system clock updates.
+        if self._ctime is None:
+            self._ctime = (
+                float(self._parse_stat_file()['create_time']) / CLOCK_TICKS
+            )
+        if monotonic:
+            return self._ctime
+        # Add the boot time, returning time expressed in seconds since
+        # the epoch. This is subject to system clock updates.
+        return self._ctime + boot_time()
 
     @wrap_exceptions
     def memory_info(self):
@@ -1127,26 +1899,80 @@ def memory_info(self):
         # | data   | data + stack                        | drs  | DATA |
         # | dirty  | dirty pages (unused in Linux 2.6)   | dt   |      |
         #  ============================================================
-        with open_binary("%s/%s/statm" % (self._procfs_path, self.pid)) as f:
-            vms, rss, shared, text, lib, data, dirty = \
-                [int(x) * PAGESIZE for x in f.readline().split()[:7]]
-        return pmem(rss, vms, shared, text, lib, data, dirty)
+        with open_binary(f"{self._procfs_path}/{self.pid}/statm") as f:
+            vms, rss, shared, text, _lib, data, _dirty = (
+                int(x) * PAGESIZE for x in f.readline().split()[:7]
+            )
+        return ntp.pmem(rss, vms, shared, text, data)
 
-    # /proc/pid/smaps does not exist on kernels < 2.6.14 or if
-    # CONFIG_MMU kernel configuration option is not enabled.
-    if HAS_SMAPS:
+    @wrap_exceptions
+    def memory_extras(
+        self,
+        _vmpeak_re=re.compile(br"VmPeak:\s+(\d+)"),
+        _vmhwm_re=re.compile(br"VmHWM:\s+(\d+)"),
+        _rssanon_re=re.compile(br"RssAnon:\s+(\d+)"),
+        _rssfile_re=re.compile(br"RssFile:\s+(\d+)"),
+        _rssshmem_re=re.compile(br"RssShmem:\s+(\d+)"),
+        _vmswap_re=re.compile(br"VmSwap:\s+(\d+)"),
+        _hugetlb_re=re.compile(br"HugetlbPages:\s+(\d+)"),
+    ):
+        # Read /proc/{pid}/status.
+        # RssAnon/RssFile/RssShmem were added in Linux 4.5;
+        # VmSwap in 2.6.34; HugetlbPages in 4.4.
+        data = self._read_status_file()
+
+        def parse(regex):
+            m = regex.search(data)
+            return int(m.group(1)) * 1024 if m else 0
+
+        return ntp.pmem_extras(
+            peak_rss=parse(_vmhwm_re),
+            peak_vms=parse(_vmpeak_re),
+            rss_anon=parse(_rssanon_re),
+            rss_file=parse(_rssfile_re),
+            rss_shmem=parse(_rssshmem_re),
+            swap_anon=parse(_vmswap_re),
+            hugetlb=parse(_hugetlb_re),
+        )
+
+    if HAS_PROC_SMAPS_ROLLUP or HAS_PROC_SMAPS:
+
+        def _parse_smaps_rollup(self):
+            # /proc/pid/smaps_rollup was added to Linux in 2017. Faster
+            # than /proc/pid/smaps. It reports higher PSS than */smaps
+            # (from 1k up to 200k higher; tested against all processes).
+            # IMPORTANT: /proc/pid/smaps_rollup is weird, because it
+            # raises ESRCH / ENOENT for many PIDs, even if they're alive
+            # (also as root). In that case we'll use /proc/pid/smaps as
+            # fallback, which is slower but has a +50% success rate
+            # compared to /proc/pid/smaps_rollup.
+            uss = pss = swap = 0
+            with open_binary(
+                f"{self._procfs_path}/{self.pid}/smaps_rollup"
+            ) as f:
+                for line in f:
+                    if line.startswith(b"Private_"):
+                        # Private_Clean, Private_Dirty, Private_Hugetlb
+                        uss += int(line.split()[1]) * 1024
+                    elif line.startswith(b"Pss:"):
+                        pss = int(line.split()[1]) * 1024
+                    elif line.startswith(b"Swap:"):
+                        swap = int(line.split()[1]) * 1024
+            return (uss, pss, swap)
 
         @wrap_exceptions
-        def memory_full_info(
-                self,
-                _private_re=re.compile(b"Private.*:\s+(\d+)"),
-                _pss_re=re.compile(b"Pss.*:\s+(\d+)"),
-                _swap_re=re.compile(b"Swap.*:\s+(\d+)")):
-            basic_mem = self.memory_info()
+        def _parse_smaps(
+            self,
+            # Gets Private_Clean, Private_Dirty, Private_Hugetlb.
+            _private_re=re.compile(br"\nPrivate.*:\s+(\d+)"),
+            _pss_re=re.compile(br"\nPss\:\s+(\d+)"),
+            _swap_re=re.compile(br"\nSwap\:\s+(\d+)"),
+        ):
+            # /proc/pid/smaps does not exist on kernels < 2.6.14 or if
+            # CONFIG_MMU kernel configuration option is not enabled.
+
             # Note: using 3 regexes is faster than reading the file
             # line by line.
-            # XXX: on Python 3 the 2 regexes are 30% slower than on
-            # Python 2 though. Figure out why.
             #
             # You might be tempted to calculate USS by subtracting
             # the "shared" value from the "resident" value in
@@ -1161,19 +1987,33 @@ def memory_full_info(
             uss = sum(map(int, _private_re.findall(smaps_data))) * 1024
             pss = sum(map(int, _pss_re.findall(smaps_data))) * 1024
             swap = sum(map(int, _swap_re.findall(smaps_data))) * 1024
-            return pfullmem(*basic_mem + (uss, pss, swap))
+            return (uss, pss, swap)
 
-    else:
-        memory_full_info = memory_info
+        @wrap_exceptions
+        def memory_footprint(self):
+            def fetch():
+                if HAS_PROC_SMAPS_ROLLUP:  # faster
+                    try:
+                        return self._parse_smaps_rollup()
+                    except (ProcessLookupError, FileNotFoundError):
+                        pass
+                return self._parse_smaps()
+
+            uss, pss, swap = fetch()
+            return ntp.pfootprint(uss, pss, swap)
 
-    if HAS_SMAPS:
+    if HAS_PROC_SMAPS:
 
         @wrap_exceptions
         def memory_maps(self):
             """Return process's mapped memory regions as a list of named
             tuples. Fields are explained in 'man proc'; here is an updated
-            (Apr 2012) version: http://goo.gl/fmebo
+            (Apr 2012) version: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/filesystems/proc.txt?id=b76437579d1344b612cf1851ae610c636cec7db0.
+
+            /proc/{PID}/smaps does not exist on kernels < 2.6.14 or if
+            CONFIG_MMU kernel configuration option is not enabled.
             """
+
             def get_blocks(lines, current_block):
                 data = {}
                 for line in lines:
@@ -1185,18 +2025,19 @@ def get_blocks(lines, current_block):
                     else:
                         try:
                             data[fields[0]] = int(fields[1]) * 1024
-                        except ValueError:
+                        except (ValueError, IndexError):
                             if fields[0].startswith(b'VmFlags:'):
                                 # see issue #369
                                 continue
-                            else:
-                                raise ValueError("don't know how to inte"
-                                                 "rpret line %r" % line)
+                            msg = f"don't know how to interpret line {line!r}"
+                            raise ValueError(msg) from None
                 yield (current_block.pop(), data)
 
             data = self._read_smaps_file()
-            # Note: smaps file can be empty for certain processes.
+            # Note: smaps file can be empty for certain processes or for
+            # zombies.
             if not data:
+                self._raise_if_zombie()
                 return []
             lines = data.split(b'\n')
             ls = []
@@ -1205,22 +2046,23 @@ def get_blocks(lines, current_block):
             for header, data in get_blocks(lines, current_block):
                 hfields = header.split(None, 5)
                 try:
-                    addr, perms, offset, dev, inode, path = hfields
+                    addr, perms, _offset, _dev, _inode, path = hfields
                 except ValueError:
-                    addr, perms, offset, dev, inode, path = \
-                        hfields + ['']
+                    addr, perms, _offset, _dev, _inode, path = hfields + ['']
                 if not path:
                     path = '[anon]'
                 else:
-                    if PY3:
-                        path = decode(path)
+                    path = decode(path)
                     path = path.strip()
-                    if (path.endswith(' (deleted)') and not
-                            path_exists_strict(path)):
+                    if path.endswith(' (deleted)') and not path_exists_strict(
+                        path
+                    ):
                         path = path[:-10]
-                ls.append((
-                    decode(addr), decode(perms), path,
-                    data[b'Rss:'],
+                item = (
+                    decode(addr),
+                    decode(perms),
+                    path,
+                    data.get(b'Rss:', 0),
                     data.get(b'Size:', 0),
                     data.get(b'Pss:', 0),
                     data.get(b'Shared_Clean:', 0),
@@ -1229,200 +2071,221 @@ def get_blocks(lines, current_block):
                     data.get(b'Private_Dirty:', 0),
                     data.get(b'Referenced:', 0),
                     data.get(b'Anonymous:', 0),
-                    data.get(b'Swap:', 0)
-                ))
+                    data.get(b'Swap:', 0),
+                )
+                ls.append(item)
             return ls
 
-    else:
-        def memory_maps(self):
-            raise NotImplementedError(
-                "/proc/%s/smaps does not exist on kernels < 2.6.14 or "
-                "if CONFIG_MMU kernel configuration option is not "
-                "enabled." % self.pid)
+    @wrap_exceptions
+    def page_faults(self):
+        values = self._parse_stat_file()
+        return ntp.ppagefaults(int(values['minflt']), int(values['majflt']))
 
     @wrap_exceptions
     def cwd(self):
-        return readlink("%s/%s/cwd" % (self._procfs_path, self.pid))
+        return self._readlink(
+            f"{self._procfs_path}/{self.pid}/cwd", fallback=""
+        )
 
     @wrap_exceptions
-    def num_ctx_switches(self, _ctxsw_re=re.compile(b'ctxt_switches:\t(\d+)')):
+    def num_ctx_switches(
+        self, _ctxsw_re=re.compile(br'ctxt_switches:\t(\d+)')
+    ):
         data = self._read_status_file()
         ctxsw = _ctxsw_re.findall(data)
         if not ctxsw:
-            raise NotImplementedError(
-                "'voluntary_ctxt_switches' and 'nonvoluntary_ctxt_switches'"
-                "lines were not found in /proc/%s/status; the kernel is "
-                "probably older than 2.6.23" % self.pid)
-        else:
-            return _common.pctxsw(int(ctxsw[0]), int(ctxsw[1]))
+            msg = (
+                "'voluntary_ctxt_switches' and"
+                " 'nonvoluntary_ctxt_switches'lines were not found in"
+                f" {self._procfs_path}/{self.pid}/status; the kernel is"
+                " probably older than 2.6.23"
+            )
+            raise NotImplementedError(msg)
+        return ntp.pctxsw(int(ctxsw[0]), int(ctxsw[1]))
 
     @wrap_exceptions
-    def num_threads(self, _num_threads_re=re.compile(b'Threads:\t(\d+)')):
-        # Note: on Python 3 using a re is faster than iterating over file
-        # line by line. On Python 2 is the exact opposite, and iterating
-        # over a file on Python 3 is slower than on Python 2.
+    def num_threads(self, _num_threads_re=re.compile(br'Threads:\t(\d+)')):
+        # Using a re is faster than iterating over file line by line.
         data = self._read_status_file()
         return int(_num_threads_re.findall(data)[0])
 
     @wrap_exceptions
     def threads(self):
-        thread_ids = os.listdir("%s/%s/task" % (self._procfs_path, self.pid))
+        thread_ids = os.listdir(f"{self._procfs_path}/{self.pid}/task")
         thread_ids.sort()
         retlist = []
         hit_enoent = False
         for thread_id in thread_ids:
-            fname = "%s/%s/task/%s/stat" % (
-                self._procfs_path, self.pid, thread_id)
+            fname = f"{self._procfs_path}/{self.pid}/task/{thread_id}/stat"
             try:
                 with open_binary(fname) as f:
                     st = f.read().strip()
-            except IOError as err:
-                if err.errno == errno.ENOENT:
-                    # no such file or directory; it means thread
-                    # disappeared on us
-                    hit_enoent = True
-                    continue
-                raise
+            except (FileNotFoundError, ProcessLookupError):
+                # no such file or directory or no such process;
+                # it means thread disappeared on us
+                hit_enoent = True
+                continue
             # ignore the first two values ("pid (exe)")
-            st = st[st.find(b')') + 2:]
+            st = st[st.find(b')') + 2 :]
             values = st.split(b' ')
             utime = float(values[11]) / CLOCK_TICKS
             stime = float(values[12]) / CLOCK_TICKS
-            ntuple = _common.pthread(int(thread_id), utime, stime)
+            ntuple = ntp.pthread(int(thread_id), utime, stime)
             retlist.append(ntuple)
         if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('%s/%s' % (self._procfs_path, self.pid))
+            self._raise_if_not_alive()
         return retlist
 
     @wrap_exceptions
     def nice_get(self):
-        # with open_text('%s/%s/stat' % (self._procfs_path, self.pid)) as f:
+        # with open_text(f"{self._procfs_path}/{self.pid}/stat") as f:
         #   data = f.read()
         #   return int(data.split()[18])
 
         # Use C implementation
-        return cext_posix.getpriority(self.pid)
+        return _psutil.proc_priority_get(self.pid)
 
     @wrap_exceptions
     def nice_set(self, value):
-        return cext_posix.setpriority(self.pid, value)
+        return _psutil.proc_priority_set(self.pid, value)
 
-    @wrap_exceptions
-    def cpu_affinity_get(self):
-        return cext.proc_cpu_affinity_get(self.pid)
+    # starting from CentOS 6.
+    if HAS_CPU_AFFINITY:
 
-    @wrap_exceptions
-    def cpu_affinity_set(self, cpus):
-        try:
-            cext.proc_cpu_affinity_set(self.pid, cpus)
-        except OSError as err:
-            if err.errno == errno.EINVAL:
-                allcpus = tuple(range(len(per_cpu_times())))
-                for cpu in cpus:
-                    if cpu not in allcpus:
-                        raise ValueError("invalid CPU #%i (choose between %s)"
-                                         % (cpu, allcpus))
-            raise
+        @wrap_exceptions
+        def cpu_affinity_get(self):
+            return _psutil.proc_cpu_affinity_get(self.pid)
+
+        def _get_eligible_cpus(
+            self,
+            _re=re.compile(
+                br"^Cpus_allowed_list:[ \t]*([^\r\n]*)", re.MULTILINE
+            ),
+        ):
+            # See: https://github.com/giampaolo/psutil/issues/956
+            data = self._read_status_file()
+            if match := _re.search(data):
+                try:
+                    return _parse_cpulist(decode(match.group(1)))
+                except ValueError as err:
+                    debug(
+                        f"can't parse Cpus_allowed_list ({err}); falling back"
+                    )
+            return list(range(len(per_cpu_times())))
+
+        @wrap_exceptions
+        def cpu_affinity_set(self, cpus):
+            try:
+                _psutil.proc_cpu_affinity_set(self.pid, cpus)
+            except (OSError, ValueError) as err:
+                if isinstance(err, ValueError) or err.errno == errno.EINVAL:
+                    eligible_cpus = self._get_eligible_cpus()
+                    all_cpus = tuple(range(len(per_cpu_times())))
+                    for cpu in cpus:
+                        if cpu not in all_cpus:
+                            msg = (
+                                f"invalid CPU {cpu!r}; choose between"
+                                f" {eligible_cpus!r}"
+                            )
+                            raise ValueError(msg) from None
+                        if cpu not in eligible_cpus:
+                            msg = (
+                                f"CPU number {cpu} is not eligible; choose"
+                                f" between {eligible_cpus}"
+                            )
+                            raise ValueError(msg) from err
+                raise
 
     # only starting from kernel 2.6.13
-    if hasattr(cext, "proc_ioprio_get"):
+    if HAS_PROC_IO_PRIORITY:
 
         @wrap_exceptions
         def ionice_get(self):
-            ioclass, value = cext.proc_ioprio_get(self.pid)
-            if enum is not None:
-                ioclass = IOPriority(ioclass)
-            return _common.pionice(ioclass, value)
+            ioclass, value = _psutil.proc_ioprio_get(self.pid)
+            ioclass = ProcessIOPriority(ioclass)
+            return ntp.pionice(ioclass, value)
 
         @wrap_exceptions
         def ionice_set(self, ioclass, value):
-            if value is not None:
-                if not PY3 and not isinstance(value, (int, long)):
-                    msg = "value argument is not an integer (gor %r)" % value
-                    raise TypeError(msg)
-                if not 0 <= value <= 7:
-                    raise ValueError(
-                        "value argument range expected is between 0 and 7")
-
-            if ioclass in (IOPRIO_CLASS_NONE, None):
-                if value:
-                    msg = "can't specify value with IOPRIO_CLASS_NONE " \
-                          "(got %r)" % value
-                    raise ValueError(msg)
-                ioclass = IOPRIO_CLASS_NONE
-                value = 0
-            elif ioclass == IOPRIO_CLASS_IDLE:
-                if value:
-                    msg = "can't specify value with IOPRIO_CLASS_IDLE " \
-                          "(got %r)" % value
-                    raise ValueError(msg)
+            if value is None:
                 value = 0
-            elif ioclass in (IOPRIO_CLASS_RT, IOPRIO_CLASS_BE):
-                if value is None:
-                    # TODO: add comment explaining why this is 4 (?)
-                    value = 4
-            else:
-                # otherwise we would get OSError(EVINAL)
-                raise ValueError("invalid ioclass argument %r" % ioclass)
-
-            return cext.proc_ioprio_set(self.pid, ioclass, value)
+            if value and ioclass in {
+                ProcessIOPriority.IOPRIO_CLASS_IDLE,
+                ProcessIOPriority.IOPRIO_CLASS_NONE,
+            }:
+                msg = f"{ioclass!r} ioclass accepts no value"
+                raise ValueError(msg)
+            if value < 0 or value > 7:
+                msg = "value not in 0-7 range"
+                raise ValueError(msg)
+            return _psutil.proc_ioprio_set(self.pid, ioclass, value)
+
+    if hasattr(resource, "prlimit"):
 
-    if HAS_PRLIMIT:
         @wrap_exceptions
-        def rlimit(self, resource, limits=None):
+        def rlimit(self, resource_, limits=None):
             # If pid is 0 prlimit() applies to the calling process and
             # we don't want that. We should never get here though as
             # PID 0 is not supported on Linux.
             if self.pid == 0:
-                raise ValueError("can't use prlimit() against PID 0 process")
+                msg = "can't use prlimit() against PID 0 process"
+                raise ValueError(msg)
             try:
                 if limits is None:
                     # get
-                    return cext.linux_prlimit(self.pid, resource)
+                    soft, hard = resource.prlimit(self.pid, resource_)
+                    # Python 3.15 returns RLIM_INFINITY as the unsigned
+                    # 2**64-1 instead of -1; map it back for consistency.
+                    if soft == RLIM_INFINITY_UNSIGNED:
+                        soft = _psutil.RLIM_INFINITY
+                    if hard == RLIM_INFINITY_UNSIGNED:
+                        hard = _psutil.RLIM_INFINITY
+                    return soft, hard
                 else:
                     # set
                     if len(limits) != 2:
-                        raise ValueError(
-                            "second argument must be a (soft, hard) tuple, "
-                            "got %s" % repr(limits))
-                    soft, hard = limits
-                    cext.linux_prlimit(self.pid, resource, soft, hard)
+                        msg = (
+                            "second argument must be a (soft, hard) "
+                            f"tuple, got {limits!r}"
+                        )
+                        raise ValueError(msg)
+                    resource.prlimit(self.pid, resource_, limits)
             except OSError as err:
-                if err.errno == errno.ENOSYS and pid_exists(self.pid):
+                if err.errno == errno.ENOSYS:
                     # I saw this happening on Travis:
                     # https://travis-ci.org/giampaolo/psutil/jobs/51368273
-                    raise ZombieProcess(self.pid, self._name, self._ppid)
-                else:
-                    raise
+                    self._raise_if_zombie()
+                raise
 
     @wrap_exceptions
     def status(self):
-        letter = self._parse_stat_file()[1]
-        if PY3:
-            letter = letter.decode()
+        letter = self._parse_stat_file()['status']
+        letter = letter.decode()
         # XXX is '?' legit? (we're not supposed to return it anyway)
         return PROC_STATUSES.get(letter, '?')
 
     @wrap_exceptions
     def open_files(self):
         retlist = []
-        files = os.listdir("%s/%s/fd" % (self._procfs_path, self.pid))
+        files = os.listdir(f"{self._procfs_path}/{self.pid}/fd")
         hit_enoent = False
         for fd in files:
-            file = "%s/%s/fd/%s" % (self._procfs_path, self.pid, fd)
+            file = f"{self._procfs_path}/{self.pid}/fd/{fd}"
             try:
                 path = readlink(file)
-            except OSError as err:
+            except (FileNotFoundError, ProcessLookupError):
                 # ENOENT == file which is gone in the meantime
-                if err.errno in (errno.ENOENT, errno.ESRCH):
-                    hit_enoent = True
-                    continue
-                elif err.errno == errno.EINVAL:
+                hit_enoent = True
+                continue
+            except OSError as err:
+                if err.errno == errno.EINVAL:
                     # not a link
                     continue
-                else:
-                    raise
+                if err.errno == errno.ENAMETOOLONG:
+                    # file name too long
+                    debug(err)
+                    continue
+                raise
             else:
                 # If path is not an absolute there's no way to tell
                 # whether it's a regular file or not, so we skip it.
@@ -1430,42 +2293,47 @@ def open_files(self):
                 # absolute path though.
                 if path.startswith('/') and isfile_strict(path):
                     # Get file position and flags.
-                    file = "%s/%s/fdinfo/%s" % (
-                        self._procfs_path, self.pid, fd)
-                    with open_binary(file) as f:
-                        pos = int(f.readline().split()[1])
-                        flags = int(f.readline().split()[1], 8)
-                    mode = file_flags_to_mode(flags)
-                    ntuple = popenfile(path, int(fd), int(pos), mode, flags)
-                    retlist.append(ntuple)
+                    file = f"{self._procfs_path}/{self.pid}/fdinfo/{fd}"
+                    try:
+                        with open_binary(file) as f:
+                            pos = int(f.readline().split()[1])
+                            flags = int(f.readline().split()[1], 8)
+                    except (FileNotFoundError, ProcessLookupError):
+                        # fd gone in the meantime; process may
+                        # still be alive
+                        hit_enoent = True
+                    else:
+                        mode = file_flags_to_mode(flags)
+                        ntuple = ntp.popenfile(
+                            path, int(fd), int(pos), mode, flags
+                        )
+                        retlist.append(ntuple)
         if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('%s/%s' % (self._procfs_path, self.pid))
+            self._raise_if_not_alive()
         return retlist
 
     @wrap_exceptions
-    def connections(self, kind='inet'):
-        ret = _connections.retrieve(kind, self.pid)
-        # raise NSP if the process disappeared on us
-        os.stat('%s/%s' % (self._procfs_path, self.pid))
+    def net_connections(self, kind='inet'):
+        ret = _net_connections.retrieve(kind, self.pid)
+        self._raise_if_not_alive()
         return ret
 
     @wrap_exceptions
     def num_fds(self):
-        return len(os.listdir("%s/%s/fd" % (self._procfs_path, self.pid)))
+        return len(os.listdir(f"{self._procfs_path}/{self.pid}/fd"))
 
     @wrap_exceptions
     def ppid(self):
-        return int(self._parse_stat_file()[2])
+        return int(self._parse_stat_file()['ppid'])
 
     @wrap_exceptions
-    def uids(self, _uids_re=re.compile(b'Uid:\t(\d+)\t(\d+)\t(\d+)')):
+    def uids(self, _uids_re=re.compile(br'Uid:\t(\d+)\t(\d+)\t(\d+)')):
         data = self._read_status_file()
         real, effective, saved = _uids_re.findall(data)[0]
-        return _common.puids(int(real), int(effective), int(saved))
+        return ntp.puids(int(real), int(effective), int(saved))
 
     @wrap_exceptions
-    def gids(self, _gids_re=re.compile(b'Gid:\t(\d+)\t(\d+)\t(\d+)')):
+    def gids(self, _gids_re=re.compile(br'Gid:\t(\d+)\t(\d+)\t(\d+)')):
         data = self._read_status_file()
         real, effective, saved = _gids_re.findall(data)[0]
-        return _common.pgids(int(real), int(effective), int(saved))
+        return ntp.pgids(int(real), int(effective), int(saved))
diff --git a/psutil/_psosx.py b/psutil/_psosx.py
index 0551338029..a585048de2 100644
--- a/psutil/_psosx.py
+++ b/psutil/_psosx.py
@@ -2,82 +2,65 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""OSX platform implementation."""
+"""macOS platform implementation."""
 
 import errno
 import functools
 import os
-from collections import namedtuple
 
-from . import _common
+from . import _ntuples as ntp
 from . import _psposix
-from . import _psutil_osx as cext
-from . import _psutil_posix as cext_posix
+from . import _psutil
+from ._common import AccessDenied
+from ._common import NoSuchProcess
+from ._common import ZombieProcess
 from ._common import conn_tmap
+from ._common import conn_to_ntuple
+from ._common import debug
 from ._common import isfile_strict
+from ._common import memoize_when_activated
 from ._common import parse_environ_block
-from ._common import sockfam_to_enum
-from ._common import socktype_to_enum
 from ._common import usage_percent
-
+from ._common import warn
+from ._enums import BatteryTime
+from ._enums import ConnectionStatus
+from ._enums import NicDuplex
+from ._enums import ProcessStatus
 
 __extra__all__ = []
 
 
 # =====================================================================
-# --- constants
+# --- globals
 # =====================================================================
 
 
-PAGESIZE = os.sysconf("SC_PAGE_SIZE")
-AF_LINK = cext_posix.AF_LINK
+PAGESIZE = _psutil.getpagesize()
+AF_LINK = _psutil.AF_LINK
 
-# http://students.mimuw.edu.pl/lxr/source/include/net/tcp_states.h
 TCP_STATUSES = {
-    cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
-    cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
-    cext.TCPS_SYN_RECEIVED: _common.CONN_SYN_RECV,
-    cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
-    cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
-    cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
-    cext.TCPS_CLOSED: _common.CONN_CLOSE,
-    cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
-    cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
-    cext.TCPS_LISTEN: _common.CONN_LISTEN,
-    cext.TCPS_CLOSING: _common.CONN_CLOSING,
-    cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
+    _psutil.TCPS_ESTABLISHED: ConnectionStatus.CONN_ESTABLISHED,
+    _psutil.TCPS_SYN_SENT: ConnectionStatus.CONN_SYN_SENT,
+    _psutil.TCPS_SYN_RECEIVED: ConnectionStatus.CONN_SYN_RECV,
+    _psutil.TCPS_FIN_WAIT_1: ConnectionStatus.CONN_FIN_WAIT1,
+    _psutil.TCPS_FIN_WAIT_2: ConnectionStatus.CONN_FIN_WAIT2,
+    _psutil.TCPS_TIME_WAIT: ConnectionStatus.CONN_TIME_WAIT,
+    _psutil.TCPS_CLOSED: ConnectionStatus.CONN_CLOSE,
+    _psutil.TCPS_CLOSE_WAIT: ConnectionStatus.CONN_CLOSE_WAIT,
+    _psutil.TCPS_LAST_ACK: ConnectionStatus.CONN_LAST_ACK,
+    _psutil.TCPS_LISTEN: ConnectionStatus.CONN_LISTEN,
+    _psutil.TCPS_CLOSING: ConnectionStatus.CONN_CLOSING,
+    _psutil.PSUTIL_CONN_NONE: ConnectionStatus.CONN_NONE,
 }
 
 PROC_STATUSES = {
-    cext.SIDL: _common.STATUS_IDLE,
-    cext.SRUN: _common.STATUS_RUNNING,
-    cext.SSLEEP: _common.STATUS_SLEEPING,
-    cext.SSTOP: _common.STATUS_STOPPED,
-    cext.SZOMB: _common.STATUS_ZOMBIE,
+    _psutil.SIDL: ProcessStatus.STATUS_IDLE,
+    _psutil.SRUN: ProcessStatus.STATUS_RUNNING,
+    _psutil.SSLEEP: ProcessStatus.STATUS_SLEEPING,
+    _psutil.SSTOP: ProcessStatus.STATUS_STOPPED,
+    _psutil.SZOMB: ProcessStatus.STATUS_ZOMBIE,
 }
 
-scputimes = namedtuple('scputimes', ['user', 'nice', 'system', 'idle'])
-
-svmem = namedtuple(
-    'svmem', ['total', 'available', 'percent', 'used', 'free',
-              'active', 'inactive', 'wired'])
-
-pmem = namedtuple('pmem', ['rss', 'vms', 'pfaults', 'pageins'])
-pfullmem = namedtuple('pfullmem', pmem._fields + ('uss', ))
-
-pmmap_grouped = namedtuple(
-    'pmmap_grouped',
-    'path rss private swapped dirtied ref_count shadow_depth')
-
-pmmap_ext = namedtuple(
-    'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields))
-
-# these get overwritten on "import psutil" from the __init__.py file
-NoSuchProcess = None
-ZombieProcess = None
-AccessDenied = None
-TimeoutExpired = None
-
 
 # =====================================================================
 # --- memory
@@ -85,20 +68,24 @@
 
 
 def virtual_memory():
-    """System virtual memory as a namedtuple."""
-    total, active, inactive, wired, free = cext.virtual_mem()
-    avail = inactive + free
-    used = active + inactive + wired
-    percent = usage_percent((total - avail), total, _round=1)
-    return svmem(total, avail, percent, used, free,
-                 active, inactive, wired)
+    """System virtual memory as a named tuple."""
+    d = _psutil.virtual_mem()
+    d["percent"] = usage_percent(
+        (d["total"] - d["available"]), d["total"], round_=1
+    )
+    return ntp.svmem(**d)
 
 
 def swap_memory():
     """Swap system memory as a (total, used, free, sin, sout) tuple."""
-    total, used, free, sin, sout = cext.swap_mem()
-    percent = usage_percent(used, total, _round=1)
-    return _common.sswap(total, used, free, percent, sin, sout)
+    d = _psutil.swap_mem()
+    d["percent"] = usage_percent(d["used"], d["total"], round_=1)
+    return ntp.sswap(**d)
+
+
+# malloc / heap functions
+heap_info = _psutil.heap_info
+heap_trim = _psutil.heap_trim
 
 
 # =====================================================================
@@ -107,36 +94,49 @@ def swap_memory():
 
 
 def cpu_times():
-    """Return system CPU times as a namedtuple."""
-    user, nice, system, idle = cext.cpu_times()
-    return scputimes(user, nice, system, idle)
+    """Return system CPU times as a named tuple."""
+    user, nice, system, idle = _psutil.cpu_times()
+    return ntp.scputimes(user, system, idle, nice)
 
 
 def per_cpu_times():
-    """Return system CPU times as a named tuple"""
+    """Return system CPU times as a named tuple."""
     ret = []
-    for cpu_t in cext.per_cpu_times():
+    for cpu_t in _psutil.per_cpu_times():
         user, nice, system, idle = cpu_t
-        item = scputimes(user, nice, system, idle)
+        item = ntp.scputimes(user, system, idle, nice)
         ret.append(item)
     return ret
 
 
 def cpu_count_logical():
     """Return the number of logical CPUs in the system."""
-    return cext.cpu_count_logical()
+    return _psutil.cpu_count_logical()
 
 
-def cpu_count_physical():
-    """Return the number of physical CPUs in the system."""
-    return cext.cpu_count_phys()
+def cpu_count_cores():
+    """Return the number of CPU cores in the system."""
+    return _psutil.cpu_count_cores()
 
 
 def cpu_stats():
-    ctx_switches, interrupts, soft_interrupts, syscalls, traps = \
-        cext.cpu_stats()
-    return _common.scpustats(
-        ctx_switches, interrupts, soft_interrupts, syscalls)
+    ctx_switches, interrupts, soft_interrupts, syscalls, _traps = (
+        _psutil.cpu_stats()
+    )
+    return ntp.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls)
+
+
+def cpu_freq():
+    """Return CPU frequency.
+    On macOS per-cpu frequency is not supported.
+    Also, the returned frequency never changes, see:
+    https://arstechnica.com/civis/viewtopic.php?f=19&t=465002.
+    """
+    ret = _psutil.cpu_freq()
+    if ret is None:  # not available on virtualized ARM64, see #2382
+        return []
+    curr, min_, max_ = ret
+    return [ntp.scpufreq(float(curr), float(min_), float(max_))]
 
 
 # =====================================================================
@@ -145,12 +145,13 @@ def cpu_stats():
 
 
 disk_usage = _psposix.disk_usage
-disk_io_counters = cext.disk_io_counters
+disk_io_counters = _psutil.disk_io_counters
 
 
 def disk_partitions(all=False):
+    """Return mounted disk partitions as a list of named tuples."""
     retlist = []
-    partitions = cext.disk_partitions()
+    partitions = _psutil.disk_partitions()
     for partition in partitions:
         device, mountpoint, fstype, opts = partition
         if device == 'none':
@@ -158,34 +159,57 @@ def disk_partitions(all=False):
         if not all:
             if not os.path.isabs(device) or not os.path.exists(device):
                 continue
-        ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
+        ntuple = ntp.sdiskpart(device, mountpoint, fstype, opts)
         retlist.append(ntuple)
     return retlist
 
 
+# =====================================================================
+# --- sensors
+# =====================================================================
+
+
+def sensors_battery():
+    """Return battery information."""
+    try:
+        percent, minsleft, power_plugged = _psutil.sensors_battery()
+    except NotImplementedError:
+        # no power source - return None according to interface
+        return None
+    power_plugged = power_plugged == 1
+    if power_plugged:
+        secsleft = BatteryTime.POWER_TIME_UNLIMITED
+    elif minsleft == -1:
+        secsleft = BatteryTime.POWER_TIME_UNKNOWN
+    else:
+        secsleft = minsleft * 60
+    return ntp.sbattery(percent, secsleft, power_plugged)
+
+
 # =====================================================================
 # --- network
 # =====================================================================
 
 
-net_io_counters = cext.net_io_counters
-net_if_addrs = cext_posix.net_if_addrs
+net_io_counters = _psutil.net_io_counters
+net_if_addrs = _psutil.net_if_addrs
 
 
 def net_connections(kind='inet'):
-    # Note: on OSX this will fail with AccessDenied unless
+    """System-wide network connections."""
+    # Note: on macOS this will fail with AccessDenied unless
     # the process is owned by root.
     ret = []
     for pid in pids():
         try:
-            cons = Process(pid).connections(kind)
+            cons = Process(pid).net_connections(kind)
         except NoSuchProcess:
             continue
         else:
             if cons:
                 for c in cons:
                     c = list(c) + [pid]
-                    ret.append(_common.sconn(*c))
+                    ret.append(ntp.sconn(*c))
     return ret
 
 
@@ -194,10 +218,19 @@ def net_if_stats():
     names = net_io_counters().keys()
     ret = {}
     for name in names:
-        isup, duplex, speed, mtu = cext_posix.net_if_stats(name)
-        if hasattr(_common, 'NicDuplex'):
-            duplex = _common.NicDuplex(duplex)
-        ret[name] = _common.snicstats(isup, duplex, speed, mtu)
+        try:
+            mtu = _psutil.net_if_mtu(name)
+            flags = _psutil.net_if_flags(name)
+            duplex, speed = _psutil.net_if_duplex_speed(name)
+        except OSError as err:
+            # https://github.com/giampaolo/psutil/issues/1279
+            if err.errno != errno.ENODEV:
+                raise
+        else:
+            duplex = NicDuplex(duplex)
+            output_flags = ','.join(flags)
+            isup = 'running' in flags
+            ret[name] = ntp.snicstats(isup, duplex, speed, mtu, output_flags)
     return ret
 
 
@@ -208,19 +241,43 @@ def net_if_stats():
 
 def boot_time():
     """The system boot time expressed in seconds since the epoch."""
-    return cext.boot_time()
+    return _psutil.boot_time()
+
+
+try:
+    INIT_BOOT_TIME = boot_time()
+except Exception as err:  # noqa: BLE001
+    # Don't want to crash at import time.
+    warn(f"boot_time() failed on import: {err!r}")
+    INIT_BOOT_TIME = 0
+
+
+def adjust_proc_create_time(ctime):
+    """Account for system clock updates."""
+    if INIT_BOOT_TIME == 0:
+        return ctime
+
+    diff = INIT_BOOT_TIME - boot_time()
+    if diff == 0 or abs(diff) < 1:
+        return ctime
+
+    debug("system clock was updated; adjusting process create_time()")
+    if diff < 0:
+        return ctime - diff
+    return ctime + diff
 
 
 def users():
+    """Return currently connected users as a list of named tuples."""
     retlist = []
-    rawlist = cext.users()
+    rawlist = _psutil.users()
     for item in rawlist:
-        user, tty, hostname, tstamp = item
+        user, tty, hostname, tstamp, pid = item
         if tty == '~':
             continue  # reboot or shutdown
         if not tstamp:
             continue
-        nt = _common.suser(user, tty or None, hostname or None, tstamp)
+        nt = ntp.suser(user, tty or None, hostname or None, tstamp, pid)
         retlist.append(nt)
     return retlist
 
@@ -230,7 +287,22 @@ def users():
 # =====================================================================
 
 
-pids = cext.pids
+def pids():
+    ls = _psutil.pids()
+    if 0 not in ls:
+        # On certain macOS versions pids() C doesn't return PID 0 but
+        # "ps" does and the process is querable via sysctl():
+        # https://travis-ci.org/giampaolo/psutil/jobs/309619941
+        try:
+            Process(0).create_time()
+            ls.insert(0, 0)
+        except NoSuchProcess:
+            pass
+        except AccessDenied:
+            ls.insert(0, 0)
+    return ls
+
+
 pid_exists = _psposix.pid_exists
 
 
@@ -238,135 +310,164 @@ def wrap_exceptions(fun):
     """Decorator which translates bare OSError exceptions into
     NoSuchProcess and AccessDenied.
     """
+
     @functools.wraps(fun)
     def wrapper(self, *args, **kwargs):
+        pid, ppid, name = self.pid, self._ppid, self._name
         try:
             return fun(self, *args, **kwargs)
-        except OSError as err:
-            if err.errno == errno.ESRCH:
-                if not pid_exists(self.pid):
-                    raise NoSuchProcess(self.pid, self._name)
-                else:
-                    raise ZombieProcess(self.pid, self._name, self._ppid)
-            if err.errno in (errno.EPERM, errno.EACCES):
-                raise AccessDenied(self.pid, self._name)
-            raise
+        except ProcessLookupError as err:
+            if _psutil.proc_is_zombie(pid):
+                raise ZombieProcess(pid, name, ppid) from err
+            raise NoSuchProcess(pid, name) from err
+        except PermissionError as err:
+            raise AccessDenied(pid, name) from err
+        except _psutil.ZombieProcessError as err:
+            raise ZombieProcess(pid, name, ppid) from err
+
     return wrapper
 
 
-class Process(object):
+class Process:
     """Wrapper class around underlying C implementation."""
 
-    __slots__ = ["pid", "_name", "_ppid"]
+    __slots__ = ["_cache", "_name", "_ppid", "pid"]
 
     def __init__(self, pid):
         self.pid = pid
         self._name = None
         self._ppid = None
 
+    @wrap_exceptions
+    @memoize_when_activated
+    def _oneshot_kinfo(self):
+        # Note: should work with all PIDs without permission issues.
+        return _psutil.proc_oneshot_kinfo(self.pid)
+
+    @wrap_exceptions
+    @memoize_when_activated
+    def _oneshot_pidtaskinfo(self):
+        # Note: should work for PIDs owned by user only.
+        return _psutil.proc_oneshot_pidtaskinfo(self.pid)
+
+    def oneshot_enter(self):
+        self._oneshot_kinfo.cache_activate(self)
+        self._oneshot_pidtaskinfo.cache_activate(self)
+
+    def oneshot_exit(self):
+        self._oneshot_kinfo.cache_deactivate(self)
+        self._oneshot_pidtaskinfo.cache_deactivate(self)
+
     @wrap_exceptions
     def name(self):
-        return cext.proc_name(self.pid)
+        name = self._oneshot_kinfo()["name"]
+        return name if name is not None else _psutil.proc_name(self.pid)
 
     @wrap_exceptions
     def exe(self):
-        return cext.proc_exe(self.pid)
+        return _psutil.proc_exe(self.pid)
 
     @wrap_exceptions
     def cmdline(self):
-        if not pid_exists(self.pid):
-            raise NoSuchProcess(self.pid, self._name)
-        return cext.proc_cmdline(self.pid)
+        return _psutil.proc_cmdline(self.pid)
 
     @wrap_exceptions
     def environ(self):
-        if not pid_exists(self.pid):
-            raise NoSuchProcess(self.pid, self._name)
-        return parse_environ_block(cext.proc_environ(self.pid))
+        return parse_environ_block(_psutil.proc_environ(self.pid))
 
     @wrap_exceptions
     def ppid(self):
-        self._ppid = cext.proc_ppid(self.pid)
+        self._ppid = self._oneshot_kinfo()["ppid"]
         return self._ppid
 
     @wrap_exceptions
     def cwd(self):
-        return cext.proc_cwd(self.pid)
+        return _psutil.proc_cwd(self.pid)
 
     @wrap_exceptions
     def uids(self):
-        real, effective, saved = cext.proc_uids(self.pid)
-        return _common.puids(real, effective, saved)
+        d = self._oneshot_kinfo()
+        return ntp.puids(d["ruid"], d["euid"], d["suid"])
 
     @wrap_exceptions
     def gids(self):
-        real, effective, saved = cext.proc_gids(self.pid)
-        return _common.pgids(real, effective, saved)
+        d = self._oneshot_kinfo()
+        return ntp.pgids(d["rgid"], d["egid"], d["sgid"])
 
     @wrap_exceptions
     def terminal(self):
-        tty_nr = cext.proc_tty_nr(self.pid)
-        tmap = _psposix.get_terminal_map()
-        try:
-            return tmap[tty_nr]
-        except KeyError:
+        tty_nr = self._oneshot_kinfo()["ttynr"]
+        if tty_nr == _psutil.NODEV:
             return None
+        return _psposix.get_terminal(tty_nr)
 
     @wrap_exceptions
     def memory_info(self):
-        rss, vms, pfaults, pageins = cext.proc_memory_info(self.pid)
-        return pmem(rss, vms, pfaults, pageins)
+        d = self._oneshot_pidtaskinfo()
+        return ntp.pmem(d["rss"], d["vms"])
+
+    @wrap_exceptions
+    def memory_extras(self):
+        d = _psutil.proc_memory_extras(self.pid)
+        return ntp.pmem_extras(d["phys_footprint"], d["peak_footprint"])
+
+    @wrap_exceptions
+    def memory_footprint(self):
+        uss = _psutil.proc_memory_uss(self.pid)
+        return ntp.pfootprint(uss)
 
     @wrap_exceptions
-    def memory_full_info(self):
-        basic_mem = self.memory_info()
-        uss = cext.proc_memory_uss(self.pid)
-        return pfullmem(*basic_mem + (uss, ))
+    def page_faults(self):
+        d = self._oneshot_pidtaskinfo()
+        return ntp.ppagefaults(d["minor_faults"], d["major_faults"])
 
     @wrap_exceptions
     def cpu_times(self):
-        user, system = cext.proc_cpu_times(self.pid)
-        # Children user/system times are not retrievable (set to 0).
-        return _common.pcputimes(user, system, 0, 0)
+        d = self._oneshot_pidtaskinfo()
+        # children user / system times are not retrievable (set to 0)
+        return ntp.pcputimes(d["cpu_utime"], d["cpu_stime"], 0.0, 0.0)
 
     @wrap_exceptions
-    def create_time(self):
-        return cext.proc_create_time(self.pid)
+    def create_time(self, monotonic=False):
+        ctime = self._oneshot_kinfo()["ctime"]
+        if not monotonic:
+            ctime = adjust_proc_create_time(ctime)
+        return ctime
 
     @wrap_exceptions
     def num_ctx_switches(self):
-        return _common.pctxsw(*cext.proc_num_ctx_switches(self.pid))
+        # Unvoluntary value seems not to be available;
+        # getrusage() numbers seems to confirm this theory.
+        # We set it to 0.
+        vol = self._oneshot_pidtaskinfo()["volctxsw"]
+        return ntp.pctxsw(vol, 0)
 
     @wrap_exceptions
     def num_threads(self):
-        return cext.proc_num_threads(self.pid)
+        return self._oneshot_pidtaskinfo()["num_threads"]
 
     @wrap_exceptions
     def open_files(self):
         if self.pid == 0:
             return []
         files = []
-        rawlist = cext.proc_open_files(self.pid)
+        rawlist = _psutil.proc_open_files(self.pid)
         for path, fd in rawlist:
             if isfile_strict(path):
-                ntuple = _common.popenfile(path, fd)
+                ntuple = ntp.popenfile(path, fd)
                 files.append(ntuple)
         return files
 
     @wrap_exceptions
-    def connections(self, kind='inet'):
-        if kind not in conn_tmap:
-            raise ValueError("invalid %r kind argument; choose between %s"
-                             % (kind, ', '.join([repr(x) for x in conn_tmap])))
+    def net_connections(self, kind='inet'):
         families, types = conn_tmap[kind]
-        rawlist = cext.proc_connections(self.pid, families, types)
+        rawlist = _psutil.proc_net_connections(self.pid, families, types)
         ret = []
         for item in rawlist:
             fd, fam, type, laddr, raddr, status = item
-            status = TCP_STATUSES[status]
-            fam = sockfam_to_enum(fam)
-            type = socktype_to_enum(type)
-            nt = _common.pconn(fd, fam, type, laddr, raddr, status)
+            nt = conn_to_ntuple(
+                fd, fam, type, laddr, raddr, status, TCP_STATUSES
+            )
             ret.append(nt)
         return ret
 
@@ -374,38 +475,31 @@ def connections(self, kind='inet'):
     def num_fds(self):
         if self.pid == 0:
             return 0
-        return cext.proc_num_fds(self.pid)
+        return _psutil.proc_num_fds(self.pid)
 
     @wrap_exceptions
     def wait(self, timeout=None):
-        try:
-            return _psposix.wait_pid(self.pid, timeout)
-        except _psposix.TimeoutExpired:
-            raise TimeoutExpired(timeout, self.pid, self._name)
+        return _psposix.wait_pid(self.pid, timeout)
 
     @wrap_exceptions
     def nice_get(self):
-        return cext_posix.getpriority(self.pid)
+        return _psutil.proc_priority_get(self.pid)
 
     @wrap_exceptions
     def nice_set(self, value):
-        return cext_posix.setpriority(self.pid, value)
+        return _psutil.proc_priority_set(self.pid, value)
 
     @wrap_exceptions
     def status(self):
-        code = cext.proc_status(self.pid)
+        code = self._oneshot_kinfo()["status"]
         # XXX is '?' legit? (we're not supposed to return it anyway)
         return PROC_STATUSES.get(code, '?')
 
     @wrap_exceptions
     def threads(self):
-        rawlist = cext.proc_threads(self.pid)
+        rawlist = _psutil.proc_threads(self.pid)
         retlist = []
         for thread_id, utime, stime in rawlist:
-            ntuple = _common.pthread(thread_id, utime, stime)
+            ntuple = ntp.pthread(thread_id, utime, stime)
             retlist.append(ntuple)
         return retlist
-
-    @wrap_exceptions
-    def memory_maps(self):
-        return cext.proc_memory_maps(self.pid)
diff --git a/psutil/_psposix.py b/psutil/_psposix.py
index acbc7855b6..331696e0ca 100644
--- a/psutil/_psposix.py
+++ b/psutil/_psposix.py
@@ -4,25 +4,26 @@
 
 """Routines common to all posix systems."""
 
+import enum
 import errno
+import functools
 import glob
 import os
-import sys
+import select
+import signal
 import time
 
-from ._common import memoize
-from ._common import sdiskusage
+from . import _ntuples as ntp
+from ._common import MACOS
+from ._common import TimeoutExpired
+from ._common import debug
 from ._common import usage_percent
-from ._compat import PY3
-from ._compat import unicode
 
+if MACOS:
+    from . import _psutil
 
-__all__ = ['TimeoutExpired', 'pid_exists', 'wait_pid', 'disk_usage',
-           'get_terminal_map']
 
-
-class TimeoutExpired(Exception):
-    pass
+__all__ = ['pid_exists', 'wait_pid', 'disk_usage', 'get_terminal']
 
 
 def pid_exists(pid):
@@ -36,88 +37,271 @@ def pid_exists(pid):
         return True
     try:
         os.kill(pid, 0)
-    except OSError as err:
-        if err.errno == errno.ESRCH:
-            # ESRCH == No such process
-            return False
-        elif err.errno == errno.EPERM:
-            # EPERM clearly means there's a process to deny access to
-            return True
-        else:
-            # According to "man 2 kill" possible error values are
-            # (EINVAL, EPERM, ESRCH) therefore we should never get
-            # here. If we do let's be explicit in considering this
-            # an error.
-            raise err
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        # EPERM clearly means there's a process to deny access to
+        return True
+    # According to "man 2 kill" possible error values are
+    # (EINVAL, EPERM, ESRCH)
     else:
         return True
 
 
-def wait_pid(pid, timeout=None):
-    """Wait for process with pid 'pid' to terminate and return its
-    exit status code as an integer.
+NegSignal = enum.IntEnum(
+    'NegSignal', {x.name: -x.value for x in signal.Signals}
+)
+
+
+def negsig_to_enum(num):
+    """Convert a negative signal value to an enum."""
+    try:
+        return NegSignal(num)
+    except ValueError:
+        return num
+
 
-    If pid is not a children of os.getpid() (current process) just
-    waits until the process disappears and return None.
+def convert_exit_code(status):
+    """Convert a os.waitpid() status to an exit code."""
+    if os.WIFEXITED(status):
+        # Process terminated normally by calling exit(3) or _exit(2),
+        # or by returning from main(). The return value is the
+        # positive integer passed to *exit().
+        return os.WEXITSTATUS(status)
+    if os.WIFSIGNALED(status):
+        # Process exited due to a signal. Return the negative value
+        # of that signal.
+        return negsig_to_enum(-os.WTERMSIG(status))
+    # if os.WIFSTOPPED(status):
+    #     # Process was stopped via SIGSTOP or is being traced, and
+    #     # waitpid() was called with WUNTRACED flag. PID is still
+    #     # alive. From now on waitpid() will keep returning (0, 0)
+    #     # until the process state doesn't change.
+    #     # It may make sense to catch/enable this since stopped PIDs
+    #     # ignore SIGTERM.
+    #     interval = sleep(interval)
+    #     continue
+    # if os.WIFCONTINUED(status):
+    #     # Process was resumed via SIGCONT and waitpid() was called
+    #     # with WCONTINUED flag.
+    #     interval = sleep(interval)
+    #     continue
 
-    If pid does not exist at all return None immediately.
+    # Should never happen.
+    msg = f"unknown process exit status {status!r}"
+    raise ValueError(msg)
 
-    Raise TimeoutExpired on timeout expired.
+
+def wait_pid_posix(
+    pid,
+    timeout=None,
+    _waitpid=os.waitpid,
+    _timer=getattr(time, 'monotonic', time.time),  # noqa: B008
+    _min=min,
+    _sleep=time.sleep,
+    _pid_exists=pid_exists,
+):
+    """Wait for a process PID to terminate.
+
+    If the process terminated normally by calling exit(3) or _exit(2),
+    or by returning from main(), the return value is the positive integer
+    passed to *exit().
+
+    If it was terminated by a signal it returns the negated value of the
+    signal which caused the termination (e.g. -SIGTERM).
+
+    If PID is not a children of os.getpid() (current process) just
+    wait until the process disappears and return None.
+
+    If PID does not exist at all return None immediately.
+
+    If timeout is specified and process is still alive raise
+    TimeoutExpired.
+
+    If timeout=0 either return immediately or raise TimeoutExpired
+    (non-blocking).
     """
-    def check_timeout(delay):
-        if timeout is not None:
-            if timer() >= stop_at:
-                raise TimeoutExpired()
-        time.sleep(delay)
-        return min(delay * 2, 0.04)
-
-    timer = getattr(time, 'monotonic', time.time)
+    interval = 0.0001
+    max_interval = 0.04
+    flags = 0
+    stop_at = None
+
     if timeout is not None:
-        def waitcall():
-            return os.waitpid(pid, os.WNOHANG)
-        stop_at = timer() + timeout
-    else:
-        def waitcall():
-            return os.waitpid(pid, 0)
+        flags |= os.WNOHANG
+        if timeout != 0:
+            stop_at = _timer() + timeout
 
-    delay = 0.0001
+    def sleep_or_timeout(interval):
+        # Sleep for some time and return a new increased interval.
+        if timeout == 0 or (stop_at is not None and _timer() >= stop_at):
+            raise TimeoutExpired(timeout)
+        _sleep(interval)
+        return _min(interval * 2, max_interval)
+
+    # See: https://linux.die.net/man/2/waitpid
     while True:
         try:
-            retpid, status = waitcall()
-        except OSError as err:
-            if err.errno == errno.EINTR:
-                delay = check_timeout(delay)
-                continue
-            elif err.errno == errno.ECHILD:
-                # This has two meanings:
-                # - pid is not a child of os.getpid() in which case
-                #   we keep polling until it's gone
-                # - pid never existed in the first place
-                # In both cases we'll eventually return None as we
-                # can't determine its exit status code.
-                while True:
-                    if pid_exists(pid):
-                        delay = check_timeout(delay)
-                    else:
-                        return
-            else:
-                raise
+            retpid, status = os.waitpid(pid, flags)
+        except ChildProcessError:
+            # This has two meanings:
+            # - PID is not a child of os.getpid() in which case
+            #   we keep polling until it's gone
+            # - PID never existed in the first place
+            # In both cases we'll eventually return None as we
+            # can't determine its exit status code.
+            while _pid_exists(pid):
+                interval = sleep_or_timeout(interval)
+            return None
         else:
             if retpid == 0:
-                # WNOHANG was used, pid is still running
-                delay = check_timeout(delay)
-                continue
-            # process exited due to a signal; return the integer of
-            # that signal
-            if os.WIFSIGNALED(status):
-                return os.WTERMSIG(status)
-            # process exited using exit(2) system call; return the
-            # integer exit(2) system call has been called with
-            elif os.WIFEXITED(status):
-                return os.WEXITSTATUS(status)
+                # WNOHANG flag was used and PID is still running.
+                interval = sleep_or_timeout(interval)
             else:
-                # should never happen
-                raise ValueError("unknown process exit status %r" % status)
+                return convert_exit_code(status)
+
+
+def _waitpid(pid, timeout):
+    """Wrapper around os.waitpid(). PID is supposed to be gone already,
+    it just returns the exit code.
+    """
+    try:
+        retpid, status = os.waitpid(pid, 0)
+    except ChildProcessError:
+        # PID is not a child of os.getpid().
+        return wait_pid_posix(pid, timeout)
+    else:
+        assert retpid != 0
+        return convert_exit_code(status)
+
+
+def wait_pid_pidfd_open(pid, timeout=None):
+    """Wait for PID to terminate using pidfd_open() + poll(). Linux >=
+    5.3 + Python >= 3.9 only.
+    """
+    try:
+        pidfd = os.pidfd_open(pid, 0)
+    except OSError as err:
+        # ESRCH = no such process, EMFILE / ENFILE = too many open files
+        if err.errno not in {errno.ESRCH, errno.EMFILE, errno.ENFILE}:
+            debug(f"pidfd_open() failed unexpectedly ({err!r}); use fallback")
+        return wait_pid_posix(pid, timeout)
+
+    try:
+        # poll() / select() have the advantage of not requiring any
+        # extra file descriptor, contrary to epoll() / kqueue().
+        # select() crashes if process opens > 1024 FDs, so we use
+        # poll().
+        poller = select.poll()
+        poller.register(pidfd, select.POLLIN)
+        timeout_ms = None if timeout is None else int(timeout * 1000)
+        events = poller.poll(timeout_ms)  # wait
+
+        if not events:
+            raise TimeoutExpired(timeout)
+        return _waitpid(pid, timeout)
+    finally:
+        os.close(pidfd)
+
+
+def wait_pid_kqueue(pid, timeout=None):
+    """Wait for PID to terminate using kqueue(). macOS and BSD only."""
+    try:
+        kq = select.kqueue()
+    except OSError as err:
+        if err.errno not in {errno.EMFILE, errno.ENFILE}:
+            debug(f"kqueue() failed unexpectedly ({err!r}); use fallback")
+        return wait_pid_posix(pid, timeout)
+
+    try:
+        kev = select.kevent(
+            pid,
+            filter=select.KQ_FILTER_PROC,
+            flags=select.KQ_EV_ADD | select.KQ_EV_ONESHOT,
+            fflags=select.KQ_NOTE_EXIT,
+        )
+        try:
+            events = kq.control([kev], 1, timeout)  # wait
+        except OSError as err:
+            if err.errno in {errno.EACCES, errno.EPERM, errno.ESRCH}:
+                debug(f"kqueue.control() failed ({err!r}); use fallback")
+                return wait_pid_posix(pid, timeout)
+            raise
+        else:
+            if not events:
+                raise TimeoutExpired(timeout)
+            return _waitpid(pid, timeout)
+    finally:
+        kq.close()
+
+
+@functools.lru_cache
+def can_use_pidfd_open():
+    # Availability: Linux >= 5.3, Python >= 3.9
+    if not hasattr(os, "pidfd_open"):
+        return False
+    try:
+        pidfd = os.pidfd_open(os.getpid(), 0)
+    except OSError as err:
+        if err.errno in {errno.EMFILE, errno.ENFILE}:  # noqa: SIM103
+            # transitory 'too many open files'
+            return True
+        # likely blocked by security policy like SECCOMP (EPERM,
+        # EACCES, ENOSYS)
+        return False
+    else:
+        os.close(pidfd)
+        return True
+
+
+@functools.lru_cache
+def can_use_kqueue():
+    # Availability: macOS, BSD
+    names = (
+        "kqueue",
+        "KQ_EV_ADD",
+        "KQ_EV_ONESHOT",
+        "KQ_FILTER_PROC",
+        "KQ_NOTE_EXIT",
+    )
+    if not all(hasattr(select, x) for x in names):
+        return False
+    kq = None
+    try:
+        kq = select.kqueue()
+        kev = select.kevent(
+            os.getpid(),
+            filter=select.KQ_FILTER_PROC,
+            flags=select.KQ_EV_ADD | select.KQ_EV_ONESHOT,
+            fflags=select.KQ_NOTE_EXIT,
+        )
+        kq.control([kev], 1, 0)
+        return True
+    except OSError as err:
+        if err.errno in {errno.EMFILE, errno.ENFILE}:  # noqa: SIM103
+            # transitory 'too many open files'
+            return True
+        return False
+    finally:
+        if kq is not None:
+            kq.close()
+
+
+def wait_pid(pid, timeout=None):
+    # PID 0 passed to waitpid() waits for any child of the current
+    # process to change state.
+    assert pid > 0
+    if timeout is not None:
+        assert timeout >= 0
+
+    if can_use_pidfd_open():
+        return wait_pid_pidfd_open(pid, timeout)
+    elif can_use_kqueue():
+        return wait_pid_kqueue(pid, timeout)
+    else:
+        return wait_pid_posix(pid, timeout)
+
+
+wait_pid.__doc__ = wait_pid_posix.__doc__
 
 
 def disk_usage(path):
@@ -127,55 +311,59 @@ def disk_usage(path):
     total and used disk space whereas "free" and "percent" represent
     the "free" and "used percent" user disk space.
     """
-    try:
-        st = os.statvfs(path)
-    except UnicodeEncodeError:
-        if not PY3 and isinstance(path, unicode):
-            # this is a bug with os.statvfs() and unicode on
-            # Python 2, see:
-            # - https://github.com/giampaolo/psutil/issues/416
-            # - http://bugs.python.org/issue18695
-            try:
-                path = path.encode(sys.getfilesystemencoding())
-            except UnicodeEncodeError:
-                pass
-            st = os.statvfs(path)
-        else:
-            raise
-
+    st = os.statvfs(path)
     # Total space which is only available to root (unless changed
     # at system level).
-    total = (st.f_blocks * st.f_frsize)
+    total = st.f_blocks * st.f_frsize
     # Remaining free space usable by root.
-    avail_to_root = (st.f_bfree * st.f_frsize)
+    avail_to_root = st.f_bfree * st.f_frsize
     # Remaining free space usable by user.
-    avail_to_user = (st.f_bavail * st.f_frsize)
+    avail_to_user = st.f_bavail * st.f_frsize
     # Total space being used in general.
-    used = (total - avail_to_root)
+    used = total - avail_to_root
+    if MACOS:
+        # see: https://github.com/giampaolo/psutil/pull/2152
+        used = _psutil.disk_usage_used(path, used)
     # Total space which is available to user (same as 'total' but
     # for the user).
     total_user = used + avail_to_user
     # User usage percent compared to the total amount of space
     # the user can use. This number would be higher if compared
     # to root's because the user has less space (usually -5%).
-    usage_percent_user = usage_percent(used, total_user, _round=1)
+    usage_percent_user = usage_percent(used, total_user, round_=1)
 
     # NB: the percentage is -5% than what shown by df due to
     # reserved blocks that we are currently not considering:
     # https://github.com/giampaolo/psutil/issues/829#issuecomment-223750462
-    return sdiskusage(
-        total=total, used=used, free=avail_to_user, percent=usage_percent_user)
+    return ntp.sdiskusage(
+        total=total, used=used, free=avail_to_user, percent=usage_percent_user
+    )
 
 
-@memoize
-def get_terminal_map():
+@functools.lru_cache
+def _get_terminal_map():
+    """Get a map of device-id -> path as a dict.
+    Used by Process.terminal().
+    """
     ret = {}
     ls = glob.glob('/dev/tty*') + glob.glob('/dev/pts/*')
     for name in ls:
         assert name not in ret, name
         try:
             ret[os.stat(name).st_rdev] = name
-        except OSError as err:
-            if err.errno != errno.ENOENT:
-                raise
+        except FileNotFoundError:
+            pass
     return ret
+
+
+def get_terminal(tty_nr):
+    """Path that terminal *tty_nr* refers to, or None.
+
+    Caller must first exclude process has no terminal. A cache miss may
+    be caused by a recently created device, so refresh the map once.
+    """
+    tmap = _get_terminal_map()
+    if tty_nr in tmap:
+        return tmap[tty_nr]
+    _get_terminal_map.cache_clear()
+    return _get_terminal_map().get(tty_nr)
diff --git a/psutil/_pssunos.py b/psutil/_pssunos.py
index a9dcd6c807..528cf33d04 100644
--- a/psutil/_pssunos.py
+++ b/psutil/_pssunos.py
@@ -5,103 +5,88 @@
 """Sun OS Solaris platform implementation."""
 
 import errno
+import functools
 import os
 import socket
 import subprocess
 import sys
 from collections import namedtuple
+from socket import AF_INET
 
-from . import _common
+from . import _ntuples as ntp
 from . import _psposix
-from . import _psutil_posix as cext_posix
-from . import _psutil_sunos as cext
+from . import _psutil
+from ._common import AF_INET6
+from ._common import ENCODING
+from ._common import AccessDenied
+from ._common import NoSuchProcess
+from ._common import ZombieProcess
+from ._common import conn_tmap
+from ._common import debug
+from ._common import get_procfs_path
 from ._common import isfile_strict
+from ._common import memoize_when_activated
 from ._common import sockfam_to_enum
 from ._common import socktype_to_enum
 from ._common import usage_percent
-from ._compat import b
-from ._compat import PY3
+from ._enums import ConnectionStatus
+from ._enums import NicDuplex
+from ._enums import ProcessStatus
 
-
-__extra__all__ = ["CONN_IDLE", "CONN_BOUND", "PROCFS_PATH"]
+__extra__all__ = ["PROCFS_PATH"]
 
 
 # =====================================================================
-# --- constants
+# --- globals
 # =====================================================================
 
 
-PAGE_SIZE = os.sysconf('SC_PAGE_SIZE')
-AF_LINK = cext_posix.AF_LINK
+PAGE_SIZE = _psutil.getpagesize()
+AF_LINK = _psutil.AF_LINK
 IS_64_BIT = sys.maxsize > 2**32
 
-CONN_IDLE = "IDLE"
-CONN_BOUND = "BOUND"
 
 PROC_STATUSES = {
-    cext.SSLEEP: _common.STATUS_SLEEPING,
-    cext.SRUN: _common.STATUS_RUNNING,
-    cext.SZOMB: _common.STATUS_ZOMBIE,
-    cext.SSTOP: _common.STATUS_STOPPED,
-    cext.SIDL: _common.STATUS_IDLE,
-    cext.SONPROC: _common.STATUS_RUNNING,  # same as run
-    cext.SWAIT: _common.STATUS_WAITING,
+    _psutil.SSLEEP: ProcessStatus.STATUS_SLEEPING,
+    _psutil.SRUN: ProcessStatus.STATUS_RUNNING,
+    _psutil.SZOMB: ProcessStatus.STATUS_ZOMBIE,
+    _psutil.SSTOP: ProcessStatus.STATUS_STOPPED,
+    _psutil.SIDL: ProcessStatus.STATUS_IDLE,
+    _psutil.SONPROC: ProcessStatus.STATUS_RUNNING,  # same as run
+    _psutil.SWAIT: ProcessStatus.STATUS_WAITING,
 }
 
 TCP_STATUSES = {
-    cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
-    cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
-    cext.TCPS_SYN_RCVD: _common.CONN_SYN_RECV,
-    cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
-    cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
-    cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
-    cext.TCPS_CLOSED: _common.CONN_CLOSE,
-    cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
-    cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
-    cext.TCPS_LISTEN: _common.CONN_LISTEN,
-    cext.TCPS_CLOSING: _common.CONN_CLOSING,
-    cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
-    cext.TCPS_IDLE: CONN_IDLE,  # sunos specific
-    cext.TCPS_BOUND: CONN_BOUND,  # sunos specific
+    _psutil.TCPS_ESTABLISHED: ConnectionStatus.CONN_ESTABLISHED,
+    _psutil.TCPS_SYN_SENT: ConnectionStatus.CONN_SYN_SENT,
+    _psutil.TCPS_SYN_RCVD: ConnectionStatus.CONN_SYN_RECV,
+    _psutil.TCPS_FIN_WAIT_1: ConnectionStatus.CONN_FIN_WAIT1,
+    _psutil.TCPS_FIN_WAIT_2: ConnectionStatus.CONN_FIN_WAIT2,
+    _psutil.TCPS_TIME_WAIT: ConnectionStatus.CONN_TIME_WAIT,
+    _psutil.TCPS_CLOSED: ConnectionStatus.CONN_CLOSE,
+    _psutil.TCPS_CLOSE_WAIT: ConnectionStatus.CONN_CLOSE_WAIT,
+    _psutil.TCPS_LAST_ACK: ConnectionStatus.CONN_LAST_ACK,
+    _psutil.TCPS_LISTEN: ConnectionStatus.CONN_LISTEN,
+    _psutil.TCPS_CLOSING: ConnectionStatus.CONN_CLOSING,
+    _psutil.PSUTIL_CONN_NONE: ConnectionStatus.CONN_NONE,
+    _psutil.TCPS_IDLE: ConnectionStatus.CONN_IDLE,  # sunos specific
+    _psutil.TCPS_BOUND: ConnectionStatus.CONN_BOUND,  # sunos specific
 }
 
-
-# =====================================================================
-# --- named tuples
-# =====================================================================
-
-
-scputimes = namedtuple('scputimes', ['user', 'system', 'idle', 'iowait'])
-pcputimes = namedtuple('pcputimes',
-                       ['user', 'system', 'children_user', 'children_system'])
-svmem = namedtuple('svmem', ['total', 'available', 'percent', 'used', 'free'])
-pmem = namedtuple('pmem', ['rss', 'vms'])
-pfullmem = pmem
-pmmap_grouped = namedtuple('pmmap_grouped',
-                           ['path', 'rss', 'anonymous', 'locked'])
-pmmap_ext = namedtuple(
-    'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields))
-
-
-# =====================================================================
-# --- exceptions
-# =====================================================================
-
-
-# these get overwritten on "import psutil" from the __init__.py file
-NoSuchProcess = None
-ZombieProcess = None
-AccessDenied = None
-TimeoutExpired = None
-
-
-# =====================================================================
-# --- utils
-# =====================================================================
-
-
-def get_procfs_path():
-    return sys.modules['psutil'].PROCFS_PATH
+proc_info_map = dict(
+    ppid=0,
+    rss=1,
+    vms=2,
+    create_time=3,
+    nice=4,
+    num_threads=5,
+    status=6,
+    ttynr=7,
+    uid=8,
+    euid=9,
+    gid=10,
+    egid=11,
+)
 
 
 # =====================================================================
@@ -110,45 +95,54 @@ def get_procfs_path():
 
 
 def virtual_memory():
-    # we could have done this with kstat, but imho this is good enough
+    """Report virtual memory metrics."""
+    # we could have done this with kstat, but IMHO this is good enough
     total = os.sysconf('SC_PHYS_PAGES') * PAGE_SIZE
     # note: there's no difference on Solaris
     free = avail = os.sysconf('SC_AVPHYS_PAGES') * PAGE_SIZE
     used = total - free
-    percent = usage_percent(used, total, _round=1)
-    return svmem(total, avail, percent, used, free)
+    percent = usage_percent(used, total, round_=1)
+    return ntp.svmem(total, avail, percent, used, free)
 
 
 def swap_memory():
-    sin, sout = cext.swap_mem()
+    """Report swap memory metrics."""
+    sin, sout = _psutil.swap_mem()
     # XXX
     # we are supposed to get total/free by doing so:
-    # http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/
-    #     usr/src/cmd/swap/swap.c
+    # http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/cmd/swap/swap.c
     # ...nevertheless I can't manage to obtain the same numbers as 'swap'
     # cmdline utility, so let's parse its output (sigh!)
-    p = subprocess.Popen(['/usr/bin/env', 'PATH=/usr/sbin:/sbin:%s' %
-                          os.environ['PATH'], 'swap', '-l'],
-                         stdout=subprocess.PIPE)
-    stdout, stderr = p.communicate()
-    if PY3:
-        stdout = stdout.decode(sys.stdout.encoding)
+    p = subprocess.Popen(
+        [
+            '/usr/bin/env',
+            f"PATH=/usr/sbin:/sbin:{os.environ['PATH']}",
+            'swap',
+            '-l',
+        ],
+        stdout=subprocess.PIPE,
+    )
+    stdout, _ = p.communicate()
+    stdout = stdout.decode(sys.stdout.encoding)
     if p.returncode != 0:
-        raise RuntimeError("'swap -l' failed (retcode=%s)" % p.returncode)
+        msg = f"'swap -l' failed (retcode={p.returncode})"
+        raise RuntimeError(msg)
 
     lines = stdout.strip().split('\n')[1:]
     if not lines:
-        raise RuntimeError('no swap device(s) configured')
+        msg = 'no swap device(s) configured'
+        raise RuntimeError(msg)
     total = free = 0
     for line in lines:
         line = line.split()
-        t, f = line[-2:]
+        t, f = line[3:5]
         total += int(int(t) * 512)
         free += int(int(f) * 512)
     used = total - free
-    percent = usage_percent(used, total, _round=1)
-    return _common.sswap(total, used, free, percent,
-                         sin * PAGE_SIZE, sout * PAGE_SIZE)
+    percent = usage_percent(used, total, round_=1)
+    return ntp.sswap(
+        total, used, free, percent, sin * PAGE_SIZE, sout * PAGE_SIZE
+    )
 
 
 # =====================================================================
@@ -157,15 +151,15 @@ def swap_memory():
 
 
 def cpu_times():
-    """Return system-wide CPU times as a named tuple"""
-    ret = cext.per_cpu_times()
-    return scputimes(*[sum(x) for x in zip(*ret)])
+    """Return system-wide CPU times as a named tuple."""
+    ret = _psutil.per_cpu_times()
+    return ntp.scputimes(*[sum(x) for x in zip(*ret)])
 
 
 def per_cpu_times():
-    """Return system per-CPU times as a list of named tuples"""
-    ret = cext.per_cpu_times()
-    return [scputimes(*x) for x in ret]
+    """Return system per-CPU times as a list of named tuples."""
+    ret = _psutil.per_cpu_times()
+    return [ntp.scputimes(*x) for x in ret]
 
 
 def cpu_count_logical():
@@ -177,16 +171,16 @@ def cpu_count_logical():
         return None
 
 
-def cpu_count_physical():
-    """Return the number of physical CPUs in the system."""
-    return cext.cpu_count_phys()
+def cpu_count_cores():
+    """Return the number of CPU cores in the system."""
+    return _psutil.cpu_count_cores()
 
 
 def cpu_stats():
-    ctx_switches, interrupts, syscalls, traps = cext.cpu_stats()
+    """Return various CPU stats as a named tuple."""
+    ctx_switches, interrupts, syscalls, _traps = _psutil.cpu_stats()
     soft_interrupts = 0
-    return _common.scpustats(ctx_switches, interrupts, soft_interrupts,
-                             syscalls)
+    return ntp.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls)
 
 
 # =====================================================================
@@ -194,7 +188,7 @@ def cpu_stats():
 # =====================================================================
 
 
-disk_io_counters = cext.disk_io_counters
+disk_io_counters = _psutil.disk_io_counters
 disk_usage = _psposix.disk_usage
 
 
@@ -203,7 +197,7 @@ def disk_partitions(all=False):
     # TODO - the filtering logic should be better checked so that
     # it tries to reflect 'df' as much as possible
     retlist = []
-    partitions = cext.disk_partitions()
+    partitions = _psutil.disk_partitions()
     for partition in partitions:
         device, mountpoint, fstype, opts = partition
         if device == 'none':
@@ -212,9 +206,14 @@ def disk_partitions(all=False):
             # Differently from, say, Linux, we don't have a list of
             # common fs types so the best we can do, AFAIK, is to
             # filter by filesystem having a total size > 0.
-            if not disk_usage(mountpoint).total:
+            try:
+                if not disk_usage(mountpoint).total:
+                    continue
+            except OSError as err:
+                # https://github.com/giampaolo/psutil/issues/1674
+                debug(f"skipping {mountpoint!r}: {err}")
                 continue
-        ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
+        ntuple = ntp.sdiskpart(device, mountpoint, fstype, opts)
         retlist.append(ntuple)
     return retlist
 
@@ -224,8 +223,8 @@ def disk_partitions(all=False):
 # =====================================================================
 
 
-net_io_counters = cext.net_io_counters
-net_if_addrs = cext_posix.net_if_addrs
+net_io_counters = _psutil.net_io_counters
+net_if_addrs = _psutil.net_if_addrs
 
 
 def net_connections(kind, _pid=-1):
@@ -233,14 +232,8 @@ def net_connections(kind, _pid=-1):
     connections (as opposed to connections opened by one process only).
     Only INET sockets are returned (UNIX are not).
     """
-    cmap = _common.conn_tmap.copy()
-    if _pid == -1:
-        cmap.pop('unix', 0)
-    if kind not in cmap:
-        raise ValueError("invalid %r kind argument; choose between %s"
-                         % (kind, ', '.join([repr(x) for x in cmap])))
-    families, types = _common.conn_tmap[kind]
-    rawlist = cext.net_connections(_pid)
+    families, types = conn_tmap[kind]
+    rawlist = _psutil.net_connections(_pid)
     ret = set()
     for item in rawlist:
         fd, fam, type_, laddr, raddr, status, pid = item
@@ -248,25 +241,30 @@ def net_connections(kind, _pid=-1):
             continue
         if type_ not in types:
             continue
+        # TODO: refactor and use _common.conn_to_ntuple.
+        if fam in {AF_INET, AF_INET6}:
+            if laddr:
+                laddr = ntp.addr(*laddr)
+            if raddr:
+                raddr = ntp.addr(*raddr)
         status = TCP_STATUSES[status]
         fam = sockfam_to_enum(fam)
         type_ = socktype_to_enum(type_)
         if _pid == -1:
-            nt = _common.sconn(fd, fam, type_, laddr, raddr, status, pid)
+            nt = ntp.sconn(fd, fam, type_, laddr, raddr, status, pid)
         else:
-            nt = _common.pconn(fd, fam, type_, laddr, raddr, status)
+            nt = ntp.pconn(fd, fam, type_, laddr, raddr, status)
         ret.add(nt)
     return list(ret)
 
 
 def net_if_stats():
     """Get NIC stats (isup, duplex, speed, mtu)."""
-    ret = cext.net_if_stats()
+    ret = _psutil.net_if_stats()
     for name, items in ret.items():
         isup, duplex, speed, mtu = items
-        if hasattr(_common, 'NicDuplex'):
-            duplex = _common.NicDuplex(duplex)
-        ret[name] = _common.snicstats(isup, duplex, speed, mtu)
+        duplex = NicDuplex(duplex)
+        ret[name] = ntp.snicstats(isup, duplex, speed, mtu, '')
     return ret
 
 
@@ -277,24 +275,16 @@ def net_if_stats():
 
 def boot_time():
     """The system boot time expressed in seconds since the epoch."""
-    return cext.boot_time()
+    return _psutil.boot_time()
 
 
 def users():
-    """Return currently connected users as a list of namedtuples."""
+    """Return currently connected users as a list of named tuples."""
     retlist = []
-    rawlist = cext.users()
-    localhost = (':0.0', ':0')
+    rawlist = _psutil.users()
     for item in rawlist:
-        user, tty, hostname, tstamp, user_process = item
-        # note: the underlying C function includes entries about
-        # system boot, run level and others.  We might want
-        # to use them in the future.
-        if not user_process:
-            continue
-        if hostname in localhost:
-            hostname = 'localhost'
-        nt = _common.suser(user, tty, hostname, tstamp)
+        user, tty, hostname, tstamp, pid = item
+        nt = ntp.suser(user, tty, hostname, tstamp, pid)
         retlist.append(nt)
     return retlist
 
@@ -306,7 +296,8 @@ def users():
 
 def pids():
     """Returns a list of PIDs currently running on the system."""
-    return [int(x) for x in os.listdir(b(get_procfs_path())) if x.isdigit()]
+    path = get_procfs_path().encode(ENCODING)
+    return [int(x) for x in os.listdir(path) if x.isdigit()]
 
 
 def pid_exists(pid):
@@ -319,28 +310,34 @@ def wrap_exceptions(fun):
     EACCES and EPERM in NoSuchProcess or AccessDenied exceptions.
     """
 
+    @functools.wraps(fun)
     def wrapper(self, *args, **kwargs):
+        pid, ppid, name = self.pid, self._ppid, self._name
         try:
             return fun(self, *args, **kwargs)
-        except EnvironmentError as err:
+        except (FileNotFoundError, ProcessLookupError) as err:
             # ENOENT (no such file or directory) gets raised on open().
             # ESRCH (no such process) can get raised on read() if
             # process is gone in meantime.
-            if err.errno in (errno.ENOENT, errno.ESRCH):
-                if not pid_exists(self.pid):
-                    raise NoSuchProcess(self.pid, self._name)
-                else:
-                    raise ZombieProcess(self.pid, self._name, self._ppid)
-            if err.errno in (errno.EPERM, errno.EACCES):
-                raise AccessDenied(self.pid, self._name)
+            if not pid_exists(pid):
+                raise NoSuchProcess(pid, name) from err
+            raise ZombieProcess(pid, name, ppid) from err
+        except PermissionError as err:
+            raise AccessDenied(pid, name) from err
+        except OSError as err:
+            if pid == 0:
+                if 0 in pids():
+                    raise AccessDenied(pid, name) from err
+                raise
             raise
+
     return wrapper
 
 
-class Process(object):
+class Process:
     """Wrapper class around underlying C implementation."""
 
-    __slots__ = ["pid", "_name", "_ppid", "_procfs_path"]
+    __slots__ = ["_cache", "_name", "_ppid", "_procfs_path", "pid"]
 
     def __init__(self, pid):
         self.pid = pid
@@ -348,18 +345,54 @@ def __init__(self, pid):
         self._ppid = None
         self._procfs_path = get_procfs_path()
 
+    def _assert_alive(self):
+        """Raise NSP if the process disappeared on us."""
+        # For those C function who do not raise NSP, possibly returning
+        # incorrect or incomplete result.
+        os.stat(f"{self._procfs_path}/{self.pid}")
+
+    def oneshot_enter(self):
+        self._oneshot.cache_activate(self)
+        self._proc_name_and_args.cache_activate(self)
+        self._proc_cred.cache_activate(self)
+
+    def oneshot_exit(self):
+        self._oneshot.cache_deactivate(self)
+        self._proc_name_and_args.cache_deactivate(self)
+        self._proc_cred.cache_deactivate(self)
+
+    @wrap_exceptions
+    @memoize_when_activated
+    def _proc_name_and_args(self):
+        return _psutil.proc_name_and_args(self.pid, self._procfs_path)
+
+    @wrap_exceptions
+    @memoize_when_activated
+    def _oneshot(self):
+        if self.pid == 0 and not os.path.exists(
+            f"{self._procfs_path}/{self.pid}/psinfo"
+        ):
+            raise AccessDenied(self.pid)
+        ret = _psutil.proc_oneshot(self.pid, self._procfs_path)
+        assert len(ret) == len(proc_info_map)
+        return ret
+
+    @wrap_exceptions
+    @memoize_when_activated
+    def _proc_cred(self):
+        return _psutil.proc_cred(self.pid, self._procfs_path)
+
     @wrap_exceptions
     def name(self):
         # note: max len == 15
-        return cext.proc_name_and_args(self.pid, self._procfs_path)[0]
+        return self._proc_name_and_args()[0]
 
     @wrap_exceptions
     def exe(self):
         try:
-            return os.readlink(
-                "%s/%s/path/a.out" % (self._procfs_path, self.pid))
+            return os.readlink(f"{self._procfs_path}/{self.pid}/path/a.out")
         except OSError:
-            pass    # continue and guess the exe name from the cmdline
+            pass  # continue and guess the exe name from the cmdline
         # Will be guessed later from cmdline but we want to explicitly
         # invoke cmdline here in order to get an AccessDenied
         # exception if the user has not enough privileges.
@@ -368,67 +401,66 @@ def exe(self):
 
     @wrap_exceptions
     def cmdline(self):
-        return cext.proc_name_and_args(
-            self.pid, self._procfs_path)[1].split(' ')
+        return self._proc_name_and_args()[1]
+
+    @wrap_exceptions
+    def environ(self):
+        return _psutil.proc_environ(self.pid, self._procfs_path)
 
     @wrap_exceptions
     def create_time(self):
-        return cext.proc_basic_info(self.pid, self._procfs_path)[3]
+        return self._oneshot()[proc_info_map['create_time']]
 
     @wrap_exceptions
     def num_threads(self):
-        return cext.proc_basic_info(self.pid, self._procfs_path)[5]
+        return self._oneshot()[proc_info_map['num_threads']]
 
     @wrap_exceptions
     def nice_get(self):
-        # For some reason getpriority(3) return ESRCH (no such process)
-        # for certain low-pid processes, no matter what (even as root).
-        # The process actually exists though, as it has a name,
-        # creation time, etc.
-        # The best thing we can do here appears to be raising AD.
-        # Note: tested on Solaris 11; on Open Solaris 5 everything is
-        # fine.
-        try:
-            return cext_posix.getpriority(self.pid)
-        except EnvironmentError as err:
-            # 48 is 'operation not supported' but errno does not expose
-            # it. It occurs for low system pids.
-            if err.errno in (errno.ENOENT, errno.ESRCH, 48):
-                if pid_exists(self.pid):
-                    raise AccessDenied(self.pid, self._name)
-            raise
+        # Note #1: getpriority(3) doesn't work for realtime processes.
+        # Psinfo is what ps uses, see:
+        # https://github.com/giampaolo/psutil/issues/1194
+        return self._oneshot()[proc_info_map['nice']]
 
     @wrap_exceptions
     def nice_set(self, value):
-        if self.pid in (2, 3):
+        if self.pid in {2, 3}:
             # Special case PIDs: internally setpriority(3) return ESRCH
             # (no such process), no matter what.
             # The process actually exists though, as it has a name,
             # creation time, etc.
             raise AccessDenied(self.pid, self._name)
-        return cext_posix.setpriority(self.pid, value)
+        return _psutil.proc_priority_set(self.pid, value)
 
     @wrap_exceptions
     def ppid(self):
-        self._ppid = cext.proc_basic_info(self.pid, self._procfs_path)[0]
+        self._ppid = self._oneshot()[proc_info_map['ppid']]
         return self._ppid
 
     @wrap_exceptions
     def uids(self):
-        real, effective, saved, _, _, _ = \
-            cext.proc_cred(self.pid, self._procfs_path)
-        return _common.puids(real, effective, saved)
+        try:
+            real, effective, saved, _, _, _ = self._proc_cred()
+        except AccessDenied:
+            real = self._oneshot()[proc_info_map['uid']]
+            effective = self._oneshot()[proc_info_map['euid']]
+            saved = None
+        return ntp.puids(real, effective, saved)
 
     @wrap_exceptions
     def gids(self):
-        _, _, _, real, effective, saved = \
-            cext.proc_cred(self.pid, self._procfs_path)
-        return _common.puids(real, effective, saved)
+        try:
+            _, _, _, real, effective, saved = self._proc_cred()
+        except AccessDenied:
+            real = self._oneshot()[proc_info_map['gid']]
+            effective = self._oneshot()[proc_info_map['egid']]
+            saved = None
+        return ntp.pgids(real, effective, saved)
 
     @wrap_exceptions
     def cpu_times(self):
         try:
-            times = cext.proc_cpu_times(self.pid, self._procfs_path)
+            times = _psutil.proc_cpu_times(self.pid, self._procfs_path)
         except OSError as err:
             if err.errno == errno.EOVERFLOW and not IS_64_BIT:
                 # We may get here if we attempt to query a 64bit process
@@ -441,54 +473,50 @@ def cpu_times(self):
                 times = (0.0, 0.0, 0.0, 0.0)
             else:
                 raise
-        return _common.pcputimes(*times)
+        return ntp.pcputimes(*times)
+
+    @wrap_exceptions
+    def cpu_num(self):
+        return _psutil.proc_cpu_num(self.pid, self._procfs_path)
 
     @wrap_exceptions
     def terminal(self):
         procfs_path = self._procfs_path
         hit_enoent = False
-        tty = wrap_exceptions(
-            cext.proc_basic_info(self.pid, self._procfs_path)[0])
-        if tty != cext.PRNODEV:
+        tty = wrap_exceptions(self._oneshot()[proc_info_map['ttynr']])
+        if tty != _psutil.PRNODEV:
             for x in (0, 1, 2, 255):
                 try:
-                    return os.readlink(
-                        '%s/%d/path/%d' % (procfs_path, self.pid, x))
-                except OSError as err:
-                    if err.errno == errno.ENOENT:
-                        hit_enoent = True
-                        continue
-                    raise
+                    return os.readlink(f"{procfs_path}/{self.pid}/path/{x}")
+                except FileNotFoundError:
+                    hit_enoent = True
+                    continue
         if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('%s/%s' % (procfs_path, self.pid))
+            self._assert_alive()
 
     @wrap_exceptions
     def cwd(self):
         # /proc/PID/path/cwd may not be resolved by readlink() even if
         # it exists (ls shows it). If that's the case and the process
         # is still alive return None (we can return None also on BSD).
-        # Reference: http://goo.gl/55XgO
+        # Reference: https://groups.google.com/g/comp.unix.solaris/c/tcqvhTNFCAs
         procfs_path = self._procfs_path
         try:
-            return os.readlink("%s/%s/path/cwd" % (procfs_path, self.pid))
-        except OSError as err:
-            if err.errno == errno.ENOENT:
-                os.stat("%s/%s" % (procfs_path, self.pid))
-                return None
-            raise
+            return os.readlink(f"{procfs_path}/{self.pid}/path/cwd")
+        except FileNotFoundError:
+            os.stat(f"{procfs_path}/{self.pid}")  # raise NSP or AD
+            return ""
 
     @wrap_exceptions
     def memory_info(self):
-        ret = cext.proc_basic_info(self.pid, self._procfs_path)
-        rss, vms = ret[1] * 1024, ret[2] * 1024
-        return pmem(rss, vms)
-
-    memory_full_info = memory_info
+        ret = self._oneshot()
+        rss = ret[proc_info_map['rss']] * 1024
+        vms = ret[proc_info_map['vms']] * 1024
+        return ntp.pmem(rss, vms)
 
     @wrap_exceptions
     def status(self):
-        code = cext.proc_basic_info(self.pid, self._procfs_path)[6]
+        code = self._oneshot()[proc_info_map['status']]
         # XXX is '?' legit? (we're not supposed to return it anyway)
         return PROC_STATUSES.get(code, '?')
 
@@ -496,14 +524,15 @@ def status(self):
     def threads(self):
         procfs_path = self._procfs_path
         ret = []
-        tids = os.listdir('%s/%d/lwp' % (procfs_path, self.pid))
+        tids = os.listdir(f"{procfs_path}/{self.pid}/lwp")
         hit_enoent = False
         for tid in tids:
             tid = int(tid)
             try:
-                utime, stime = cext.query_process_thread(
-                    self.pid, tid, procfs_path)
-            except EnvironmentError as err:
+                utime, stime = _psutil.query_process_thread(
+                    self.pid, tid, procfs_path
+                )
+            except OSError as err:
                 if err.errno == errno.EOVERFLOW and not IS_64_BIT:
                     # We may get here if we attempt to query a 64bit process
                     # with a 32bit python.
@@ -519,11 +548,10 @@ def threads(self):
                     continue
                 raise
             else:
-                nt = _common.pthread(tid, utime, stime)
+                nt = ntp.pthread(tid, utime, stime)
                 ret.append(nt)
         if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('%s/%s' % (procfs_path, self.pid))
+            self._assert_alive()
         return ret
 
     @wrap_exceptions
@@ -531,60 +559,79 @@ def open_files(self):
         retlist = []
         hit_enoent = False
         procfs_path = self._procfs_path
-        pathdir = '%s/%d/path' % (procfs_path, self.pid)
-        for fd in os.listdir('%s/%d/fd' % (procfs_path, self.pid)):
+        pathdir = f"{procfs_path}/{self.pid}/path"
+        for fd in os.listdir(f"{procfs_path}/{self.pid}/fd"):
             path = os.path.join(pathdir, fd)
             if os.path.islink(path):
                 try:
                     file = os.readlink(path)
-                except OSError as err:
-                    # ENOENT == file which is gone in the meantime
-                    if err.errno == errno.ENOENT:
-                        hit_enoent = True
-                        continue
-                    raise
+                except FileNotFoundError:
+                    hit_enoent = True
+                    continue
                 else:
                     if isfile_strict(file):
-                        retlist.append(_common.popenfile(file, int(fd)))
+                        retlist.append(ntp.popenfile(file, int(fd)))
         if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('%s/%s' % (procfs_path, self.pid))
+            self._assert_alive()
         return retlist
 
     def _get_unix_sockets(self, pid):
         """Get UNIX sockets used by process by parsing 'pfiles' output."""
         # TODO: rewrite this in C (...but the damn netstat source code
         # does not include this part! Argh!!)
-        cmd = "pfiles %s" % pid
-        p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
+        cmd = ["pfiles", str(pid)]
+        p = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
         stdout, stderr = p.communicate()
-        if PY3:
-            stdout, stderr = [x.decode(sys.stdout.encoding)
-                              for x in (stdout, stderr)]
+        stdout, stderr = (
+            x.decode(sys.stdout.encoding) for x in (stdout, stderr)
+        )
         if p.returncode != 0:
             if 'permission denied' in stderr.lower():
                 raise AccessDenied(self.pid, self._name)
             if 'no such process' in stderr.lower():
                 raise NoSuchProcess(self.pid, self._name)
-            raise RuntimeError("%r command error\n%s" % (cmd, stderr))
-
-        lines = stdout.split('\n')[2:]
-        for i, line in enumerate(lines):
-            line = line.lstrip()
-            if line.startswith('sockname: AF_UNIX'):
-                path = line.split(' ', 2)[2]
-                type = lines[i - 2].strip()
-                if type == 'SOCK_STREAM':
+            if self.status() == ProcessStatus.STATUS_ZOMBIE:
+                # pfiles can't examine zombies
+                raise ZombieProcess(self.pid, self._name, self._ppid)
+            msg = f"{cmd!r} command error\n{stderr}"
+            raise RuntimeError(msg)
+
+        blocks = []
+        cur = None
+        for line in stdout.split('\n'):
+            line = line.strip()
+            first, _, rest = line.partition(':')
+            if first.isdigit() and rest.lstrip().startswith('S_IF'):
+                cur = None
+                if 'S_IFSOCK' in rest:
+                    cur = (int(first), [])
+                    blocks.append(cur)
+            elif cur is not None:
+                cur[1].append(line)
+        for fd, block in blocks:
+            path = None
+            type = -1
+            for line in block:
+                if line.startswith('sockname: AF_UNIX'):
+                    path = line[len('sockname: AF_UNIX') :].strip()
+                elif line.startswith('SOCK_STREAM'):
                     type = socket.SOCK_STREAM
-                elif type == 'SOCK_DGRAM':
+                elif line.startswith('SOCK_DGRAM'):
                     type = socket.SOCK_DGRAM
-                else:
-                    type = -1
-                yield (-1, socket.AF_UNIX, type, path, "", _common.CONN_NONE)
+            if path is not None:
+                yield (
+                    fd,
+                    socket.AF_UNIX,
+                    type,
+                    path,
+                    "",
+                    ConnectionStatus.CONN_NONE,
+                )
 
     @wrap_exceptions
-    def connections(self, kind='inet'):
+    def net_connections(self, kind='inet'):
         ret = net_connections(kind, _pid=self.pid)
         # The underlying C implementation retrieves all OS connections
         # and filters them by PID.  At this point we can't tell whether
@@ -593,12 +640,13 @@ def connections(self, kind='inet'):
         # is no longer there.
         if not ret:
             # will raise NSP if process is gone
-            os.stat('%s/%s' % (self._procfs_path, self.pid))
+            os.stat(f"{self._procfs_path}/{self.pid}")
 
         # UNIX sockets
-        if kind in ('all', 'unix'):
-            ret.extend([_common.pconn(*conn) for conn in
-                        self._get_unix_sockets(self.pid)])
+        if kind in {'all', 'unix'}:
+            ret.extend(
+                [ntp.pconn(*conn) for conn in self._get_unix_sockets(self.pid)]
+            )
         return ret
 
     nt_mmap_grouped = namedtuple('mmap', 'path rss anon locked')
@@ -607,13 +655,12 @@ def connections(self, kind='inet'):
     @wrap_exceptions
     def memory_maps(self):
         def toaddr(start, end):
-            return '%s-%s' % (hex(start)[2:].strip('L'),
-                              hex(end)[2:].strip('L'))
+            return f"{hex(start)[2:].strip('L')}-{hex(end)[2:].strip('L')}"
 
         procfs_path = self._procfs_path
         retlist = []
         try:
-            rawlist = cext.proc_memory_maps(self.pid, procfs_path)
+            rawlist = _psutil.proc_memory_maps(self.pid, procfs_path)
         except OSError as err:
             if err.errno == errno.EOVERFLOW and not IS_64_BIT:
                 # We may get here if we attempt to query a 64bit process
@@ -632,38 +679,39 @@ def toaddr(start, end):
             addr = toaddr(addr, addrsize)
             if not name.startswith('['):
                 try:
-                    name = os.readlink(
-                        '%s/%s/path/%s' % (procfs_path, self.pid, name))
+                    name = os.readlink(f"{procfs_path}/{self.pid}/path/{name}")
                 except OSError as err:
                     if err.errno == errno.ENOENT:
                         # sometimes the link may not be resolved by
                         # readlink() even if it exists (ls shows it).
                         # If that's the case we just return the
                         # unresolved link path.
-                        # This seems an incosistency with /proc similar
+                        # This seems an inconsistency with /proc similar
                         # to: http://goo.gl/55XgO
-                        name = '%s/%s/path/%s' % (procfs_path, self.pid, name)
+                        name = f"{procfs_path}/{self.pid}/path/{name}"
                         hit_enoent = True
                     else:
                         raise
             retlist.append((addr, perm, name, rss, anon, locked))
         if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('%s/%s' % (procfs_path, self.pid))
+            self._assert_alive()
         return retlist
 
     @wrap_exceptions
     def num_fds(self):
-        return len(os.listdir("%s/%s/fd" % (self._procfs_path, self.pid)))
+        return len(os.listdir(f"{self._procfs_path}/{self.pid}/fd"))
 
     @wrap_exceptions
     def num_ctx_switches(self):
-        return _common.pctxsw(
-            *cext.proc_num_ctx_switches(self.pid, self._procfs_path))
+        return ntp.pctxsw(
+            *_psutil.proc_num_ctx_switches(self.pid, self._procfs_path)
+        )
+
+    @wrap_exceptions
+    def page_faults(self):
+        ret = _psutil.proc_page_faults(self.pid, self._procfs_path)
+        return ntp.ppagefaults(*ret)
 
     @wrap_exceptions
     def wait(self, timeout=None):
-        try:
-            return _psposix.wait_pid(self.pid, timeout)
-        except _psposix.TimeoutExpired:
-            raise TimeoutExpired(timeout, self.pid, self._name)
+        return _psposix.wait_pid(self.pid, timeout)
diff --git a/psutil/_psutil_aix.c b/psutil/_psutil_aix.c
new file mode 100644
index 0000000000..bfdab95f2d
--- /dev/null
+++ b/psutil/_psutil_aix.c
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// AIX support is experimental at this time.
+// The following functions and methods are unsupported on the AIX platform:
+// - psutil.Process.memory_maps
+//
+// Known limitations:
+// - psutil.Process.io_counters read count is always 0
+// - psutil.Process.io_counters may not be available on older AIX versions
+// - psutil.Process.threads may not be available on older AIX versions
+// - psutil.net_io_counters may not be available on older AIX versions
+// - reading basic process info may fail or return incorrect values when
+//   process is starting (see IBM APAR IV58499 - fixed in newer AIX versions)
+// - sockets and pipes may not be counted in num_fds (fixed in newer AIX
+//   versions)
+//
+// Useful resources:
+// - proc filesystem:
+// http://www-01.ibm.com/support/knowledgecenter/ssw_aix_72/com.ibm.aix.files/proc.htm
+// - libperfstat:
+// http://www-01.ibm.com/support/knowledgecenter/ssw_aix_72/com.ibm.aix.files/libperfstat.h.htm
+
+#include <Python.h>
+#include <sys/proc.h>
+#include <netinet/tcp_fsm.h>
+#include <libperfstat.h>  // CURR_VERSION_* guards below
+
+#include "arch/all/init.h"
+#include "arch/aix/init.h"
+
+
+static PyMethodDef mod_methods[] = {
+    // --- process-related functions
+    {"proc_args", psutil_proc_args, METH_VARARGS},
+    {"proc_cpu_times", psutil_proc_cpu_times, METH_VARARGS},
+    {"proc_cred", psutil_proc_cred, METH_VARARGS},
+    {"proc_environ", psutil_proc_environ, METH_VARARGS},
+    {"proc_name", psutil_proc_name, METH_VARARGS},
+    {"proc_oneshot", psutil_proc_oneshot, METH_VARARGS},
+#ifdef CURR_VERSION_THREAD
+    {"proc_threads", psutil_proc_threads, METH_VARARGS},
+#endif
+#ifdef CURR_VERSION_PROCESS
+    {"proc_io_counters", psutil_proc_io_counters, METH_VARARGS},
+#endif
+    {"proc_num_ctx_switches", psutil_proc_num_ctx_switches, METH_VARARGS},
+
+    // --- system-related functions
+    {"boot_time", psutil_boot_time, METH_VARARGS},
+    {"disk_io_counters", psutil_disk_io_counters, METH_VARARGS},
+    {"disk_partitions", psutil_disk_partitions, METH_VARARGS},
+    {"per_cpu_times", psutil_per_cpu_times, METH_VARARGS},
+    {"swap_mem", psutil_swap_mem, METH_VARARGS},
+    {"virtual_mem", psutil_virtual_mem, METH_VARARGS},
+#if defined(CURR_VERSION_NETINTERFACE) && CURR_VERSION_NETINTERFACE >= 3
+    {"net_io_counters", psutil_net_io_counters, METH_VARARGS},
+#endif
+    {"cpu_stats", psutil_cpu_stats, METH_VARARGS},
+    {"net_connections", psutil_net_connections, METH_VARARGS},
+    {"net_if_stats", psutil_net_if_stats, METH_VARARGS},
+
+    // --- others
+    {"check_pid_range", psutil_check_pid_range, METH_VARARGS},
+    {"set_debug", psutil_set_debug, METH_VARARGS},
+
+    {NULL, NULL, 0, NULL}
+};
+
+
+static int
+psutil_add_constants(PyObject *mod) {
+    PSUTIL_ADD_INT(mod, "version", PSUTIL_VERSION);
+    PSUTIL_ADD_INT(mod, "SIDL", SIDL);
+    PSUTIL_ADD_INT(mod, "SZOMB", SZOMB);
+    PSUTIL_ADD_INT(mod, "SACTIVE", SACTIVE);
+    PSUTIL_ADD_INT(mod, "SSWAP", SSWAP);
+    PSUTIL_ADD_INT(mod, "SSTOP", SSTOP);
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSED", TCPS_CLOSED);
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSING", TCPS_CLOSING);
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT);
+    PSUTIL_ADD_INT(mod, "TCPS_LISTEN", TCPS_LISTEN);
+    PSUTIL_ADD_INT(mod, "TCPS_ESTABLISHED", TCPS_ESTABLISHED);
+    PSUTIL_ADD_INT(mod, "TCPS_SYN_SENT", TCPS_SYN_SENT);
+    PSUTIL_ADD_INT(mod, "TCPS_SYN_RCVD", TCPS_SYN_RECEIVED);
+    PSUTIL_ADD_INT(mod, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1);
+    PSUTIL_ADD_INT(mod, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2);
+    PSUTIL_ADD_INT(mod, "TCPS_LAST_ACK", TCPS_LAST_ACK);
+    PSUTIL_ADD_INT(mod, "TCPS_TIME_WAIT", TCPS_TIME_WAIT);
+    PSUTIL_ADD_INT(mod, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE);
+    return 0;
+}
+
+
+static int
+psutil_exec(PyObject *mod) {
+    if (psutil_setup() != 0)
+        return -1;
+    if (psutil_posix_add_constants(mod) != 0)
+        return -1;
+    if (psutil_posix_add_methods(mod) != 0)
+        return -1;
+    if (psutil_add_exceptions(mod) != 0)
+        return -1;
+    if (psutil_add_constants(mod) != 0)
+        return -1;
+    return 0;
+}
+
+
+PyMODINIT_FUNC
+PyInit__psutil(void) {
+    return psutil_mod_init("_psutil", mod_methods, psutil_exec);
+}
diff --git a/psutil/_psutil_bsd.c b/psutil/_psutil_bsd.c
index 4e0e2d98fc..aaea55f5bc 100644
--- a/psutil/_psutil_bsd.c
+++ b/psutil/_psutil_bsd.c
@@ -1,1136 +1,159 @@
 /*
- * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil (OpenBSD).
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola', Landry Breuil
+ * (OpenBSD implementation), Ryo Onodera (NetBSD implementation).
  * All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
- *
- * Platform-specific module methods for FreeBSD and OpenBSD.
-
- * OpenBSD references:
- * - OpenBSD source code: http://anoncvs.spacehopper.org/openbsd-src/
- *
- * OpenBSD / NetBSD: missing APIs compared to FreeBSD implementation:
- * - psutil.net_connections()
- * - psutil.Process.get/set_cpu_affinity()  (not supported natively)
- * - psutil.Process.memory_maps()
  */
 
-#if defined(__NetBSD__)
-#define _KMEMUSER
-#endif
-
 #include <Python.h>
-#include <assert.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <signal.h>
-#include <fcntl.h>
-#include <paths.h>
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/sysctl.h>
-#include <sys/user.h>
+#include <sys/types.h>  // NODEV
 #include <sys/proc.h>
-#include <sys/file.h>
-#include <sys/socket.h>
-#include <net/route.h>
-#include <sys/socketvar.h>    // for struct xsocket
-#include <sys/un.h>
-#include <sys/unpcb.h>
-// for xinpcb struct
-#include <netinet/in.h>
-#include <netinet/in_systm.h>
-#include <netinet/ip.h>
-#include <netinet/in_pcb.h>
-#include <netinet/tcp.h>
-#include <netinet/tcp_timer.h>
-#include <netinet/ip_var.h>
-#include <netinet/tcp_var.h>   // for struct xtcpcb
-#include <netinet/tcp_fsm.h>   // for TCP connection states
-#include <arpa/inet.h>         // for inet_ntop()
-
-#include <sys/mount.h>
-
-#include <net/if.h>       // net io counters
-#include <net/if_dl.h>
-#include <net/route.h>
-
-#include <netinet/in.h>   // process open files/connections
-#include <sys/un.h>
-
-#include "_psutil_common.h"
-
-#ifdef __FreeBSD__
-    #include "arch/bsd/freebsd.h"
-    #include "arch/bsd/freebsd_socks.h"
-#elif __OpenBSD__
-    #include "arch/bsd/openbsd.h"
-#elif __NetBSD__
-    #include "arch/bsd/netbsd.h"
-    #include "arch/bsd/netbsd_socks.h"
-#endif
-
-#ifdef __FreeBSD__
-    #include <net/if_media.h>
-    #include <devstat.h>  // get io counters
-    #include <libutil.h>  // process open files, shared libs (kinfo_getvmmap)
-    #if __FreeBSD_version < 900000
-        #include <utmp.h>  // system users
-    #else
-        #include <utmpx.h>
-    #endif
-#endif
-
-#ifdef __OpenBSD__
-    #include <utmp.h>
-    #include <sys/vnode.h>  // for VREG
-    #define _KERNEL  // for DTYPE_VNODE
-    #include <sys/file.h>
-    #undef _KERNEL
-    #include <sys/sched.h>  // for CPUSTATES & CP_*
-#endif
-
-#if defined(__NetBSD__)
-    #include <utmpx.h>
-    #include <sys/vnode.h>  // for VREG
-    #include <sys/sched.h>  // for CPUSTATES & CP_*
-    #ifndef DTYPE_VNODE
-    #define DTYPE_VNODE 1
-    #endif
-#endif
-
-
-// convert a timeval struct to a double
-#define PSUTIL_TV2DOUBLE(t) ((t).tv_sec + (t).tv_usec / 1000000.0)
-
-#ifdef __FreeBSD__
-    // convert a bintime struct to milliseconds
-    #define PSUTIL_BT2MSEC(bt) (bt.sec * 1000 + (((uint64_t) 1000000000 * \
-                           (uint32_t) (bt.frac >> 32) ) >> 32 ) / 1000000)
-#endif
-
-#if defined(__OpenBSD__) || defined (__NetBSD__)
-    #define PSUTIL_KPT2DOUBLE(t) (t ## _sec + t ## _usec / 1000000.0)
-#endif
-
-
-/*
- * Return a Python list of all the PIDs running on the system.
- */
-static PyObject *
-psutil_pids(PyObject *self, PyObject *args) {
-    kinfo_proc *proclist = NULL;
-    kinfo_proc *orig_address = NULL;
-    size_t num_processes;
-    size_t idx;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_pid = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (psutil_get_proc_list(&proclist, &num_processes) != 0) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "failed to retrieve process list.");
-        goto error;
-    }
-
-    if (num_processes > 0) {
-        orig_address = proclist; // save so we can free it after we're done
-        for (idx = 0; idx < num_processes; idx++) {
-#ifdef __FreeBSD__
-            py_pid = Py_BuildValue("i", proclist->ki_pid);
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-            py_pid = Py_BuildValue("i", proclist->p_pid);
-#endif
-            if (!py_pid)
-                goto error;
-            if (PyList_Append(py_retlist, py_pid))
-                goto error;
-            Py_DECREF(py_pid);
-            proclist++;
-        }
-        free(orig_address);
-    }
-
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_pid);
-    Py_DECREF(py_retlist);
-    if (orig_address != NULL)
-        free(orig_address);
-    return NULL;
-}
-
-
-/*
- * Return a Python float indicating the system boot time expressed in
- * seconds since the epoch.
- */
-static PyObject *
-psutil_boot_time(PyObject *self, PyObject *args) {
-    // fetch sysctl "kern.boottime"
-    static int request[2] = { CTL_KERN, KERN_BOOTTIME };
-    struct timeval boottime;
-    size_t len = sizeof(boottime);
-
-    if (sysctl(request, 2, &boottime, &len, NULL, 0) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-    return Py_BuildValue("d", (double)boottime.tv_sec);
-}
-
-
-/*
- * Return process name from kinfo_proc as a Python string.
- */
-static PyObject *
-psutil_proc_name(PyObject *self, PyObject *args) {
-    long pid;
-    kinfo_proc kp;
-    char str[1000];
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-
-#ifdef __FreeBSD__
-    sprintf(str, "%s", kp.ki_comm);
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-    sprintf(str, "%s", kp.p_comm);
-#endif
-
-#if PY_MAJOR_VERSION >= 3
-    return PyUnicode_DecodeFSDefault(str);
-#else
-    return Py_BuildValue("s", str);
-#endif
-}
-
-
-/*
- * Return process cmdline as a Python list of cmdline arguments.
- */
-static PyObject *
-psutil_proc_cmdline(PyObject *self, PyObject *args) {
-    long pid;
-    PyObject *py_retlist = NULL;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    py_retlist = psutil_get_cmdline(pid);
-    // psutil_get_cmdline() returns NULL only if psutil_cmd_args
-    // failed with ESRCH (no process with that PID)
-    if (NULL == py_retlist)
-        return PyErr_SetFromErrno(PyExc_OSError);
-    return Py_BuildValue("N", py_retlist);
-}
-
-
-/*
- * Return process parent pid from kinfo_proc as a Python integer.
- */
-static PyObject *
-psutil_proc_ppid(PyObject *self, PyObject *args) {
-    long pid;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-#ifdef __FreeBSD__
-    return Py_BuildValue("l", (long)kp.ki_ppid);
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-    return Py_BuildValue("l", (long)kp.p_ppid);
-#endif
-}
-
-
-/*
- * Return process status as a Python integer.
- */
-static PyObject *
-psutil_proc_status(PyObject *self, PyObject *args) {
-    long pid;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-#ifdef __FreeBSD__
-    return Py_BuildValue("i", (int)kp.ki_stat);
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-    return Py_BuildValue("i", (int)kp.p_stat);
-#endif
-}
-
-
-/*
- * Return process real, effective and saved user ids from kinfo_proc
- * as a Python tuple.
- */
-static PyObject *
-psutil_proc_uids(PyObject *self, PyObject *args) {
-    long pid;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("lll",
-#ifdef __FreeBSD__
-                         (long)kp.ki_ruid,
-                         (long)kp.ki_uid,
-                         (long)kp.ki_svuid);
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-                         (long)kp.p_ruid,
-                         (long)kp.p_uid,
-                         (long)kp.p_svuid);
-#endif
-}
-
-
-/*
- * Return process real, effective and saved group ids from kinfo_proc
- * as a Python tuple.
- */
-static PyObject *
-psutil_proc_gids(PyObject *self, PyObject *args) {
-    long pid;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("lll",
-#ifdef __FreeBSD__
-                         (long)kp.ki_rgid,
-                         (long)kp.ki_groups[0],
-                         (long)kp.ki_svuid);
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-                         (long)kp.p_rgid,
-                         (long)kp.p_groups[0],
-                         (long)kp.p_svuid);
-#endif
-}
-
-
-/*
- * Return process real, effective and saved group ids from kinfo_proc
- * as a Python tuple.
- */
-static PyObject *
-psutil_proc_tty_nr(PyObject *self, PyObject *args) {
-    long pid;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-#ifdef __FreeBSD__
-    return Py_BuildValue("i", kp.ki_tdev);
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-    return Py_BuildValue("i", kp.p_tdev);
-#endif
-}
-
-
-/*
- * Return the number of context switches performed by process as a tuple.
- */
-static PyObject *
-psutil_proc_num_ctx_switches(PyObject *self, PyObject *args) {
-    long pid;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("(ll)",
-#ifdef __FreeBSD__
-                         kp.ki_rusage.ru_nvcsw,
-                         kp.ki_rusage.ru_nivcsw);
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-                         kp.p_uru_nvcsw,
-                         kp.p_uru_nivcsw);
-#endif
-}
-
-
-/*
- * Return a Python tuple (user_time, kernel_time)
- */
-static PyObject *
-psutil_proc_cpu_times(PyObject *self, PyObject *args) {
-    long pid;
-    double user_t, sys_t, children_user_t, children_sys_t;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    // convert from microseconds to seconds
-#ifdef __FreeBSD__
-    user_t = PSUTIL_TV2DOUBLE(kp.ki_rusage.ru_utime);
-    sys_t = PSUTIL_TV2DOUBLE(kp.ki_rusage.ru_stime);
-    children_user_t = PSUTIL_TV2DOUBLE(kp.ki_rusage_ch.ru_utime);
-    children_sys_t = PSUTIL_TV2DOUBLE(kp.ki_rusage_ch.ru_stime);
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-    user_t = PSUTIL_KPT2DOUBLE(kp.p_uutime);
-    sys_t = PSUTIL_KPT2DOUBLE(kp.p_ustime);
-    // OpenBSD and NetBSD provide children user + system times summed
-    // together (no distinction).
-    children_user_t = kp.p_uctime_sec + kp.p_uctime_usec / 1000000.0;
-    children_sys_t = children_user_t;
-#endif
-    return Py_BuildValue("(dddd)",
-                         user_t, sys_t, children_user_t, children_sys_t);
-}
-
-
-/*
- * Return the number of logical CPUs in the system.
- * XXX this could be shared with OSX
- */
-static PyObject *
-psutil_cpu_count_logical(PyObject *self, PyObject *args) {
-    int mib[2];
-    int ncpu;
-    size_t len;
-
-    mib[0] = CTL_HW;
-    mib[1] = HW_NCPU;
-    len = sizeof(ncpu);
-
-    if (sysctl(mib, 2, &ncpu, &len, NULL, 0) == -1)
-        Py_RETURN_NONE;  // mimic os.cpu_count()
-    else
-        return Py_BuildValue("i", ncpu);
-}
-
-
-/*
- * Return a Python float indicating the process create time expressed in
- * seconds since the epoch.
- */
-static PyObject *
-psutil_proc_create_time(PyObject *self, PyObject *args) {
-    long pid;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-#ifdef __FreeBSD__
-    return Py_BuildValue("d", PSUTIL_TV2DOUBLE(kp.ki_start));
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-    return Py_BuildValue("d", PSUTIL_KPT2DOUBLE(kp.p_ustart));
-#endif
-}
-
-
-/*
- * Return a Python float indicating the process create time expressed in
- * seconds since the epoch.
- */
-static PyObject *
-psutil_proc_io_counters(PyObject *self, PyObject *args) {
-    long pid;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    // there's apparently no way to determine bytes count, hence return -1.
-    return Py_BuildValue("(llll)",
-#ifdef __FreeBSD__
-                         kp.ki_rusage.ru_inblock,
-                         kp.ki_rusage.ru_oublock,
-#elif defined(__OpenBSD__) || defined(__NetBSD__)
-                         kp.p_uru_inblock,
-                         kp.p_uru_oublock,
-#endif
-                         -1,
-                         -1);
-}
-
-
-/*
- * Return extended memory info for a process as a Python tuple.
- */
-static PyObject *
-psutil_proc_memory_info(PyObject *self, PyObject *args) {
-    long pagesize = sysconf(_SC_PAGESIZE);
-    long pid;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-
-    return Py_BuildValue(
-        "(lllll)",
-#ifdef __FreeBSD__
-        (long) kp.ki_rssize * pagesize,  // rss
-        (long) kp.ki_size,  // vms
-        (long) kp.ki_tsize * pagesize,  // text
-        (long) kp.ki_dsize * pagesize,  // data
-        (long) kp.ki_ssize * pagesize  // stack
-#else
-        (long) kp.p_vm_rssize * pagesize,    // rss
-    #ifdef __OpenBSD__
-        // VMS, this is how ps determines it on OpenBSD:
-        // http://anoncvs.spacehopper.org/openbsd-src/tree/bin/ps/print.c#n461
-        // vms
-        (long) (kp.p_vm_dsize + kp.p_vm_ssize + kp.p_vm_tsize) * pagesize,
-    #elif __NetBSD__
-        // VMS, this is how top determines it on NetBSD:
-        // ftp://ftp.iij.ad.jp/pub/NetBSD/NetBSD-release-6/src/external/bsd/
-        //     top/dist/machine/m_netbsd.c
-        (long) kp.p_vm_msize * pagesize,  // vms
-    #endif
-        (long) kp.p_vm_tsize * pagesize,  // text
-        (long) kp.p_vm_dsize * pagesize,  // data
-        (long) kp.p_vm_ssize * pagesize  // stack
-#endif
-    );
-}
-
-
-/*
- * Return a Python tuple representing user, kernel and idle CPU times
- */
-static PyObject *
-psutil_cpu_times(PyObject *self, PyObject *args) {
-#if defined(__NetBSD__)
-    u_int64_t cpu_time[CPUSTATES];
-#else
-    long cpu_time[CPUSTATES];
-#endif
-    size_t size = sizeof(cpu_time);
-    int ret;
-
-#if defined(__FreeBSD__) || defined(__NetBSD__)
-    ret = sysctlbyname("kern.cp_time", &cpu_time, &size, NULL, 0);
-#elif __OpenBSD__
-    int mib[] = {CTL_KERN, KERN_CPTIME};
-    ret = sysctl(mib, 2, &cpu_time, &size, NULL, 0);
-#endif
-    if (ret == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    return Py_BuildValue("(ddddd)",
-                         (double)cpu_time[CP_USER] / CLOCKS_PER_SEC,
-                         (double)cpu_time[CP_NICE] / CLOCKS_PER_SEC,
-                         (double)cpu_time[CP_SYS] / CLOCKS_PER_SEC,
-                         (double)cpu_time[CP_IDLE] / CLOCKS_PER_SEC,
-                         (double)cpu_time[CP_INTR] / CLOCKS_PER_SEC
-                        );
-}
-
-
- /*
- * Return files opened by process as a list of (path, fd) tuples.
- * TODO: this is broken as it may report empty paths. 'procstat'
- * utility has the same problem see:
- * https://github.com/giampaolo/psutil/issues/595
- */
-#if (defined(__FreeBSD_version) && __FreeBSD_version >= 800000) || __OpenBSD__ || defined(__NetBSD__)
-static PyObject *
-psutil_proc_open_files(PyObject *self, PyObject *args) {
-    long pid;
-    int i, cnt;
-    struct kinfo_file *freep = NULL;
-    struct kinfo_file *kif;
-    kinfo_proc kipp;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-    if (psutil_kinfo_proc(pid, &kipp) == -1)
-        goto error;
-
-    freep = kinfo_getfile(pid, &cnt);
-    if (freep == NULL) {
-        psutil_raise_ad_or_nsp(pid);
-        goto error;
-    }
-
-    for (i = 0; i < cnt; i++) {
-        kif = &freep[i];
-#ifdef __FreeBSD__
-        if ((kif->kf_type == KF_TYPE_VNODE) &&
-                (kif->kf_vnode_type == KF_VTYPE_VREG))
-        {
-            py_tuple = Py_BuildValue("(si)", kif->kf_path, kif->kf_fd);
-#elif defined(__OpenBSD__)
-        if ((kif->f_type == DTYPE_VNODE) &&
-                (kif->v_type == VREG))
-        {
-            py_tuple = Py_BuildValue("(si)", "", kif->fd_fd);
-#elif defined(__NetBSD__)
-        if ((kif->ki_ftype == DTYPE_VNODE) &&
-                (kif->ki_vtype == VREG))
-        {
-            py_tuple = Py_BuildValue("(si)", "", kif->ki_fd);
-#endif
-            if (py_tuple == NULL)
-                goto error;
-            if (PyList_Append(py_retlist, py_tuple))
-                goto error;
-            Py_DECREF(py_tuple);
-        }
-    }
-    free(freep);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (freep != NULL)
-        free(freep);
-    return NULL;
-}
-#endif
-
-
-/*
- * Return a list of tuples including device, mount point and fs type
- * for all partitions mounted on the system.
- */
-static PyObject *
-psutil_disk_partitions(PyObject *self, PyObject *args) {
-    int num;
-    int i;
-    long len;
-    uint64_t flags;
-    char opts[200];
-#if defined(__NetBSD__)
-    struct statvfs *fs = NULL;
-#else
-    struct statfs *fs = NULL;
-#endif
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
+#include <sys/param.h>  // BSD version
+#include <netinet/tcp_fsm.h>  // for TCP connection states
 
-    if (py_retlist == NULL)
-        return NULL;
-
-    // get the number of mount points
-    Py_BEGIN_ALLOW_THREADS
-#if defined(__NetBSD__)
-    num = getvfsstat(NULL, 0, MNT_NOWAIT);
-#else
-    num = getfsstat(NULL, 0, MNT_NOWAIT);
-#endif
-    Py_END_ALLOW_THREADS
-    if (num == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    len = sizeof(*fs) * num;
-    fs = malloc(len);
-    if (fs == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    Py_BEGIN_ALLOW_THREADS
-#if defined(__NetBSD__)
-    num = getvfsstat(fs, len, MNT_NOWAIT);
-#else
-    num = getfsstat(fs, len, MNT_NOWAIT);
-#endif
-    Py_END_ALLOW_THREADS
-    if (num == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    for (i = 0; i < num; i++) {
-        py_tuple = NULL;
-        opts[0] = 0;
-#if defined(__NetBSD__)
-        flags = fs[i].f_flag;
-#else
-        flags = fs[i].f_flags;
-#endif
+#include "arch/all/init.h"
+#include "arch/bsd/init.h"
 
-        // see sys/mount.h
-        if (flags & MNT_RDONLY)
-            strlcat(opts, "ro", sizeof(opts));
-        else
-            strlcat(opts, "rw", sizeof(opts));
-        if (flags & MNT_SYNCHRONOUS)
-            strlcat(opts, ",sync", sizeof(opts));
-        if (flags & MNT_NOEXEC)
-            strlcat(opts, ",noexec", sizeof(opts));
-        if (flags & MNT_NOSUID)
-            strlcat(opts, ",nosuid", sizeof(opts));
-        if (flags & MNT_ASYNC)
-            strlcat(opts, ",async", sizeof(opts));
-        if (flags & MNT_NOATIME)
-            strlcat(opts, ",noatime", sizeof(opts));
-        if (flags & MNT_SOFTDEP)
-            strlcat(opts, ",softdep", sizeof(opts));
-#ifdef __FreeBSD__
-        if (flags & MNT_UNION)
-            strlcat(opts, ",union", sizeof(opts));
-        if (flags & MNT_SUIDDIR)
-            strlcat(opts, ",suiddir", sizeof(opts));
-        if (flags & MNT_SOFTDEP)
-            strlcat(opts, ",softdep", sizeof(opts));
-        if (flags & MNT_NOSYMFOLLOW)
-            strlcat(opts, ",nosymfollow", sizeof(opts));
-        if (flags & MNT_GJOURNAL)
-            strlcat(opts, ",gjournal", sizeof(opts));
-        if (flags & MNT_MULTILABEL)
-            strlcat(opts, ",multilabel", sizeof(opts));
-        if (flags & MNT_ACLS)
-            strlcat(opts, ",acls", sizeof(opts));
-        if (flags & MNT_NOCLUSTERR)
-            strlcat(opts, ",noclusterr", sizeof(opts));
-        if (flags & MNT_NOCLUSTERW)
-            strlcat(opts, ",noclusterw", sizeof(opts));
-        if (flags & MNT_NFS4ACLS)
-            strlcat(opts, ",nfs4acls", sizeof(opts));
-#elif __NetBSD__
-        if (flags & MNT_NODEV)
-            strlcat(opts, ",nodev", sizeof(opts));
-        if (flags & MNT_UNION)
-            strlcat(opts, ",union", sizeof(opts));
-        if (flags & MNT_NOCOREDUMP)
-            strlcat(opts, ",nocoredump", sizeof(opts));
-#if defined(MNT_RELATIME)
-        if (flags & MNT_RELATIME)
-            strlcat(opts, ",relatime", sizeof(opts));
+#ifdef PSUTIL_FREEBSD
+#include "arch/freebsd/init.h"
+#elif PSUTIL_OPENBSD
+#include "arch/openbsd/init.h"
+#elif PSUTIL_NETBSD
+#include "arch/netbsd/init.h"
 #endif
-        if (flags & MNT_IGNORE)
-            strlcat(opts, ",ignore", sizeof(opts));
-#if defined(MNT_DISCARD)
-        if (flags & MNT_DISCARD)
-            strlcat(opts, ",discard", sizeof(opts));
-#endif
-#if defined(MNT_EXTATTR)
-        if (flags & MNT_EXTATTR)
-            strlcat(opts, ",extattr", sizeof(opts));
-#endif
-        if (flags & MNT_LOG)
-            strlcat(opts, ",log", sizeof(opts));
-        if (flags & MNT_SYMPERM)
-            strlcat(opts, ",symperm", sizeof(opts));
-        if (flags & MNT_NODEVMTIME)
-            strlcat(opts, ",nodevmtime", sizeof(opts));
-#endif
-        py_tuple = Py_BuildValue("(ssss)",
-                                 fs[i].f_mntfromname,  // device
-                                 fs[i].f_mntonname,    // mount point
-                                 fs[i].f_fstypename,   // fs type
-                                 opts);                // options
-        if (!py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-
-    free(fs);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (fs != NULL)
-        free(fs);
-    return NULL;
-}
-
-
-/*
- * Return a Python list of named tuples with overall network I/O information
- */
-static PyObject *
-psutil_net_io_counters(PyObject *self, PyObject *args) {
-    char *buf = NULL, *lim, *next;
-    struct if_msghdr *ifm;
-    int mib[6];
-    size_t len;
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_ifc_info = NULL;
-    if (py_retdict == NULL)
-        return NULL;
-
-    mib[0] = CTL_NET;          // networking subsystem
-    mib[1] = PF_ROUTE;         // type of information
-    mib[2] = 0;                // protocol (IPPROTO_xxx)
-    mib[3] = 0;                // address family
-    mib[4] = NET_RT_IFLIST;   // operation
-    mib[5] = 0;
-
-    if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    buf = malloc(len);
-    if (buf == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
 
-    lim = buf + len;
 
-    for (next = buf; next < lim; ) {
-        py_ifc_info = NULL;
-        ifm = (struct if_msghdr *)next;
-        next += ifm->ifm_msglen;
-
-        if (ifm->ifm_type == RTM_IFINFO) {
-            struct if_msghdr *if2m = (struct if_msghdr *)ifm;
-            struct sockaddr_dl *sdl = (struct sockaddr_dl *)(if2m + 1);
-            char ifc_name[32];
-
-            strncpy(ifc_name, sdl->sdl_data, sdl->sdl_nlen);
-            ifc_name[sdl->sdl_nlen] = 0;
-            // XXX: ignore usbus interfaces:
-            // http://lists.freebsd.org/pipermail/freebsd-current/
-            //     2011-October/028752.html
-            // 'ifconfig -a' doesn't show them, nor do we.
-            if (strncmp(ifc_name, "usbus", 5) == 0)
-                continue;
-
-            py_ifc_info = Py_BuildValue("(kkkkkkki)",
-                                        if2m->ifm_data.ifi_obytes,
-                                        if2m->ifm_data.ifi_ibytes,
-                                        if2m->ifm_data.ifi_opackets,
-                                        if2m->ifm_data.ifi_ipackets,
-                                        if2m->ifm_data.ifi_ierrors,
-                                        if2m->ifm_data.ifi_oerrors,
-                                        if2m->ifm_data.ifi_iqdrops,
-#ifdef _IFI_OQDROPS
-                                        if2m->ifm_data.ifi_oqdrops
-#else
-                                        0
-#endif
-                                        );
-            if (!py_ifc_info)
-                goto error;
-            if (PyDict_SetItemString(py_retdict, ifc_name, py_ifc_info))
-                goto error;
-            Py_DECREF(py_ifc_info);
-        }
-        else {
-            continue;
-        }
-    }
-
-    free(buf);
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_ifc_info);
-    Py_DECREF(py_retdict);
-    if (buf != NULL)
-        free(buf);
-    return NULL;
-}
-
-
-/*
- * Return currently connected users as a list of tuples.
- */
-static PyObject *
-psutil_users(PyObject *self, PyObject *args) {
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-#if (defined(__FreeBSD_version) && (__FreeBSD_version < 900000)) || __OpenBSD__
-    struct utmp ut;
-    FILE *fp;
-
-    fp = fopen(_PATH_UTMP, "r");
-    if (fp == NULL) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    while (fread(&ut, sizeof(ut), 1, fp) == 1) {
-        if (*ut.ut_name == '\0')
-            continue;
-        py_tuple = Py_BuildValue(
-            "(sssf)",
-            ut.ut_name,         // username
-            ut.ut_line,         // tty
-            ut.ut_host,         // hostname
-           (float)ut.ut_time);  // start time
-        if (!py_tuple) {
-            fclose(fp);
-            goto error;
-        }
-        if (PyList_Append(py_retlist, py_tuple)) {
-            fclose(fp);
-            goto error;
-        }
-        Py_DECREF(py_tuple);
-    }
-
-    fclose(fp);
-#else
-    struct utmpx *utx;
-
-    setutxent();
-    while ((utx = getutxent()) != NULL) {
-        if (utx->ut_type != USER_PROCESS)
-            continue;
-        py_tuple = Py_BuildValue(
-            "(sssf)",
-            utx->ut_user,  // username
-            utx->ut_line,  // tty
-            utx->ut_host,  // hostname
-            (float)utx->ut_tv.tv_sec  // start time
-        );
-
-        if (!py_tuple) {
-            endutxent();
-            goto error;
-        }
-        if (PyList_Append(py_retlist, py_tuple)) {
-            endutxent();
-            goto error;
-        }
-        Py_DECREF(py_tuple);
-    }
-
-    endutxent();
-#endif
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    return NULL;
-}
-
-
-/*
- * define the psutil C module methods and initialize the module.
- */
-static PyMethodDef
-PsutilMethods[] = {
+static PyMethodDef mod_methods[] = {
     // --- per-process functions
 
-    {"proc_name", psutil_proc_name, METH_VARARGS,
-     "Return process name"},
-    {"proc_connections", psutil_proc_connections, METH_VARARGS,
-     "Return connections opened by process"},
-    {"proc_cmdline", psutil_proc_cmdline, METH_VARARGS,
-     "Return process cmdline as a list of cmdline arguments"},
-    {"proc_ppid", psutil_proc_ppid, METH_VARARGS,
-     "Return process ppid as an integer"},
-    {"proc_uids", psutil_proc_uids, METH_VARARGS,
-     "Return process real effective and saved user ids as a Python tuple"},
-    {"proc_gids", psutil_proc_gids, METH_VARARGS,
-     "Return process real effective and saved group ids as a Python tuple"},
-    {"proc_cpu_times", psutil_proc_cpu_times, METH_VARARGS,
-     "Return tuple of user/kern time for the given PID"},
-    {"proc_create_time", psutil_proc_create_time, METH_VARARGS,
-     "Return a float indicating the process create time expressed in "
-     "seconds since the epoch"},
-    {"proc_memory_info", psutil_proc_memory_info, METH_VARARGS,
-     "Return extended memory info for a process as a Python tuple."},
-    {"proc_num_ctx_switches", psutil_proc_num_ctx_switches, METH_VARARGS,
-     "Return the number of context switches performed by process"},
-    {"proc_threads", psutil_proc_threads, METH_VARARGS,
-     "Return process threads"},
-    {"proc_status", psutil_proc_status, METH_VARARGS,
-     "Return process status as an integer"},
-    {"proc_io_counters", psutil_proc_io_counters, METH_VARARGS,
-     "Return process IO counters"},
-    {"proc_tty_nr", psutil_proc_tty_nr, METH_VARARGS,
-     "Return process tty (terminal) number"},
-#if defined(__FreeBSD__) || defined(__OpenBSD__)
-    {"proc_cwd", psutil_proc_cwd, METH_VARARGS,
-     "Return process current working directory."},
-#endif
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 800000 || __OpenBSD__ || defined(__NetBSD__)
-    {"proc_num_fds", psutil_proc_num_fds, METH_VARARGS,
-     "Return the number of file descriptors opened by this process"},
-#endif
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 800000 || __OpenBSD__ || defined(__NetBSD__)
-    {"proc_open_files", psutil_proc_open_files, METH_VARARGS,
-     "Return files opened by process as a list of (path, fd) tuples"},
-#endif
-
-#if defined(__FreeBSD__) || defined(__NetBSD__)
-    {"proc_exe", psutil_proc_exe, METH_VARARGS,
-     "Return process pathname executable"},
-    {"proc_num_threads", psutil_proc_num_threads, METH_VARARGS,
-     "Return number of threads used by process"},
-#if defined(__FreeBSD__)
-    {"proc_memory_maps", psutil_proc_memory_maps, METH_VARARGS,
-     "Return a list of tuples for every process's memory map"},
-    {"proc_cpu_affinity_get", psutil_proc_cpu_affinity_get, METH_VARARGS,
-     "Return process CPU affinity."},
-    {"proc_cpu_affinity_set", psutil_proc_cpu_affinity_set, METH_VARARGS,
-     "Set process CPU affinity."},
-    {"cpu_count_phys", psutil_cpu_count_phys, METH_VARARGS,
-     "Return an XML string to determine the number physical CPUs."},
-#endif
+    {"proc_cmdline", psutil_proc_cmdline, METH_VARARGS},
+    {"proc_cwd", psutil_proc_cwd, METH_VARARGS},
+    {"proc_environ", psutil_proc_environ, METH_VARARGS},
+    {"proc_name", psutil_proc_name, METH_VARARGS},
+    {"proc_num_fds", psutil_proc_num_fds, METH_VARARGS},
+    {"proc_oneshot_kinfo", psutil_proc_oneshot_kinfo, METH_VARARGS},
+    {"proc_open_files", psutil_proc_open_files, METH_VARARGS},
+    {"proc_threads", psutil_proc_threads, METH_VARARGS},
+#if defined(PSUTIL_FREEBSD) || defined(PSUTIL_NETBSD)
+    {"proc_exe", psutil_proc_exe, METH_VARARGS},
+    {"proc_num_threads", psutil_proc_num_threads, METH_VARARGS},
+#endif
+#if defined(PSUTIL_FREEBSD)
+    {"proc_cpu_affinity_get", psutil_proc_cpu_affinity_get, METH_VARARGS},
+    {"proc_cpu_affinity_set", psutil_proc_cpu_affinity_set, METH_VARARGS},
+    {"proc_getrlimit", psutil_proc_getrlimit, METH_VARARGS},
+    {"proc_memory_maps", psutil_proc_memory_maps, METH_VARARGS},
+    {"proc_net_connections", psutil_proc_net_connections, METH_VARARGS},
+    {"proc_setrlimit", psutil_proc_setrlimit, METH_VARARGS},
 #endif
 
     // --- system-related functions
+    {"boot_time", psutil_boot_time, METH_VARARGS},
+    {"cpu_count_logical", psutil_cpu_count_logical, METH_VARARGS},
+    {"cpu_stats", psutil_cpu_stats, METH_VARARGS},
+    {"cpu_times", psutil_cpu_times, METH_VARARGS},
+    {"disk_io_counters", psutil_disk_io_counters, METH_VARARGS},
+    {"disk_partitions", psutil_disk_partitions, METH_VARARGS},
+    {"net_connections", psutil_net_connections, METH_VARARGS},
+    {"net_io_counters", psutil_net_io_counters, METH_VARARGS},
+    {"per_cpu_times", psutil_per_cpu_times, METH_VARARGS},
+    {"pids", psutil_pids, METH_VARARGS},
+    {"swap_mem", psutil_swap_mem, METH_VARARGS},
+#if defined(PSUTIL_FREEBSD) || defined(PSUTIL_NETBSD)
+    {"heap_info", psutil_heap_info, METH_VARARGS},
+    {"heap_trim", psutil_heap_trim, METH_VARARGS},
+#endif
+#if defined(PSUTIL_OPENBSD)
+    {"users", psutil_users, METH_VARARGS},
+#endif
+    {"virtual_mem", psutil_virtual_mem, METH_VARARGS},
+#if defined(PSUTIL_FREEBSD) || defined(PSUTIL_OPENBSD)
+    {"cpu_freq", psutil_cpu_freq, METH_VARARGS},
+#endif
+#if defined(PSUTIL_FREEBSD)
+    {"cpu_count_cores", psutil_cpu_count_cores, METH_VARARGS},
+    {"sensors_battery", psutil_sensors_battery, METH_VARARGS},
+    {"sensors_cpu_temperature", psutil_sensors_cpu_temperature, METH_VARARGS},
+#endif
+    // --- others
+    {"check_pid_range", psutil_check_pid_range, METH_VARARGS},
+    {"set_debug", psutil_set_debug, METH_VARARGS},
 
-    {"pids", psutil_pids, METH_VARARGS,
-     "Returns a list of PIDs currently running on the system"},
-    {"cpu_count_logical", psutil_cpu_count_logical, METH_VARARGS,
-     "Return number of logical CPUs on the system"},
-    {"virtual_mem", psutil_virtual_mem, METH_VARARGS,
-     "Return system virtual memory usage statistics"},
-    {"swap_mem", psutil_swap_mem, METH_VARARGS,
-     "Return swap mem stats"},
-    {"cpu_times", psutil_cpu_times, METH_VARARGS,
-     "Return system cpu times as a tuple (user, system, nice, idle, irc)"},
-    {"per_cpu_times", psutil_per_cpu_times, METH_VARARGS,
-     "Return system per-cpu times as a list of tuples"},
-    {"boot_time", psutil_boot_time, METH_VARARGS,
-     "Return the system boot time expressed in seconds since the epoch."},
-    {"disk_partitions", psutil_disk_partitions, METH_VARARGS,
-     "Return a list of tuples including device, mount point and "
-     "fs type for all partitions mounted on the system."},
-    {"net_io_counters", psutil_net_io_counters, METH_VARARGS,
-     "Return dict of tuples of networks I/O information."},
-    {"disk_io_counters", psutil_disk_io_counters, METH_VARARGS,
-     "Return a Python dict of tuples for disk I/O information"},
-    {"users", psutil_users, METH_VARARGS,
-     "Return currently connected users as a list of tuples"},
-    {"cpu_stats", psutil_cpu_stats, METH_VARARGS,
-     "Return CPU statistics"},
-#if defined(__FreeBSD__) || defined(__NetBSD__)
-    {"net_connections", psutil_net_connections, METH_VARARGS,
-     "Return system-wide open connections."},
-#endif
     {NULL, NULL, 0, NULL}
 };
 
-struct module_state {
-    PyObject *error;
-};
 
-#if PY_MAJOR_VERSION >= 3
-#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
-#else
-#define GETSTATE(m) (&_state)
+static int
+psutil_add_constants(PyObject *mod) {
+    PSUTIL_ADD_INT(mod, "version", PSUTIL_VERSION);
+    PSUTIL_ADD_INT(mod, "NODEV", -1);
+
+    // process status constants
+#ifdef PSUTIL_FREEBSD
+    PSUTIL_ADD_INT(mod, "SIDL", SIDL);
+    PSUTIL_ADD_INT(mod, "SRUN", SRUN);
+    PSUTIL_ADD_INT(mod, "SSLEEP", SSLEEP);
+    PSUTIL_ADD_INT(mod, "SSTOP", SSTOP);
+    PSUTIL_ADD_INT(mod, "SZOMB", SZOMB);
+    PSUTIL_ADD_INT(mod, "SWAIT", SWAIT);
+    PSUTIL_ADD_INT(mod, "SLOCK", SLOCK);
+#elif PSUTIL_OPENBSD
+    PSUTIL_ADD_INT(mod, "SIDL", SIDL);
+    PSUTIL_ADD_INT(mod, "SRUN", SRUN);
+    PSUTIL_ADD_INT(mod, "SSLEEP", SSLEEP);
+    PSUTIL_ADD_INT(mod, "SSTOP", SSTOP);
+    PSUTIL_ADD_INT(mod, "SZOMB", SZOMB);  // unused
+    PSUTIL_ADD_INT(mod, "SDEAD", SDEAD);
+    PSUTIL_ADD_INT(mod, "SONPROC", SONPROC);
+#elif defined(PSUTIL_NETBSD)
+    PSUTIL_ADD_INT(mod, "SIDL", LSIDL);
+    PSUTIL_ADD_INT(mod, "SRUN", LSRUN);
+    PSUTIL_ADD_INT(mod, "SSLEEP", LSSLEEP);
+    PSUTIL_ADD_INT(mod, "SSTOP", LSSTOP);
+    PSUTIL_ADD_INT(mod, "SZOMB", LSZOMB);
+#if __NetBSD_Version__ < 500000000
+    PSUTIL_ADD_INT(mod, "SDEAD", LSDEAD);
+#endif
+    PSUTIL_ADD_INT(mod, "SONPROC", LSONPROC);
+    // unique to NetBSD
+    PSUTIL_ADD_INT(mod, "SSUSPENDED", LSSUSPENDED);
 #endif
 
-#if PY_MAJOR_VERSION >= 3
+    // connection status constants
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSED", TCPS_CLOSED);
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSING", TCPS_CLOSING);
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT);
+    PSUTIL_ADD_INT(mod, "TCPS_LISTEN", TCPS_LISTEN);
+    PSUTIL_ADD_INT(mod, "TCPS_ESTABLISHED", TCPS_ESTABLISHED);
+    PSUTIL_ADD_INT(mod, "TCPS_SYN_SENT", TCPS_SYN_SENT);
+    PSUTIL_ADD_INT(mod, "TCPS_SYN_RECEIVED", TCPS_SYN_RECEIVED);
+    PSUTIL_ADD_INT(mod, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1);
+    PSUTIL_ADD_INT(mod, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2);
+    PSUTIL_ADD_INT(mod, "TCPS_LAST_ACK", TCPS_LAST_ACK);
+    PSUTIL_ADD_INT(mod, "TCPS_TIME_WAIT", TCPS_TIME_WAIT);
+    PSUTIL_ADD_INT(mod, "PSUTIL_CONN_NONE", 128);
 
-static int
-psutil_bsd_traverse(PyObject *m, visitproc visit, void *arg) {
-    Py_VISIT(GETSTATE(m)->error);
     return 0;
 }
 
+
 static int
-psutil_bsd_clear(PyObject *m) {
-    Py_CLEAR(GETSTATE(m)->error);
+psutil_exec(PyObject *mod) {
+    if (psutil_setup() != 0)
+        return -1;
+    if (psutil_posix_add_constants(mod) != 0)
+        return -1;
+    if (psutil_posix_add_methods(mod) != 0)
+        return -1;
+    if (psutil_add_exceptions(mod) != 0)
+        return -1;
+    if (psutil_add_constants(mod) != 0)
+        return -1;
     return 0;
 }
 
-static struct PyModuleDef
-        moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "psutil_bsd",
-    NULL,
-    sizeof(struct module_state),
-    PsutilMethods,
-    NULL,
-    psutil_bsd_traverse,
-    psutil_bsd_clear,
-    NULL
-};
-
-#define INITERROR return NULL
-
-PyMODINIT_FUNC PyInit__psutil_bsd(void)
-
-#else
-#define INITERROR return
-
-void init_psutil_bsd(void)
-#endif
-{
-#if PY_MAJOR_VERSION >= 3
-    PyObject *module = PyModule_Create(&moduledef);
-#else
-    PyObject *module = Py_InitModule("_psutil_bsd", PsutilMethods);
-#endif
-    PyModule_AddIntConstant(module, "version", PSUTIL_VERSION);
-    // process status constants
-
-#ifdef __FreeBSD__
-    PyModule_AddIntConstant(module, "SIDL", SIDL);
-    PyModule_AddIntConstant(module, "SRUN", SRUN);
-    PyModule_AddIntConstant(module, "SSLEEP", SSLEEP);
-    PyModule_AddIntConstant(module, "SSTOP", SSTOP);
-    PyModule_AddIntConstant(module, "SZOMB", SZOMB);
-    PyModule_AddIntConstant(module, "SWAIT", SWAIT);
-    PyModule_AddIntConstant(module, "SLOCK", SLOCK);
-#elif  __OpenBSD__
-    PyModule_AddIntConstant(module, "SIDL", SIDL);
-    PyModule_AddIntConstant(module, "SRUN", SRUN);
-    PyModule_AddIntConstant(module, "SSLEEP", SSLEEP);
-    PyModule_AddIntConstant(module, "SSTOP", SSTOP);
-    PyModule_AddIntConstant(module, "SZOMB", SZOMB);  // unused
-    PyModule_AddIntConstant(module, "SDEAD", SDEAD);
-    PyModule_AddIntConstant(module, "SONPROC", SONPROC);
-#elif  defined(__NetBSD__)
-    PyModule_AddIntConstant(module, "SIDL", LSIDL);
-    PyModule_AddIntConstant(module, "SRUN", LSRUN);
-    PyModule_AddIntConstant(module, "SSLEEP", LSSLEEP);
-    PyModule_AddIntConstant(module, "SSTOP", LSSTOP);
-    PyModule_AddIntConstant(module, "SZOMB", LSZOMB);
-    PyModule_AddIntConstant(module, "SDEAD", LSDEAD);
-    PyModule_AddIntConstant(module, "SONPROC", LSONPROC);
-    // unique to NetBSD
-    PyModule_AddIntConstant(module, "SSUSPENDED", LSSUSPENDED);
-#endif
-
-    // connection status constants
-    PyModule_AddIntConstant(module, "TCPS_CLOSED", TCPS_CLOSED);
-    PyModule_AddIntConstant(module, "TCPS_CLOSING", TCPS_CLOSING);
-    PyModule_AddIntConstant(module, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT);
-    PyModule_AddIntConstant(module, "TCPS_LISTEN", TCPS_LISTEN);
-    PyModule_AddIntConstant(module, "TCPS_ESTABLISHED", TCPS_ESTABLISHED);
-    PyModule_AddIntConstant(module, "TCPS_SYN_SENT", TCPS_SYN_SENT);
-    PyModule_AddIntConstant(module, "TCPS_SYN_RECEIVED", TCPS_SYN_RECEIVED);
-    PyModule_AddIntConstant(module, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1);
-    PyModule_AddIntConstant(module, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2);
-    PyModule_AddIntConstant(module, "TCPS_LAST_ACK", TCPS_LAST_ACK);
-    PyModule_AddIntConstant(module, "TCPS_TIME_WAIT", TCPS_TIME_WAIT);
-    // PSUTIL_CONN_NONE
-    PyModule_AddIntConstant(module, "PSUTIL_CONN_NONE", 128);
-
-    if (module == NULL)
-        INITERROR;
-#if PY_MAJOR_VERSION >= 3
-    return module;
-#endif
+PyMODINIT_FUNC
+PyInit__psutil(void) {
+    return psutil_mod_init("_psutil", mod_methods, psutil_exec);
 }
diff --git a/psutil/_psutil_common.c b/psutil/_psutil_common.c
deleted file mode 100644
index 1c530d4df5..0000000000
--- a/psutil/_psutil_common.c
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Routines common to all platforms.
- */
-
-#include <Python.h>
-
-
-/*
- * Set OSError(errno=ESRCH, strerror="No such process") Python exception.
- */
-PyObject *
-NoSuchProcess(void) {
-    PyObject *exc;
-    char *msg = strerror(ESRCH);
-    exc = PyObject_CallFunction(PyExc_OSError, "(is)", ESRCH, msg);
-    PyErr_SetObject(PyExc_OSError, exc);
-    Py_XDECREF(exc);
-    return NULL;
-}
-
-
-/*
- * Set OSError(errno=EACCES, strerror="Permission denied") Python exception.
- */
-PyObject *
-AccessDenied(void) {
-    PyObject *exc;
-    char *msg = strerror(EACCES);
-    exc = PyObject_CallFunction(PyExc_OSError, "(is)", EACCES, msg);
-    PyErr_SetObject(PyExc_OSError, exc);
-    Py_XDECREF(exc);
-    return NULL;
-}
diff --git a/psutil/_psutil_common.h b/psutil/_psutil_common.h
deleted file mode 100644
index 43021a72df..0000000000
--- a/psutil/_psutil_common.h
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include <Python.h>
-
-PyObject* AccessDenied(void);
-PyObject* NoSuchProcess(void);
diff --git a/psutil/_psutil_linux.c b/psutil/_psutil_linux.c
index 19fd14b985..8ec909fe97 100644
--- a/psutil/_psutil_linux.c
+++ b/psutil/_psutil_linux.c
@@ -2,701 +2,77 @@
  * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
- *
- * Linux-specific functions.
  */
 
+// Linux-specific functions.
+
 #ifndef _GNU_SOURCE
-    #define _GNU_SOURCE 1
+#define _GNU_SOURCE 1
 #endif
 #include <Python.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <mntent.h>
-#include <features.h>
-#include <utmp.h>
-#include <sched.h>
-#include <linux/version.h>
-#include <sys/syscall.h>
-#include <sys/sysinfo.h>
-#include <sys/ioctl.h>
-#include <sys/socket.h>
-#include <linux/sockios.h>
-#include <linux/if.h>
-
-// see: https://github.com/giampaolo/psutil/issues/659
-#ifdef PSUTIL_ETHTOOL_MISSING_TYPES
-    #include <linux/types.h>
-    typedef __u64 u64;
-    typedef __u32 u32;
-    typedef __u16 u16;
-    typedef __u8 u8;
-#endif
-#include <linux/ethtool.h>
-
-/* The minimum number of CPUs allocated in a cpu_set_t */
-static const int NCPUS_START = sizeof(unsigned long) * CHAR_BIT;
-
-// Linux >= 2.6.13
-#define PSUTIL_HAVE_IOPRIO defined(__NR_ioprio_get) && defined(__NR_ioprio_set)
-
-// Linux >= 2.6.36 (supposedly) and glibc >= 13
-#define PSUTIL_HAVE_PRLIMIT \
-    (LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 36)) && \
-    (__GLIBC__ >= 2 && __GLIBC_MINOR__ >= 13) && \
-    defined(__NR_prlimit64)
-
-#if PSUTIL_HAVE_PRLIMIT
-    #define _FILE_OFFSET_BITS 64
-    #include <time.h>
-    #include <sys/resource.h>
-#endif
+#include <linux/ethtool.h>  // DUPLEX_*
 
+#include "arch/all/init.h"
 
 // May happen on old RedHat versions, see:
 // https://github.com/giampaolo/psutil/issues/607
 #ifndef DUPLEX_UNKNOWN
-    #define DUPLEX_UNKNOWN 0xff
+#define DUPLEX_UNKNOWN 0xff
 #endif
 
-
-#if PSUTIL_HAVE_IOPRIO
-enum {
-    IOPRIO_WHO_PROCESS = 1,
-};
-
-static inline int
-ioprio_get(int which, int who) {
-    return syscall(__NR_ioprio_get, which, who);
-}
-
-static inline int
-ioprio_set(int which, int who, int ioprio) {
-    return syscall(__NR_ioprio_set, which, who, ioprio);
-}
-
-#define IOPRIO_CLASS_SHIFT 13
-#define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1)
-
-#define IOPRIO_PRIO_CLASS(mask) ((mask) >> IOPRIO_CLASS_SHIFT)
-#define IOPRIO_PRIO_DATA(mask) ((mask) & IOPRIO_PRIO_MASK)
-#define IOPRIO_PRIO_VALUE(class, data) (((class) << IOPRIO_CLASS_SHIFT) | data)
-
-
-/*
- * Return a (ioclass, iodata) Python tuple representing process I/O priority.
- */
-static PyObject *
-psutil_proc_ioprio_get(PyObject *self, PyObject *args) {
-    long pid;
-    int ioprio, ioclass, iodata;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    ioprio = ioprio_get(IOPRIO_WHO_PROCESS, pid);
-    if (ioprio == -1)
-        return PyErr_SetFromErrno(PyExc_OSError);
-    ioclass = IOPRIO_PRIO_CLASS(ioprio);
-    iodata = IOPRIO_PRIO_DATA(ioprio);
-    return Py_BuildValue("ii", ioclass, iodata);
-}
-
-
-/*
- * A wrapper around ioprio_set(); sets process I/O priority.
- * ioclass can be either IOPRIO_CLASS_RT, IOPRIO_CLASS_BE, IOPRIO_CLASS_IDLE
- * or 0. iodata goes from 0 to 7 depending on ioclass specified.
- */
-static PyObject *
-psutil_proc_ioprio_set(PyObject *self, PyObject *args) {
-    long pid;
-    int ioprio, ioclass, iodata;
-    int retval;
-
-    if (! PyArg_ParseTuple(args, "lii", &pid, &ioclass, &iodata))
-        return NULL;
-    ioprio = IOPRIO_PRIO_VALUE(ioclass, iodata);
-    retval = ioprio_set(IOPRIO_WHO_PROCESS, pid, ioprio);
-    if (retval == -1)
-        return PyErr_SetFromErrno(PyExc_OSError);
-    Py_RETURN_NONE;
-}
-#endif
-
-
-#if PSUTIL_HAVE_PRLIMIT
-/*
- * A wrapper around prlimit(2); sets process resource limits.
- * This can be used for both get and set, in which case extra
- * 'soft' and 'hard' args must be provided.
- */
-static PyObject *
-psutil_linux_prlimit(PyObject *self, PyObject *args) {
-    long pid;
-    int ret, resource;
-    struct rlimit old, new;
-    struct rlimit *newp = NULL;
-    PyObject *py_soft = NULL;
-    PyObject *py_hard = NULL;
-
-    if (! PyArg_ParseTuple(args, "li|OO", &pid, &resource, &py_soft, &py_hard))
-        return NULL;
-
-    // get
-    if (py_soft == NULL && py_hard == NULL) {
-        ret = prlimit(pid, resource, NULL, &old);
-        if (ret == -1)
-            return PyErr_SetFromErrno(PyExc_OSError);
-#if defined(PSUTIL_HAVE_LONG_LONG)
-        if (sizeof(old.rlim_cur) > sizeof(long)) {
-            return Py_BuildValue("LL",
-                                 (PY_LONG_LONG)old.rlim_cur,
-                                 (PY_LONG_LONG)old.rlim_max);
-        }
-#endif
-        return Py_BuildValue("ll", (long)old.rlim_cur, (long)old.rlim_max);
-    }
-
-    // set
-    else {
-#if defined(PSUTIL_HAVE_LARGEFILE_SUPPORT)
-        new.rlim_cur = PyLong_AsLongLong(py_soft);
-        if (new.rlim_cur == (rlim_t) - 1 && PyErr_Occurred())
-            return NULL;
-        new.rlim_max = PyLong_AsLongLong(py_hard);
-        if (new.rlim_max == (rlim_t) - 1 && PyErr_Occurred())
-            return NULL;
-#else
-        new.rlim_cur = PyLong_AsLong(py_soft);
-        if (new.rlim_cur == (rlim_t) - 1 && PyErr_Occurred())
-            return NULL;
-        new.rlim_max = PyLong_AsLong(py_hard);
-        if (new.rlim_max == (rlim_t) - 1 && PyErr_Occurred())
-            return NULL;
-#endif
-        newp = &new;
-        ret = prlimit(pid, resource, newp, &old);
-        if (ret == -1)
-            return PyErr_SetFromErrno(PyExc_OSError);
-        Py_RETURN_NONE;
-    }
-}
-#endif
-
-
-/*
- * Return disk mounted partitions as a list of tuples including device,
- * mount point and filesystem type
- */
-static PyObject *
-psutil_disk_partitions(PyObject *self, PyObject *args) {
-    FILE *file = NULL;
-    struct mntent *entry;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    // MOUNTED constant comes from mntent.h and it's == '/etc/mtab'
-    Py_BEGIN_ALLOW_THREADS
-    file = setmntent(MOUNTED, "r");
-    Py_END_ALLOW_THREADS
-    if ((file == 0) || (file == NULL)) {
-        PyErr_SetFromErrnoWithFilename(PyExc_OSError, MOUNTED);
-        goto error;
-    }
-
-    while ((entry = getmntent(file))) {
-        if (entry == NULL) {
-            PyErr_Format(PyExc_RuntimeError, "getmntent() failed");
-            goto error;
-        }
-        py_tuple = Py_BuildValue("(ssss)",
-                                 entry->mnt_fsname,  // device
-                                 entry->mnt_dir,     // mount point
-                                 entry->mnt_type,    // fs type
-                                 entry->mnt_opts);   // options
-        if (! py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-    endmntent(file);
-    return py_retlist;
-
-error:
-    if (file != NULL)
-        endmntent(file);
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    return NULL;
-}
-
-
-/*
- * A wrapper around sysinfo(), return system memory usage statistics.
- */
-static PyObject *
-psutil_linux_sysinfo(PyObject *self, PyObject *args) {
-    struct sysinfo info;
-
-    if (sysinfo(&info) != 0)
-        return PyErr_SetFromErrno(PyExc_OSError);
-    // note: boot time might also be determined from here
-    return Py_BuildValue(
-        "(kkkkkkI)",
-        info.totalram,  // total
-        info.freeram,  // free
-        info.bufferram, // buffer
-        info.sharedram, // shared
-        info.totalswap, // swap tot
-        info.freeswap,  // swap free
-        info.mem_unit  // multiplier
-    );
-}
-
-
-/*
- * Return process CPU affinity as a Python list
- * The dual implementation exists because of:
- * https://github.com/giampaolo/psutil/issues/536
- */
-
-#ifdef CPU_ALLOC
-
-static PyObject *
-psutil_proc_cpu_affinity_get(PyObject *self, PyObject *args) {
-    int cpu, ncpus, count, cpucount_s;
-    long pid;
-    size_t setsize;
-    cpu_set_t *mask = NULL;
-    PyObject *py_list = NULL;
-
-    if (!PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    ncpus = NCPUS_START;
-    while (1) {
-        setsize = CPU_ALLOC_SIZE(ncpus);
-        mask = CPU_ALLOC(ncpus);
-        if (mask == NULL)
-            return PyErr_NoMemory();
-        if (sched_getaffinity(pid, setsize, mask) == 0)
-            break;
-        CPU_FREE(mask);
-        if (errno != EINVAL)
-            return PyErr_SetFromErrno(PyExc_OSError);
-        if (ncpus > INT_MAX / 2) {
-            PyErr_SetString(PyExc_OverflowError, "could not allocate "
-                            "a large enough CPU set");
-            return NULL;
-        }
-        ncpus = ncpus * 2;
-    }
-
-    py_list = PyList_New(0);
-    if (py_list == NULL)
-        goto error;
-
-    cpucount_s = CPU_COUNT_S(setsize, mask);
-    for (cpu = 0, count = cpucount_s; count; cpu++) {
-        if (CPU_ISSET_S(cpu, setsize, mask)) {
-#if PY_MAJOR_VERSION >= 3
-            PyObject *cpu_num = PyLong_FromLong(cpu);
-#else
-            PyObject *cpu_num = PyInt_FromLong(cpu);
-#endif
-            if (cpu_num == NULL)
-                goto error;
-            if (PyList_Append(py_list, cpu_num)) {
-                Py_DECREF(cpu_num);
-                goto error;
-            }
-            Py_DECREF(cpu_num);
-            --count;
-        }
-    }
-    CPU_FREE(mask);
-    return py_list;
-
-error:
-    if (mask)
-        CPU_FREE(mask);
-    Py_XDECREF(py_list);
-    return NULL;
-}
-#else
-
-
-/*
- * Alternative implementation in case CPU_ALLOC is not defined.
- */
-static PyObject *
-psutil_proc_cpu_affinity_get(PyObject *self, PyObject *args) {
-    cpu_set_t cpuset;
-    unsigned int len = sizeof(cpu_set_t);
-    long pid;
-    int i;
-    PyObject* py_retlist = NULL;
-    PyObject *py_cpu_num = NULL;
-
-    if (!PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-	CPU_ZERO(&cpuset);
-    if (sched_getaffinity(pid, len, &cpuset) < 0)
-        return PyErr_SetFromErrno(PyExc_OSError);
-
-    py_retlist = PyList_New(0);
-    if (py_retlist == NULL)
-        goto error;
-    for (i = 0; i < CPU_SETSIZE; ++i) {
-        if (CPU_ISSET(i, &cpuset)) {
-            py_cpu_num = Py_BuildValue("i", i);
-            if (py_cpu_num == NULL)
-                goto error;
-            if (PyList_Append(py_retlist, py_cpu_num))
-                goto error;
-            Py_DECREF(py_cpu_num);
-        }
-    }
-
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_cpu_num);
-    Py_XDECREF(py_retlist);
-    return NULL;
-}
-#endif
-
-/*
- * Set process CPU affinity; expects a bitmask
- */
-static PyObject *
-psutil_proc_cpu_affinity_set(PyObject *self, PyObject *args) {
-    cpu_set_t cpu_set;
-    size_t len;
-    long pid;
-    int i, seq_len;
-    PyObject *py_cpu_set;
-    PyObject *py_cpu_seq = NULL;
-
-    if (!PyArg_ParseTuple(args, "lO", &pid, &py_cpu_set))
-        return NULL;
-
-    if (!PySequence_Check(py_cpu_set)) {
-        PyErr_Format(PyExc_TypeError, "sequence argument expected, got %s",
-                     Py_TYPE(py_cpu_set)->tp_name);
-        goto error;
-    }
-
-    py_cpu_seq = PySequence_Fast(py_cpu_set, "expected a sequence or integer");
-    if (!py_cpu_seq)
-        goto error;
-    seq_len = PySequence_Fast_GET_SIZE(py_cpu_seq);
-    CPU_ZERO(&cpu_set);
-    for (i = 0; i < seq_len; i++) {
-        PyObject *item = PySequence_Fast_GET_ITEM(py_cpu_seq, i);
-#if PY_MAJOR_VERSION >= 3
-        long value = PyLong_AsLong(item);
-#else
-        long value = PyInt_AsLong(item);
-#endif
-        if (value == -1 && PyErr_Occurred())
-            goto error;
-        CPU_SET(value, &cpu_set);
-    }
-
-    len = sizeof(cpu_set);
-    if (sched_setaffinity(pid, len, &cpu_set)) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    Py_DECREF(py_cpu_seq);
-    Py_RETURN_NONE;
-
-error:
-    if (py_cpu_seq != NULL)
-        Py_DECREF(py_cpu_seq);
-    return NULL;
-}
-
-
-/*
- * Return currently connected users as a list of tuples.
- */
-static PyObject *
-psutil_users(PyObject *self, PyObject *args) {
-    struct utmp *ut;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_user_proc = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    setutent();
-    while (NULL != (ut = getutent())) {
-        py_tuple = NULL;
-        py_user_proc = NULL;
-        if (ut->ut_type == USER_PROCESS)
-            py_user_proc = Py_True;
-        else
-            py_user_proc = Py_False;
-        py_tuple = Py_BuildValue(
-            "(sssfO)",
-            ut->ut_user,              // username
-            ut->ut_line,              // tty
-            ut->ut_host,              // hostname
-            (float)ut->ut_tv.tv_sec,  // tstamp
-            py_user_proc              // (bool) user process
-        );
-    if (! py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-    endutent();
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_user_proc);
-    Py_DECREF(py_retlist);
-    endutent();
-    return NULL;
-}
-
-
-/*
- * Return stats about a particular network
- * interface.  References:
- * https://github.com/dpaleino/wicd/blob/master/wicd/backends/be-ioctl.py
- * http://www.i-scream.org/libstatgrab/
- */
-static PyObject*
-psutil_net_if_stats(PyObject* self, PyObject* args) {
-    char *nic_name;
-    int sock = 0;
-    int ret;
-    int duplex;
-    int speed;
-    int mtu;
-    struct ifreq ifr;
-    struct ethtool_cmd ethcmd;
-    PyObject *py_is_up = NULL;
-    PyObject *py_retlist = NULL;
-
-    if (! PyArg_ParseTuple(args, "s", &nic_name))
-        return NULL;
-
-    sock = socket(AF_INET, SOCK_DGRAM, 0);
-    if (sock == -1)
-        goto error;
-    strncpy(ifr.ifr_name, nic_name, sizeof(ifr.ifr_name));
-
-    // is up?
-    ret = ioctl(sock, SIOCGIFFLAGS, &ifr);
-    if (ret == -1)
-        goto error;
-    if ((ifr.ifr_flags & IFF_UP) != 0)
-        py_is_up = Py_True;
-    else
-        py_is_up = Py_False;
-    Py_INCREF(py_is_up);
-
-    // MTU
-    ret = ioctl(sock, SIOCGIFMTU, &ifr);
-    if (ret == -1)
-        goto error;
-    mtu = ifr.ifr_mtu;
-
-    // duplex and speed
-    memset(&ethcmd, 0, sizeof ethcmd);
-    ethcmd.cmd = ETHTOOL_GSET;
-    ifr.ifr_data = (void *)&ethcmd;
-    ret = ioctl(sock, SIOCETHTOOL, &ifr);
-
-    if (ret != -1) {
-        duplex = ethcmd.duplex;
-        speed = ethcmd.speed;
-    }
-    else {
-        if ((errno == EOPNOTSUPP) || (errno == EINVAL)) {
-            // EOPNOTSUPP may occur in case of wi-fi cards.
-            // For EINVAL see:
-            // https://github.com/giampaolo/psutil/issues/797
-            //     #issuecomment-202999532
-            duplex = DUPLEX_UNKNOWN;
-            speed = 0;
-        }
-        else {
-            goto error;
-        }
-    }
-
-    close(sock);
-    py_retlist = Py_BuildValue("[Oiii]", py_is_up, duplex, speed, mtu);
-    if (!py_retlist)
-        goto error;
-    Py_DECREF(py_is_up);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_is_up);
-    if (sock != 0)
-        close(sock);
-    PyErr_SetFromErrno(PyExc_OSError);
-    return NULL;
-}
-
-
-/*
- * Define the psutil C module methods and initialize the module.
- */
-static PyMethodDef
-PsutilMethods[] = {
-
+static PyMethodDef mod_methods[] = {
     // --- per-process functions
-
-#if PSUTIL_HAVE_IOPRIO
-    {"proc_ioprio_get", psutil_proc_ioprio_get, METH_VARARGS,
-     "Get process I/O priority"},
-    {"proc_ioprio_set", psutil_proc_ioprio_set, METH_VARARGS,
-     "Set process I/O priority"},
+    {"proc_ioprio_get", psutil_proc_ioprio_get, METH_VARARGS},
+    {"proc_ioprio_set", psutil_proc_ioprio_set, METH_VARARGS},
+#ifdef PSUTIL_HAS_CPU_AFFINITY
+    {"proc_cpu_affinity_get", psutil_proc_cpu_affinity_get, METH_VARARGS},
+    {"proc_cpu_affinity_set", psutil_proc_cpu_affinity_set, METH_VARARGS},
 #endif
-    {"proc_cpu_affinity_get", psutil_proc_cpu_affinity_get, METH_VARARGS,
-     "Return process CPU affinity as a Python long (the bitmask)."},
-    {"proc_cpu_affinity_set", psutil_proc_cpu_affinity_set, METH_VARARGS,
-     "Set process CPU affinity; expects a bitmask."},
-
     // --- system related functions
-
-    {"disk_partitions", psutil_disk_partitions, METH_VARARGS,
-     "Return disk mounted partitions as a list of tuples including "
-     "device, mount point and filesystem type"},
-    {"users", psutil_users, METH_VARARGS,
-     "Return currently connected users as a list of tuples"},
-    {"net_if_stats", psutil_net_if_stats, METH_VARARGS,
-     "Return NIC stats (isup, duplex, speed, mtu)"},
-
-    // --- linux specific
-
-    {"linux_sysinfo", psutil_linux_sysinfo, METH_VARARGS,
-     "A wrapper around sysinfo(), return system memory usage statistics"},
-#if PSUTIL_HAVE_PRLIMIT
-    {"linux_prlimit", psutil_linux_prlimit, METH_VARARGS,
-     "Get or set process resource limits."},
+    {"disk_partitions", psutil_disk_partitions, METH_VARARGS},
+    {"net_if_duplex_speed", psutil_net_if_duplex_speed, METH_VARARGS},
+#ifdef PSUTIL_HAS_HEAP_INFO
+    {"heap_info", psutil_heap_info, METH_VARARGS},
+#endif
+#ifdef PSUTIL_HAS_HEAP_TRIM
+    {"heap_trim", psutil_heap_trim, METH_VARARGS},
 #endif
 
-
+    // --- linux specific
+    {"linux_sysinfo", psutil_linux_sysinfo, METH_VARARGS},
+    // --- others
+    {"check_pid_range", psutil_check_pid_range, METH_VARARGS},
+    {"set_debug", psutil_set_debug, METH_VARARGS},
     {NULL, NULL, 0, NULL}
 };
 
-struct module_state {
-    PyObject *error;
-};
-
-#if PY_MAJOR_VERSION >= 3
-#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
-#else
-#define GETSTATE(m) (&_state)
-#endif
-
-#if PY_MAJOR_VERSION >= 3
 
 static int
-psutil_linux_traverse(PyObject *m, visitproc visit, void *arg) {
-    Py_VISIT(GETSTATE(m)->error);
+psutil_add_constants(PyObject *mod) {
+    PSUTIL_ADD_INT(mod, "version", PSUTIL_VERSION);
+    PSUTIL_ADD_INT(mod, "DUPLEX_HALF", DUPLEX_HALF);
+    PSUTIL_ADD_INT(mod, "DUPLEX_FULL", DUPLEX_FULL);
+    PSUTIL_ADD_INT(mod, "DUPLEX_UNKNOWN", DUPLEX_UNKNOWN);
     return 0;
 }
 
+
 static int
-psutil_linux_clear(PyObject *m) {
-    Py_CLEAR(GETSTATE(m)->error);
+psutil_exec(PyObject *mod) {
+    if (psutil_setup() != 0)
+        return -1;
+    if (psutil_posix_add_constants(mod) != 0)
+        return -1;
+    if (psutil_posix_add_methods(mod) != 0)
+        return -1;
+    if (psutil_add_exceptions(mod) != 0)
+        return -1;
+    if (psutil_add_constants(mod) != 0)
+        return -1;
     return 0;
 }
 
-static struct PyModuleDef
-        moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "psutil_linux",
-    NULL,
-    sizeof(struct module_state),
-    PsutilMethods,
-    NULL,
-    psutil_linux_traverse,
-    psutil_linux_clear,
-    NULL
-};
-
-#define INITERROR return NULL
-
-PyMODINIT_FUNC PyInit__psutil_linux(void)
-
-#else
-#define INITERROR return
-
-void init_psutil_linux(void)
-#endif
-{
-    PyObject *v;
-#if PY_MAJOR_VERSION >= 3
-    PyObject *module = PyModule_Create(&moduledef);
-#else
-    PyObject *module = Py_InitModule("_psutil_linux", PsutilMethods);
-#endif
-
-    PyModule_AddIntConstant(module, "version", PSUTIL_VERSION);
-#if PSUTIL_HAVE_PRLIMIT
-    PyModule_AddIntConstant(module, "RLIMIT_AS", RLIMIT_AS);
-    PyModule_AddIntConstant(module, "RLIMIT_CORE", RLIMIT_CORE);
-    PyModule_AddIntConstant(module, "RLIMIT_CPU", RLIMIT_CPU);
-    PyModule_AddIntConstant(module, "RLIMIT_DATA", RLIMIT_DATA);
-    PyModule_AddIntConstant(module, "RLIMIT_FSIZE", RLIMIT_FSIZE);
-    PyModule_AddIntConstant(module, "RLIMIT_LOCKS", RLIMIT_LOCKS);
-    PyModule_AddIntConstant(module, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK);
-    PyModule_AddIntConstant(module, "RLIMIT_NOFILE", RLIMIT_NOFILE);
-    PyModule_AddIntConstant(module, "RLIMIT_NPROC", RLIMIT_NPROC);
-    PyModule_AddIntConstant(module, "RLIMIT_RSS", RLIMIT_RSS);
-    PyModule_AddIntConstant(module, "RLIMIT_STACK", RLIMIT_STACK);
-
-#if defined(HAVE_LONG_LONG)
-    if (sizeof(RLIM_INFINITY) > sizeof(long)) {
-        v = PyLong_FromLongLong((PY_LONG_LONG) RLIM_INFINITY);
-    } else
-#endif
-    {
-        v = PyLong_FromLong((long) RLIM_INFINITY);
-    }
-    if (v) {
-        PyModule_AddObject(module, "RLIM_INFINITY", v);
-    }
-
-#ifdef RLIMIT_MSGQUEUE
-    PyModule_AddIntConstant(module, "RLIMIT_MSGQUEUE", RLIMIT_MSGQUEUE);
-#endif
-#ifdef RLIMIT_NICE
-    PyModule_AddIntConstant(module, "RLIMIT_NICE", RLIMIT_NICE);
-#endif
-#ifdef RLIMIT_RTPRIO
-    PyModule_AddIntConstant(module, "RLIMIT_RTPRIO", RLIMIT_RTPRIO);
-#endif
-#ifdef RLIMIT_RTTIME
-    PyModule_AddIntConstant(module, "RLIMIT_RTTIME", RLIMIT_RTTIME);
-#endif
-#ifdef RLIMIT_SIGPENDING
-    PyModule_AddIntConstant(module, "RLIMIT_SIGPENDING", RLIMIT_SIGPENDING);
-#endif
-#endif
-    PyModule_AddIntConstant(module, "DUPLEX_HALF", DUPLEX_HALF);
-    PyModule_AddIntConstant(module, "DUPLEX_FULL", DUPLEX_FULL);
-    PyModule_AddIntConstant(module, "DUPLEX_UNKNOWN", DUPLEX_UNKNOWN);
-
-    if (module == NULL)
-        INITERROR;
-#if PY_MAJOR_VERSION >= 3
-    return module;
-#endif
+PyMODINIT_FUNC
+PyInit__psutil(void) {
+    return psutil_mod_init("_psutil", mod_methods, psutil_exec);
 }
diff --git a/psutil/_psutil_osx.c b/psutil/_psutil_osx.c
index b78035e6a6..4ac60bffe8 100644
--- a/psutil/_psutil_osx.c
+++ b/psutil/_psutil_osx.c
@@ -1,1986 +1,113 @@
 /*
- * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
- *
- * OS X platform-specific module methods for _psutil_osx
  */
 
 #include <Python.h>
-#include <assert.h>
-#include <errno.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <utmpx.h>
-#include <sys/sysctl.h>
-#include <sys/vmmeter.h>
-#include <libproc.h>
-#include <sys/proc_info.h>
+#include <sys/types.h>  // NODEV
+#include <sys/time.h>  // needed for old macOS versions
+#include <sys/proc.h>
 #include <netinet/tcp_fsm.h>
-#include <arpa/inet.h>
-#include <net/if_dl.h>
-#include <pwd.h>
 
-#include <mach/mach.h>
-#include <mach/task.h>
-#include <mach/mach_init.h>
-#include <mach/host_info.h>
-#include <mach/mach_host.h>
-#include <mach/mach_traps.h>
-#include <mach/mach_vm.h>
-#include <mach/shared_region.h>
+#include "arch/all/init.h"
+#include "arch/osx/init.h"
 
-#include <mach-o/loader.h>
-
-#include <CoreFoundation/CoreFoundation.h>
-#include <IOKit/IOKitLib.h>
-#include <IOKit/storage/IOBlockStorageDriver.h>
-#include <IOKit/storage/IOMedia.h>
-#include <IOKit/IOBSD.h>
-
-#include "_psutil_common.h"
-#include "arch/osx/process_info.h"
-
-
-#define PSUTIL_TV2DOUBLE(t) ((t).tv_sec + (t).tv_usec / 1000000.0)
-
-
-/*
- * A wrapper around host_statistics() invoked with HOST_VM_INFO.
- */
-int
-psutil_sys_vminfo(vm_statistics_data_t *vmstat) {
-    kern_return_t ret;
-    mach_msg_type_number_t count = sizeof(*vmstat) / sizeof(integer_t);
-    mach_port_t mport = mach_host_self();
-
-    ret = host_statistics(mport, HOST_VM_INFO, (host_info_t)vmstat, &count);
-    if (ret != KERN_SUCCESS) {
-        PyErr_Format(PyExc_RuntimeError,
-                     "host_statistics() failed: %s", mach_error_string(ret));
-        return 0;
-    }
-    mach_port_deallocate(mach_task_self(), mport);
-    return 1;
-}
-
-
-/*
- * Set exception to AccessDenied if pid exists else NoSuchProcess.
- */
-void
-psutil_raise_ad_or_nsp(long pid) {
-    int ret;
-    ret = psutil_pid_exists(pid);
-    if (ret == 0)
-        NoSuchProcess();
-    else
-        AccessDenied();
-}
-
-
-/*
- * Return a Python list of all the PIDs running on the system.
- */
-static PyObject *
-psutil_pids(PyObject *self, PyObject *args) {
-    kinfo_proc *proclist = NULL;
-    kinfo_proc *orig_address = NULL;
-    size_t num_processes;
-    size_t idx;
-    PyObject *py_pid = NULL;
-    PyObject *py_retlist = PyList_New(0);
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    if (psutil_get_proc_list(&proclist, &num_processes) != 0) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "failed to retrieve process list.");
-        goto error;
-    }
-
-    if (num_processes > 0) {
-        // save the address of proclist so we can free it later
-        orig_address = proclist;
-        for (idx = 0; idx < num_processes; idx++) {
-            py_pid = Py_BuildValue("i", proclist->kp_proc.p_pid);
-            if (! py_pid)
-                goto error;
-            if (PyList_Append(py_retlist, py_pid))
-                goto error;
-            Py_DECREF(py_pid);
-            proclist++;
-        }
-        free(orig_address);
-    }
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_pid);
-    Py_DECREF(py_retlist);
-    if (orig_address != NULL)
-        free(orig_address);
-    return NULL;
-}
-
-
-/*
- * Return process name from kinfo_proc as a Python string.
- */
-static PyObject *
-psutil_proc_name(PyObject *self, PyObject *args) {
-    long pid;
-    struct kinfo_proc kp;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_get_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-#if PY_MAJOR_VERSION >= 3
-    return PyUnicode_DecodeFSDefault(kp.kp_proc.p_comm);
-#else
-    return Py_BuildValue("s", kp.kp_proc.p_comm);
-#endif
-
-}
-
-
-/*
- * Return process current working directory.
- */
-static PyObject *
-psutil_proc_cwd(PyObject *self, PyObject *args) {
-    long pid;
-    struct proc_vnodepathinfo pathinfo;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    if (! psutil_proc_pidinfo(pid, PROC_PIDVNODEPATHINFO, &pathinfo,
-                              sizeof(pathinfo)))
-    {
-        return NULL;
-    }
-
-#if PY_MAJOR_VERSION >= 3
-    return PyUnicode_DecodeFSDefault(pathinfo.pvi_cdir.vip_path);
-#else
-    return Py_BuildValue("s", pathinfo.pvi_cdir.vip_path);
-#endif
-}
-
-
-/*
- * Return path of the process executable.
- */
-static PyObject *
-psutil_proc_exe(PyObject *self, PyObject *args) {
-    long pid;
-    char buf[PATH_MAX];
-    int ret;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    ret = proc_pidpath(pid, &buf, sizeof(buf));
-    if (ret == 0) {
-        psutil_raise_ad_or_nsp(pid);
-        return NULL;
-    }
-#if PY_MAJOR_VERSION >= 3
-    return PyUnicode_DecodeFSDefault(buf);
-#else
-    return Py_BuildValue("s", buf);
-#endif
-}
-
-
-/*
- * Return process cmdline as a Python list of cmdline arguments.
- */
-static PyObject *
-psutil_proc_cmdline(PyObject *self, PyObject *args) {
-    long pid;
-    PyObject *py_retlist = NULL;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    // get the commandline, defined in arch/osx/process_info.c
-    py_retlist = psutil_get_cmdline(pid);
-    return py_retlist;
-}
-
-
-/*
- * Return process environment as a Python string.
- */
-static PyObject *
-psutil_proc_environ(PyObject *self, PyObject *args) {
-    long pid;
-    PyObject *py_retdict = NULL;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    // get the environment block, defined in arch/osx/process_info.c
-    py_retdict = psutil_get_environ(pid);
-    return py_retdict;
-}
-
-
-/*
- * Return process parent pid from kinfo_proc as a Python integer.
- */
-static PyObject *
-psutil_proc_ppid(PyObject *self, PyObject *args) {
-    long pid;
-    struct kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_get_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("l", (long)kp.kp_eproc.e_ppid);
-}
-
-
-/*
- * Return process real uid from kinfo_proc as a Python integer.
- */
-static PyObject *
-psutil_proc_uids(PyObject *self, PyObject *args) {
-    long pid;
-    struct kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_get_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("lll",
-                         (long)kp.kp_eproc.e_pcred.p_ruid,
-                         (long)kp.kp_eproc.e_ucred.cr_uid,
-                         (long)kp.kp_eproc.e_pcred.p_svuid);
-}
-
-
-/*
- * Return process real group id from ki_comm as a Python integer.
- */
-static PyObject *
-psutil_proc_gids(PyObject *self, PyObject *args) {
-    long pid;
-    struct kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_get_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("lll",
-                         (long)kp.kp_eproc.e_pcred.p_rgid,
-                         (long)kp.kp_eproc.e_ucred.cr_groups[0],
-                         (long)kp.kp_eproc.e_pcred.p_svgid);
-}
-
-
-/*
- * Return process controlling terminal number as an integer.
- */
-static PyObject *
-psutil_proc_tty_nr(PyObject *self, PyObject *args) {
-    long pid;
-    struct kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_get_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("i", kp.kp_eproc.e_tdev);
-}
-
-
-/*
- * Return a list of tuples for every process memory maps.
- * 'procstat' cmdline utility has been used as an example.
- */
-static PyObject *
-psutil_proc_memory_maps(PyObject *self, PyObject *args) {
-    char buf[PATH_MAX];
-    char addr_str[34];
-    char perms[8];
-    int pagesize = getpagesize();
-    long pid;
-    kern_return_t err = KERN_SUCCESS;
-    mach_port_t task = MACH_PORT_NULL;
-    uint32_t depth = 1;
-    vm_address_t address = 0;
-    vm_size_t size = 0;
-
-    PyObject *py_tuple = NULL;
-    PyObject *py_list = PyList_New(0);
-
-    if (py_list == NULL)
-        return NULL;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-
-    err = task_for_pid(mach_task_self(), pid, &task);
-
-    if (err != KERN_SUCCESS) {
-        psutil_raise_ad_or_nsp(pid);
-        goto error;
-    }
-
-    while (1) {
-        py_tuple = NULL;
-        struct vm_region_submap_info_64 info;
-        mach_msg_type_number_t count = VM_REGION_SUBMAP_INFO_COUNT_64;
-
-        err = vm_region_recurse_64(task, &address, &size, &depth,
-                                   (vm_region_info_64_t)&info, &count);
-        if (err == KERN_INVALID_ADDRESS)
-            break;
-        if (info.is_submap) {
-            depth++;
-        }
-        else {
-            // Free/Reset the char[]s to avoid weird paths
-            memset(buf, 0, sizeof(buf));
-            memset(addr_str, 0, sizeof(addr_str));
-            memset(perms, 0, sizeof(perms));
-
-            sprintf(addr_str, "%016lx-%016lx", address, address + size);
-            sprintf(perms, "%c%c%c/%c%c%c",
-                    (info.protection & VM_PROT_READ) ? 'r' : '-',
-                    (info.protection & VM_PROT_WRITE) ? 'w' : '-',
-                    (info.protection & VM_PROT_EXECUTE) ? 'x' : '-',
-                    (info.max_protection & VM_PROT_READ) ? 'r' : '-',
-                    (info.max_protection & VM_PROT_WRITE) ? 'w' : '-',
-                    (info.max_protection & VM_PROT_EXECUTE) ? 'x' : '-');
-
-            err = proc_regionfilename(pid, address, buf, sizeof(buf));
-
-            if (info.share_mode == SM_COW && info.ref_count == 1) {
-                // Treat single reference SM_COW as SM_PRIVATE
-                info.share_mode = SM_PRIVATE;
-            }
-
-            if (strlen(buf) == 0) {
-                switch (info.share_mode) {
-// #ifdef SM_LARGE_PAGE
-                    // case SM_LARGE_PAGE:
-                        // Treat SM_LARGE_PAGE the same as SM_PRIVATE
-                        // since they are not shareable and are wired.
-// #endif
-                    case SM_COW:
-                        strcpy(buf, "[cow]");
-                        break;
-                    case SM_PRIVATE:
-                        strcpy(buf, "[prv]");
-                        break;
-                    case SM_EMPTY:
-                        strcpy(buf, "[nul]");
-                        break;
-                    case SM_SHARED:
-                    case SM_TRUESHARED:
-                        strcpy(buf, "[shm]");
-                        break;
-                    case SM_PRIVATE_ALIASED:
-                        strcpy(buf, "[ali]");
-                        break;
-                    case SM_SHARED_ALIASED:
-                        strcpy(buf, "[s/a]");
-                        break;
-                    default:
-                        strcpy(buf, "[???]");
-                }
-            }
-
-            py_tuple = Py_BuildValue(
-                "sssIIIIIH",
-                addr_str,                                 // "start-end"address
-                perms,                                    // "rwx" permissions
-                buf,                                      // path
-                info.pages_resident * pagesize,           // rss
-                info.pages_shared_now_private * pagesize, // private
-                info.pages_swapped_out * pagesize,        // swapped
-                info.pages_dirtied * pagesize,            // dirtied
-                info.ref_count,                           // ref count
-                info.shadow_depth                         // shadow depth
-            );
-            if (!py_tuple)
-                goto error;
-            if (PyList_Append(py_list, py_tuple))
-                goto error;
-            Py_DECREF(py_tuple);
-        }
-
-        // increment address for the next map/file
-        address += size;
-    }
-
-    if (task != MACH_PORT_NULL)
-        mach_port_deallocate(mach_task_self(), task);
-
-    return py_list;
-
-error:
-    if (task != MACH_PORT_NULL)
-        mach_port_deallocate(mach_task_self(), task);
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_list);
-    return NULL;
-}
-
-
-/*
- * Return the number of logical CPUs in the system.
- * XXX this could be shared with BSD.
- */
-static PyObject *
-psutil_cpu_count_logical(PyObject *self, PyObject *args) {
-    /*
-    int mib[2];
-    int ncpu;
-    size_t len;
-    mib[0] = CTL_HW;
-    mib[1] = HW_NCPU;
-    len = sizeof(ncpu);
-
-    if (sysctl(mib, 2, &ncpu, &len, NULL, 0) == -1)
-        Py_RETURN_NONE;  // mimic os.cpu_count()
-    else
-        return Py_BuildValue("i", ncpu);
-    */
-    int num;
-    size_t size = sizeof(int);
-
-    if (sysctlbyname("hw.logicalcpu", &num, &size, NULL, 2))
-        Py_RETURN_NONE;  // mimic os.cpu_count()
-    else
-        return Py_BuildValue("i", num);
-}
-
-
-/*
- * Return the number of physical CPUs in the system.
- */
-static PyObject *
-psutil_cpu_count_phys(PyObject *self, PyObject *args) {
-    int num;
-    size_t size = sizeof(int);
-
-    if (sysctlbyname("hw.physicalcpu", &num, &size, NULL, 0))
-        Py_RETURN_NONE;  // mimic os.cpu_count()
-    else
-        return Py_BuildValue("i", num);
-}
-
-
-/*
- * Return a Python tuple (user_time, kernel_time)
- */
-static PyObject *
-psutil_proc_cpu_times(PyObject *self, PyObject *args) {
-    long pid;
-    struct proc_taskinfo pti;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (! psutil_proc_pidinfo(pid, PROC_PIDTASKINFO, &pti, sizeof(pti)))
-        return NULL;
-    return Py_BuildValue("(dd)",
-                         (float)pti.pti_total_user / 1000000000.0,
-                         (float)pti.pti_total_system / 1000000000.0);
-}
-
-
-/*
- * Return a Python float indicating the process create time expressed in
- * seconds since the epoch.
- */
-static PyObject *
-psutil_proc_create_time(PyObject *self, PyObject *args) {
-    long pid;
-    struct kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_get_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("d", PSUTIL_TV2DOUBLE(kp.kp_proc.p_starttime));
-}
-
-
-/*
- * Return extended memory info about a process.
- */
-static PyObject *
-psutil_proc_memory_info(PyObject *self, PyObject *args) {
-    long pid;
-    struct proc_taskinfo pti;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (! psutil_proc_pidinfo(pid, PROC_PIDTASKINFO, &pti, sizeof(pti)))
-        return NULL;
-    // Note: determining other memory stats on OSX is a mess:
-    // http://www.opensource.apple.com/source/top/top-67/libtop.c?txt
-    // I just give up...
-    // struct proc_regioninfo pri;
-    // psutil_proc_pidinfo(pid, PROC_PIDREGIONINFO, &pri, sizeof(pri))
-    return Py_BuildValue(
-        "(KKkk)",
-        pti.pti_resident_size,  // resident memory size (rss)
-        pti.pti_virtual_size,   // virtual memory size (vms)
-        pti.pti_faults,         // number of page faults (pages)
-        pti.pti_pageins         // number of actual pageins (pages)
-    );
-}
-
-
-/*
- * Indicates if the given virtual address on the given architecture is in the
- * shared VM region.
- */
-bool
-psutil_in_shared_region(mach_vm_address_t addr, cpu_type_t type) {
-    mach_vm_address_t base;
-    mach_vm_address_t size;
-
-    switch (type) {
-        case CPU_TYPE_ARM:
-            base = SHARED_REGION_BASE_ARM;
-            size = SHARED_REGION_SIZE_ARM;
-            break;
-        case CPU_TYPE_I386:
-            base = SHARED_REGION_BASE_I386;
-            size = SHARED_REGION_SIZE_I386;
-            break;
-        case CPU_TYPE_X86_64:
-            base = SHARED_REGION_BASE_X86_64;
-            size = SHARED_REGION_SIZE_X86_64;
-            break;
-        default:
-            return false;
-    }
-
-    return base <= addr && addr < (base + size);
-}
-
-
-/*
- * Returns the USS (unique set size) of the process. Reference:
- * https://dxr.mozilla.org/mozilla-central/source/xpcom/base/
- *     nsMemoryReporterManager.cpp
- */
-static PyObject *
-psutil_proc_memory_uss(PyObject *self, PyObject *args) {
-    long pid;
-    int err;
-    size_t len;
-    cpu_type_t cpu_type;
-    size_t private_pages = 0;
-    mach_vm_size_t size = 0;
-    mach_msg_type_number_t info_count = VM_REGION_TOP_INFO_COUNT;
-    kern_return_t kr;
-    vm_size_t page_size;
-    mach_vm_address_t addr = MACH_VM_MIN_ADDRESS;
-    mach_port_t task = MACH_PORT_NULL;
-    vm_region_top_info_data_t info;
-    mach_port_t object_name;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    err = task_for_pid(mach_task_self(), pid, &task);
-    if (err != KERN_SUCCESS) {
-        psutil_raise_ad_or_nsp(pid);
-        return NULL;
-    }
-
-    len = sizeof(cpu_type);
-    if (sysctlbyname("sysctl.proc_cputype", &cpu_type, &len, NULL, 0) != 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    // Roughly based on libtop_update_vm_regions in
-    // http://www.opensource.apple.com/source/top/top-100.1.2/libtop.c
-    for (addr = 0; ; addr += size) {
-        kr = mach_vm_region(
-            task, &addr, &size, VM_REGION_TOP_INFO, (vm_region_info_t)&info,
-            &info_count, &object_name);
-        if (kr == KERN_INVALID_ADDRESS) {
-            // Done iterating VM regions.
-            break;
-        }
-        else if (kr != KERN_SUCCESS) {
-            PyErr_Format(PyExc_RuntimeError, "mach_vm_region() failed");
-            return NULL;
-        }
-
-        if (psutil_in_shared_region(addr, cpu_type) &&
-                info.share_mode != SM_PRIVATE) {
-            continue;
-        }
-
-        switch (info.share_mode) {
-#ifdef SM_LARGE_PAGE
-            case SM_LARGE_PAGE:
-                // NB: Large pages are not shareable and always resident.
-#endif
-            case SM_PRIVATE:
-                private_pages += info.private_pages_resident;
-                private_pages += info.shared_pages_resident;
-                break;
-            case SM_COW:
-                private_pages += info.private_pages_resident;
-                if (info.ref_count == 1) {
-                    // Treat copy-on-write pages as private if they only
-                    // have one reference.
-                    private_pages += info.shared_pages_resident;
-                }
-                break;
-            case SM_SHARED:
-            default:
-                break;
-        }
-    }
-
-    mach_port_deallocate(mach_task_self(), task);
-
-    if (host_page_size(mach_host_self(), &page_size) != KERN_SUCCESS)
-        page_size = PAGE_SIZE;
-
-    return Py_BuildValue("K", private_pages * page_size);
-}
-
-
-/*
- * Return number of threads used by process as a Python integer.
- */
-static PyObject *
-psutil_proc_num_threads(PyObject *self, PyObject *args) {
-    long pid;
-    struct proc_taskinfo pti;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (! psutil_proc_pidinfo(pid, PROC_PIDTASKINFO, &pti, sizeof(pti)))
-        return NULL;
-    return Py_BuildValue("k", pti.pti_threadnum);
-}
-
-
-/*
- * Return the number of context switches performed by process.
- */
-static PyObject *
-psutil_proc_num_ctx_switches(PyObject *self, PyObject *args) {
-    long pid;
-    struct proc_taskinfo pti;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (! psutil_proc_pidinfo(pid, PROC_PIDTASKINFO, &pti, sizeof(pti)))
-        return NULL;
-    // unvoluntary value seems not to be available;
-    // pti.pti_csw probably refers to the sum of the two (getrusage()
-    // numbers seems to confirm this theory).
-    return Py_BuildValue("ki", pti.pti_csw, 0);
-}
-
-
-/*
- * Return system virtual memory stats
- */
-static PyObject *
-psutil_virtual_mem(PyObject *self, PyObject *args) {
-    int      mib[2];
-    uint64_t total;
-    size_t   len = sizeof(total);
-    vm_statistics_data_t vm;
-    int pagesize = getpagesize();
-    // physical mem
-    mib[0] = CTL_HW;
-    mib[1] = HW_MEMSIZE;
-
-    // This is also available as sysctlbyname("hw.memsize").
-    if (sysctl(mib, 2, &total, &len, NULL, 0)) {
-        if (errno != 0)
-            PyErr_SetFromErrno(PyExc_OSError);
-        else
-            PyErr_Format(PyExc_RuntimeError, "sysctl(HW_MEMSIZE) failed");
-        return NULL;
-    }
-
-    // vm
-    if (!psutil_sys_vminfo(&vm))
-        return NULL;
-
-    return Py_BuildValue(
-        "KKKKK",
-        total,
-        (unsigned long long) vm.active_count * pagesize,
-        (unsigned long long) vm.inactive_count * pagesize,
-        (unsigned long long) vm.wire_count * pagesize,
-        (unsigned long long) vm.free_count * pagesize
-    );
-}
-
-
-/*
- * Return stats about swap memory.
- */
-static PyObject *
-psutil_swap_mem(PyObject *self, PyObject *args) {
-    int mib[2];
-    size_t size;
-    struct xsw_usage totals;
-    vm_statistics_data_t vmstat;
-    int pagesize = getpagesize();
-
-    mib[0] = CTL_VM;
-    mib[1] = VM_SWAPUSAGE;
-    size = sizeof(totals);
-    if (sysctl(mib, 2, &totals, &size, NULL, 0) == -1) {
-        if (errno != 0)
-            PyErr_SetFromErrno(PyExc_OSError);
-        else
-            PyErr_Format(PyExc_RuntimeError, "sysctl(VM_SWAPUSAGE) failed");
-        return NULL;
-    }
-    if (!psutil_sys_vminfo(&vmstat))
-        return NULL;
-
-    return Py_BuildValue(
-        "LLLKK",
-        totals.xsu_total,
-        totals.xsu_used,
-        totals.xsu_avail,
-        (unsigned long long)vmstat.pageins * pagesize,
-        (unsigned long long)vmstat.pageouts * pagesize);
-}
-
-
-/*
- * Return a Python tuple representing user, kernel and idle CPU times
- */
-static PyObject *
-psutil_cpu_times(PyObject *self, PyObject *args) {
-    mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
-    kern_return_t error;
-    host_cpu_load_info_data_t r_load;
-
-    mach_port_t host_port = mach_host_self();
-    error = host_statistics(host_port, HOST_CPU_LOAD_INFO,
-                            (host_info_t)&r_load, &count);
-    if (error != KERN_SUCCESS)
-        return PyErr_Format(PyExc_RuntimeError,
-                            "Error in host_statistics(): %s",
-                            mach_error_string(error));
-    mach_port_deallocate(mach_task_self(), host_port);
-
-    return Py_BuildValue(
-        "(dddd)",
-        (double)r_load.cpu_ticks[CPU_STATE_USER] / CLK_TCK,
-        (double)r_load.cpu_ticks[CPU_STATE_NICE] / CLK_TCK,
-        (double)r_load.cpu_ticks[CPU_STATE_SYSTEM] / CLK_TCK,
-        (double)r_load.cpu_ticks[CPU_STATE_IDLE] / CLK_TCK
-    );
-}
-
-
-/*
- * Return a Python list of tuple representing per-cpu times
- */
-static PyObject *
-psutil_per_cpu_times(PyObject *self, PyObject *args) {
-    natural_t cpu_count;
-    processor_info_array_t info_array;
-    mach_msg_type_number_t info_count;
-    kern_return_t error;
-    processor_cpu_load_info_data_t *cpu_load_info = NULL;
-    int i, ret;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_cputime = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    mach_port_t host_port = mach_host_self();
-    error = host_processor_info(host_port, PROCESSOR_CPU_LOAD_INFO,
-                                &cpu_count, &info_array, &info_count);
-    if (error != KERN_SUCCESS) {
-        PyErr_Format(PyExc_RuntimeError, "Error in host_processor_info(): %s",
-                     mach_error_string(error));
-        goto error;
-    }
-    mach_port_deallocate(mach_task_self(), host_port);
-
-    cpu_load_info = (processor_cpu_load_info_data_t *) info_array;
-
-    for (i = 0; i < cpu_count; i++) {
-        py_cputime = Py_BuildValue(
-            "(dddd)",
-            (double)cpu_load_info[i].cpu_ticks[CPU_STATE_USER] / CLK_TCK,
-            (double)cpu_load_info[i].cpu_ticks[CPU_STATE_NICE] / CLK_TCK,
-            (double)cpu_load_info[i].cpu_ticks[CPU_STATE_SYSTEM] / CLK_TCK,
-            (double)cpu_load_info[i].cpu_ticks[CPU_STATE_IDLE] / CLK_TCK
-        );
-        if (!py_cputime)
-            goto error;
-        if (PyList_Append(py_retlist, py_cputime))
-            goto error;
-        Py_DECREF(py_cputime);
-    }
-
-    ret = vm_deallocate(mach_task_self(), (vm_address_t)info_array,
-                        info_count * sizeof(int));
-    if (ret != KERN_SUCCESS)
-        PyErr_WarnEx(PyExc_RuntimeWarning, "vm_deallocate() failed", 2);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_cputime);
-    Py_DECREF(py_retlist);
-    if (cpu_load_info != NULL) {
-        ret = vm_deallocate(mach_task_self(), (vm_address_t)info_array,
-                            info_count * sizeof(int));
-        if (ret != KERN_SUCCESS)
-            PyErr_WarnEx(PyExc_RuntimeWarning, "vm_deallocate() failed", 2);
-    }
-    return NULL;
-}
-
-
-/*
- * Return a Python float indicating the system boot time expressed in
- * seconds since the epoch.
- */
-static PyObject *
-psutil_boot_time(PyObject *self, PyObject *args) {
-    // fetch sysctl "kern.boottime"
-    static int request[2] = { CTL_KERN, KERN_BOOTTIME };
-    struct timeval result;
-    size_t result_len = sizeof result;
-    time_t boot_time = 0;
-
-    if (sysctl(request, 2, &result, &result_len, NULL, 0) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-    boot_time = result.tv_sec;
-    return Py_BuildValue("f", (float)boot_time);
-}
-
-
-/*
- * Return a list of tuples including device, mount point and fs type
- * for all partitions mounted on the system.
- */
-static PyObject *
-psutil_disk_partitions(PyObject *self, PyObject *args) {
-    int num;
-    int i;
-    long len;
-    uint64_t flags;
-    char opts[400];
-    struct statfs *fs = NULL;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    // get the number of mount points
-    Py_BEGIN_ALLOW_THREADS
-    num = getfsstat(NULL, 0, MNT_NOWAIT);
-    Py_END_ALLOW_THREADS
-    if (num == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    len = sizeof(*fs) * num;
-    fs = malloc(len);
-    if (fs == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    Py_BEGIN_ALLOW_THREADS
-    num = getfsstat(fs, len, MNT_NOWAIT);
-    Py_END_ALLOW_THREADS
-    if (num == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    for (i = 0; i < num; i++) {
-        opts[0] = 0;
-        flags = fs[i].f_flags;
-
-        // see sys/mount.h
-        if (flags & MNT_RDONLY)
-            strlcat(opts, "ro", sizeof(opts));
-        else
-            strlcat(opts, "rw", sizeof(opts));
-        if (flags & MNT_SYNCHRONOUS)
-            strlcat(opts, ",sync", sizeof(opts));
-        if (flags & MNT_NOEXEC)
-            strlcat(opts, ",noexec", sizeof(opts));
-        if (flags & MNT_NOSUID)
-            strlcat(opts, ",nosuid", sizeof(opts));
-        if (flags & MNT_UNION)
-            strlcat(opts, ",union", sizeof(opts));
-        if (flags & MNT_ASYNC)
-            strlcat(opts, ",async", sizeof(opts));
-        if (flags & MNT_EXPORTED)
-            strlcat(opts, ",exported", sizeof(opts));
-        if (flags & MNT_QUARANTINE)
-            strlcat(opts, ",quarantine", sizeof(opts));
-        if (flags & MNT_LOCAL)
-            strlcat(opts, ",local", sizeof(opts));
-        if (flags & MNT_QUOTA)
-            strlcat(opts, ",quota", sizeof(opts));
-        if (flags & MNT_ROOTFS)
-            strlcat(opts, ",rootfs", sizeof(opts));
-        if (flags & MNT_DOVOLFS)
-            strlcat(opts, ",dovolfs", sizeof(opts));
-        if (flags & MNT_DONTBROWSE)
-            strlcat(opts, ",dontbrowse", sizeof(opts));
-        if (flags & MNT_IGNORE_OWNERSHIP)
-            strlcat(opts, ",ignore-ownership", sizeof(opts));
-        if (flags & MNT_AUTOMOUNTED)
-            strlcat(opts, ",automounted", sizeof(opts));
-        if (flags & MNT_JOURNALED)
-            strlcat(opts, ",journaled", sizeof(opts));
-        if (flags & MNT_NOUSERXATTR)
-            strlcat(opts, ",nouserxattr", sizeof(opts));
-        if (flags & MNT_DEFWRITE)
-            strlcat(opts, ",defwrite", sizeof(opts));
-        if (flags & MNT_MULTILABEL)
-            strlcat(opts, ",multilabel", sizeof(opts));
-        if (flags & MNT_NOATIME)
-            strlcat(opts, ",noatime", sizeof(opts));
-        if (flags & MNT_UPDATE)
-            strlcat(opts, ",update", sizeof(opts));
-        if (flags & MNT_RELOAD)
-            strlcat(opts, ",reload", sizeof(opts));
-        if (flags & MNT_FORCE)
-            strlcat(opts, ",force", sizeof(opts));
-        if (flags & MNT_CMDFLAGS)
-            strlcat(opts, ",cmdflags", sizeof(opts));
-
-        py_tuple = Py_BuildValue(
-            "(ssss)", fs[i].f_mntfromname,  // device
-            fs[i].f_mntonname,    // mount point
-            fs[i].f_fstypename,   // fs type
-            opts);                // options
-        if (!py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-
-    free(fs);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (fs != NULL)
-        free(fs);
-    return NULL;
-}
-
-
-/*
- * Return process status as a Python integer.
- */
-static PyObject *
-psutil_proc_status(PyObject *self, PyObject *args) {
-    long pid;
-    struct kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_get_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("i", (int)kp.kp_proc.p_stat);
-}
-
-
-/*
- * Return process threads
- */
-static PyObject *
-psutil_proc_threads(PyObject *self, PyObject *args) {
-    long pid;
-    int err, j, ret;
-    kern_return_t kr;
-    unsigned int info_count = TASK_BASIC_INFO_COUNT;
-    mach_port_t task = MACH_PORT_NULL;
-    struct task_basic_info tasks_info;
-    thread_act_port_array_t thread_list = NULL;
-    thread_info_data_t thinfo_basic;
-    thread_basic_info_t basic_info_th;
-    mach_msg_type_number_t thread_count, thread_info_count;
-
-    PyObject *py_tuple = NULL;
-    PyObject *py_retlist = PyList_New(0);
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    // the argument passed should be a process id
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-
-    // task_for_pid() requires special privileges
-    err = task_for_pid(mach_task_self(), pid, &task);
-    if (err != KERN_SUCCESS) {
-        psutil_raise_ad_or_nsp(pid);
-        goto error;
-    }
-
-    info_count = TASK_BASIC_INFO_COUNT;
-    err = task_info(task, TASK_BASIC_INFO, (task_info_t)&tasks_info,
-                    &info_count);
-    if (err != KERN_SUCCESS) {
-        // errcode 4 is "invalid argument" (access denied)
-        if (err == 4) {
-            AccessDenied();
-        }
-        else {
-            // otherwise throw a runtime error with appropriate error code
-            PyErr_Format(PyExc_RuntimeError,
-                         "task_info(TASK_BASIC_INFO) failed");
-        }
-        goto error;
-    }
-
-    err = task_threads(task, &thread_list, &thread_count);
-    if (err != KERN_SUCCESS) {
-        PyErr_Format(PyExc_RuntimeError, "task_threads() failed");
-        goto error;
-    }
-
-    for (j = 0; j < thread_count; j++) {
-        py_tuple = NULL;
-        thread_info_count = THREAD_INFO_MAX;
-        kr = thread_info(thread_list[j], THREAD_BASIC_INFO,
-                         (thread_info_t)thinfo_basic, &thread_info_count);
-        if (kr != KERN_SUCCESS) {
-            PyErr_Format(PyExc_RuntimeError,
-                         "thread_info() with flag THREAD_BASIC_INFO failed");
-            goto error;
-        }
-
-        basic_info_th = (thread_basic_info_t)thinfo_basic;
-        py_tuple = Py_BuildValue(
-            "Iff",
-            j + 1,
-            (float)basic_info_th->user_time.microseconds / 1000000.0,
-            (float)basic_info_th->system_time.microseconds / 1000000.0
-        );
-        if (!py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-
-    ret = vm_deallocate(task, (vm_address_t)thread_list,
-                        thread_count * sizeof(int));
-    if (ret != KERN_SUCCESS)
-        PyErr_WarnEx(PyExc_RuntimeWarning, "vm_deallocate() failed", 2);
-
-    mach_port_deallocate(mach_task_self(), task);
-
-    return py_retlist;
-
-error:
-    if (task != MACH_PORT_NULL)
-        mach_port_deallocate(mach_task_self(), task);
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (thread_list != NULL) {
-        ret = vm_deallocate(task, (vm_address_t)thread_list,
-                            thread_count * sizeof(int));
-        if (ret != KERN_SUCCESS)
-            PyErr_WarnEx(PyExc_RuntimeWarning, "vm_deallocate() failed", 2);
-    }
-    return NULL;
-}
-
-
-/*
- * Return process open files as a Python tuple.
- * References:
- * - lsof source code: http://goo.gl/SYW79 and http://goo.gl/m78fd
- * - /usr/include/sys/proc_info.h
- */
-static PyObject *
-psutil_proc_open_files(PyObject *self, PyObject *args) {
-    long pid;
-    int pidinfo_result;
-    int iterations;
-    int i;
-    int nb;
-
-    struct proc_fdinfo *fds_pointer = NULL;
-    struct proc_fdinfo *fdp_pointer;
-    struct vnode_fdinfowithpath vi;
-
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_path = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-
-    pidinfo_result = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, NULL, 0);
-    if (pidinfo_result <= 0) {
-        // may be be ignored later if errno != 0
-        PyErr_Format(PyExc_RuntimeError,
-                     "proc_pidinfo(PROC_PIDLISTFDS) failed");
-        goto error;
-    }
-
-    fds_pointer = malloc(pidinfo_result);
-    if (fds_pointer == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-    pidinfo_result = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, fds_pointer,
-                                  pidinfo_result);
-    if (pidinfo_result <= 0) {
-        // may be be ignored later if errno != 0
-        PyErr_Format(PyExc_RuntimeError,
-                     "proc_pidinfo(PROC_PIDLISTFDS) failed");
-        goto error;
-    }
-
-    iterations = (pidinfo_result / PROC_PIDLISTFD_SIZE);
-
-    for (i = 0; i < iterations; i++) {
-        py_tuple = NULL;
-        fdp_pointer = &fds_pointer[i];
-
-        if (fdp_pointer->proc_fdtype == PROX_FDTYPE_VNODE)
-        {
-            nb = proc_pidfdinfo(pid,
-                                fdp_pointer->proc_fd,
-                                PROC_PIDFDVNODEPATHINFO,
-                                &vi,
-                                sizeof(vi));
-
-            // --- errors checking
-            if (nb <= 0) {
-                if ((errno == ENOENT) || (errno == EBADF)) {
-                    // no such file or directory or bad file descriptor;
-                    // let's assume the file has been closed or removed
-                    continue;
-                }
-                // may be be ignored later if errno != 0
-                PyErr_Format(PyExc_RuntimeError,
-                             "proc_pidinfo(PROC_PIDFDVNODEPATHINFO) failed");
-                goto error;
-            }
-            if (nb < sizeof(vi)) {
-                PyErr_Format(PyExc_RuntimeError,
-                             "proc_pidinfo(PROC_PIDFDVNODEPATHINFO) failed "
-                             "(buffer mismatch)");
-                goto error;
-            }
-            // --- /errors checking
-
-            // --- construct python list
-#if PY_MAJOR_VERSION >= 3
-            py_path = PyUnicode_DecodeFSDefault(vi.pvip.vip_path);
-#else
-            py_path = Py_BuildValue("s", vi.pvip.vip_path);
-#endif
-            if (! py_path)
-                goto error;
-            py_tuple = Py_BuildValue(
-                "(Oi)",
-                py_path,
-                (int)fdp_pointer->proc_fd);
-            if (!py_tuple)
-                goto error;
-            if (PyList_Append(py_retlist, py_tuple))
-                goto error;
-            Py_DECREF(py_tuple);
-            Py_DECREF(py_path);
-            // --- /construct python list
-        }
-    }
-
-    free(fds_pointer);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_path);
-    Py_DECREF(py_retlist);
-    if (fds_pointer != NULL)
-        free(fds_pointer);
-    if (errno != 0)
-        return PyErr_SetFromErrno(PyExc_OSError);
-    else if (! psutil_pid_exists(pid))
-        return NoSuchProcess();
-    else
-        return NULL;  // exception has already been set earlier
-}
-
-
-// a signaler for connections without an actual status
-static int PSUTIL_CONN_NONE = 128;
-
-/*
- * Return process TCP and UDP connections as a list of tuples.
- * References:
- * - lsof source code: http://goo.gl/SYW79 and http://goo.gl/wNrC0
- * - /usr/include/sys/proc_info.h
- */
-static PyObject *
-psutil_proc_connections(PyObject *self, PyObject *args) {
-    long pid;
-    int pidinfo_result;
-    int iterations;
-    int i;
-    int nb;
-
-    struct proc_fdinfo *fds_pointer = NULL;
-    struct proc_fdinfo *fdp_pointer;
-    struct socket_fdinfo si;
-
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_laddr = NULL;
-    PyObject *py_raddr = NULL;
-    PyObject *py_af_filter = NULL;
-    PyObject *py_type_filter = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    if (! PyArg_ParseTuple(args, "lOO", &pid, &py_af_filter, &py_type_filter))
-        goto error;
-
-    if (!PySequence_Check(py_af_filter) || !PySequence_Check(py_type_filter)) {
-        PyErr_SetString(PyExc_TypeError, "arg 2 or 3 is not a sequence");
-        goto error;
-    }
-
-    if (pid == 0)
-        return py_retlist;
-    pidinfo_result = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, NULL, 0);
-    if (pidinfo_result <= 0)
-        goto error;
-
-    fds_pointer = malloc(pidinfo_result);
-    if (fds_pointer == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-    pidinfo_result = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, fds_pointer,
-                                  pidinfo_result);
-
-    if (pidinfo_result <= 0)
-        goto error;
-    iterations = (pidinfo_result / PROC_PIDLISTFD_SIZE);
-
-    for (i = 0; i < iterations; i++) {
-        py_tuple = NULL;
-        py_laddr = NULL;
-        py_raddr = NULL;
-        errno = 0;
-        fdp_pointer = &fds_pointer[i];
-
-        if (fdp_pointer->proc_fdtype == PROX_FDTYPE_SOCKET)
-        {
-            nb = proc_pidfdinfo(pid, fdp_pointer->proc_fd,
-                                PROC_PIDFDSOCKETINFO, &si, sizeof(si));
-
-            // --- errors checking
-            if (nb <= 0) {
-                if (errno == EBADF) {
-                    // let's assume socket has been closed
-                    continue;
-                }
-                if (errno != 0)
-                    PyErr_SetFromErrno(PyExc_OSError);
-                else
-                    PyErr_Format(
-                        PyExc_RuntimeError,
-                        "proc_pidinfo(PROC_PIDFDVNODEPATHINFO) failed");
-                goto error;
-            }
-            if (nb < sizeof(si)) {
-                PyErr_Format(PyExc_RuntimeError,
-                             "proc_pidinfo(PROC_PIDFDVNODEPATHINFO) failed "
-                             "(buffer mismatch)");
-                goto error;
-            }
-            // --- /errors checking
-
-            //
-            int fd, family, type, lport, rport, state;
-            char lip[200], rip[200];
-            int inseq;
-            PyObject *py_family;
-            PyObject *py_type;
-
-            fd = (int)fdp_pointer->proc_fd;
-            family = si.psi.soi_family;
-            type = si.psi.soi_type;
-
-            // apply filters
-            py_family = PyLong_FromLong((long)family);
-            inseq = PySequence_Contains(py_af_filter, py_family);
-            Py_DECREF(py_family);
-            if (inseq == 0)
-                continue;
-            py_type = PyLong_FromLong((long)type);
-            inseq = PySequence_Contains(py_type_filter, py_type);
-            Py_DECREF(py_type);
-            if (inseq == 0)
-                continue;
-
-            if (errno != 0) {
-                PyErr_SetFromErrno(PyExc_OSError);
-                goto error;
-            }
-
-            if ((family == AF_INET) || (family == AF_INET6)) {
-                if (family == AF_INET) {
-                    inet_ntop(AF_INET,
-                              &si.psi.soi_proto.pri_tcp.tcpsi_ini. \
-                                  insi_laddr.ina_46.i46a_addr4,
-                              lip,
-                              sizeof(lip));
-                    inet_ntop(AF_INET,
-                              &si.psi.soi_proto.pri_tcp.tcpsi_ini.insi_faddr. \
-                                  ina_46.i46a_addr4,
-                              rip,
-                              sizeof(rip));
-                }
-                else {
-                    inet_ntop(AF_INET6,
-                              &si.psi.soi_proto.pri_tcp.tcpsi_ini. \
-                                  insi_laddr.ina_6,
-                              lip, sizeof(lip));
-                    inet_ntop(AF_INET6,
-                              &si.psi.soi_proto.pri_tcp.tcpsi_ini. \
-                                  insi_faddr.ina_6,
-                              rip, sizeof(rip));
-                }
-
-                // check for inet_ntop failures
-                if (errno != 0) {
-                    PyErr_SetFromErrno(PyExc_OSError);
-                    goto error;
-                }
-
-                lport = ntohs(si.psi.soi_proto.pri_tcp.tcpsi_ini.insi_lport);
-                rport = ntohs(si.psi.soi_proto.pri_tcp.tcpsi_ini.insi_fport);
-                if (type == SOCK_STREAM)
-                    state = (int)si.psi.soi_proto.pri_tcp.tcpsi_state;
-                else
-                    state = PSUTIL_CONN_NONE;
-
-                py_laddr = Py_BuildValue("(si)", lip, lport);
-                if (!py_laddr)
-                    goto error;
-                if (rport != 0)
-                    py_raddr = Py_BuildValue("(si)", rip, rport);
-                else
-                    py_raddr = Py_BuildValue("()");
-                if (!py_raddr)
-                    goto error;
-
-                // construct the python list
-                py_tuple = Py_BuildValue(
-                    "(iiiNNi)", fd, family, type, py_laddr, py_raddr, state);
-                if (!py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-            }
-            else if (family == AF_UNIX) {
-                // construct the python list
-                py_tuple = Py_BuildValue(
-                    "(iiissi)",
-                    fd, family, type,
-                    si.psi.soi_proto.pri_un.unsi_addr.ua_sun.sun_path,
-                    si.psi.soi_proto.pri_un.unsi_caddr.ua_sun.sun_path,
-                    PSUTIL_CONN_NONE);
-                if (!py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-            }
-        }
-    }
-
-    free(fds_pointer);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_laddr);
-    Py_XDECREF(py_raddr);
-    Py_DECREF(py_retlist);
-
-    if (fds_pointer != NULL)
-        free(fds_pointer);
-    if (errno != 0)
-        return PyErr_SetFromErrno(PyExc_OSError);
-    else if (! psutil_pid_exists(pid))
-        return NoSuchProcess();
-    else
-        return PyErr_Format(PyExc_RuntimeError,
-                            "proc_pidinfo(PROC_PIDLISTFDS) failed");
-}
-
-
-/*
- * Return number of file descriptors opened by process.
- */
-static PyObject *
-psutil_proc_num_fds(PyObject *self, PyObject *args) {
-    long pid;
-    int pidinfo_result;
-    int num;
-    struct proc_fdinfo *fds_pointer;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    pidinfo_result = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, NULL, 0);
-    if (pidinfo_result <= 0)
-        return PyErr_SetFromErrno(PyExc_OSError);
-
-    fds_pointer = malloc(pidinfo_result);
-    if (fds_pointer == NULL)
-        return PyErr_NoMemory();
-    pidinfo_result = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, fds_pointer,
-                                  pidinfo_result);
-    if (pidinfo_result <= 0) {
-        free(fds_pointer);
-        return PyErr_SetFromErrno(PyExc_OSError);
-    }
-
-    num = (pidinfo_result / PROC_PIDLISTFD_SIZE);
-    free(fds_pointer);
-    return Py_BuildValue("i", num);
-}
-
-
-/*
- * Return a Python list of named tuples with overall network I/O information
- */
-static PyObject *
-psutil_net_io_counters(PyObject *self, PyObject *args) {
-    char *buf = NULL, *lim, *next;
-    struct if_msghdr *ifm;
-    int mib[6];
-    size_t len;
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_ifc_info = NULL;
-
-    if (py_retdict == NULL)
-        return NULL;
-
-    mib[0] = CTL_NET;          // networking subsystem
-    mib[1] = PF_ROUTE;         // type of information
-    mib[2] = 0;                // protocol (IPPROTO_xxx)
-    mib[3] = 0;                // address family
-    mib[4] = NET_RT_IFLIST2;   // operation
-    mib[5] = 0;
-
-    if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    buf = malloc(len);
-    if (buf == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    if (sysctl(mib, 6, buf, &len, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    lim = buf + len;
-
-    for (next = buf; next < lim; ) {
-        ifm = (struct if_msghdr *)next;
-        next += ifm->ifm_msglen;
-
-        if (ifm->ifm_type == RTM_IFINFO2) {
-            py_ifc_info = NULL;
-            struct if_msghdr2 *if2m = (struct if_msghdr2 *)ifm;
-            struct sockaddr_dl *sdl = (struct sockaddr_dl *)(if2m + 1);
-            char ifc_name[32];
-
-            strncpy(ifc_name, sdl->sdl_data, sdl->sdl_nlen);
-            ifc_name[sdl->sdl_nlen] = 0;
-
-            py_ifc_info = Py_BuildValue(
-                "(KKKKKKKi)",
-                if2m->ifm_data.ifi_obytes,
-                if2m->ifm_data.ifi_ibytes,
-                if2m->ifm_data.ifi_opackets,
-                if2m->ifm_data.ifi_ipackets,
-                if2m->ifm_data.ifi_ierrors,
-                if2m->ifm_data.ifi_oerrors,
-                if2m->ifm_data.ifi_iqdrops,
-                0);  // dropout not supported
-
-            if (!py_ifc_info)
-                goto error;
-            if (PyDict_SetItemString(py_retdict, ifc_name, py_ifc_info))
-                goto error;
-            Py_DECREF(py_ifc_info);
-        }
-        else {
-            continue;
-        }
-    }
-
-    free(buf);
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_ifc_info);
-    Py_DECREF(py_retdict);
-    if (buf != NULL)
-        free(buf);
-    return NULL;
-}
-
-
-/*
- * Return a Python dict of tuples for disk I/O information
- */
-static PyObject *
-psutil_disk_io_counters(PyObject *self, PyObject *args) {
-    CFDictionaryRef parent_dict;
-    CFDictionaryRef props_dict;
-    CFDictionaryRef stats_dict;
-    io_registry_entry_t parent;
-    io_registry_entry_t disk;
-    io_iterator_t disk_list;
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_disk_info = NULL;
-
-    if (py_retdict == NULL)
-        return NULL;
-
-    // Get list of disks
-    if (IOServiceGetMatchingServices(kIOMasterPortDefault,
-                                     IOServiceMatching(kIOMediaClass),
-                                     &disk_list) != kIOReturnSuccess) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "unable to get the list of disks.");
-        goto error;
-    }
-
-    // Iterate over disks
-    while ((disk = IOIteratorNext(disk_list)) != 0) {
-        py_disk_info = NULL;
-        parent_dict = NULL;
-        props_dict = NULL;
-        stats_dict = NULL;
-
-        if (IORegistryEntryGetParentEntry(disk, kIOServicePlane, &parent)
-                != kIOReturnSuccess) {
-            PyErr_SetString(PyExc_RuntimeError,
-                            "unable to get the disk's parent.");
-            IOObjectRelease(disk);
-            goto error;
-        }
-
-        if (IOObjectConformsTo(parent, "IOBlockStorageDriver")) {
-            if (IORegistryEntryCreateCFProperties(
-                    disk,
-                    (CFMutableDictionaryRef *) &parent_dict,
-                    kCFAllocatorDefault,
-                    kNilOptions
-                ) != kIOReturnSuccess)
-            {
-                PyErr_SetString(PyExc_RuntimeError,
-                                "unable to get the parent's properties.");
-                IOObjectRelease(disk);
-                IOObjectRelease(parent);
-                goto error;
-            }
-
-            if (IORegistryEntryCreateCFProperties(
-                    parent,
-                    (CFMutableDictionaryRef *) &props_dict,
-                    kCFAllocatorDefault,
-                    kNilOptions
-                ) != kIOReturnSuccess)
-            {
-                PyErr_SetString(PyExc_RuntimeError,
-                                "unable to get the disk properties.");
-                CFRelease(props_dict);
-                IOObjectRelease(disk);
-                IOObjectRelease(parent);
-                goto error;
-            }
-
-            const int kMaxDiskNameSize = 64;
-            CFStringRef disk_name_ref = (CFStringRef)CFDictionaryGetValue(
-                parent_dict, CFSTR(kIOBSDNameKey));
-            char disk_name[kMaxDiskNameSize];
-
-            CFStringGetCString(disk_name_ref,
-                               disk_name,
-                               kMaxDiskNameSize,
-                               CFStringGetSystemEncoding());
-
-            stats_dict = (CFDictionaryRef)CFDictionaryGetValue(
-                props_dict, CFSTR(kIOBlockStorageDriverStatisticsKey));
-
-            if (stats_dict == NULL) {
-                PyErr_SetString(PyExc_RuntimeError,
-                                "Unable to get disk stats.");
-                goto error;
-            }
-
-            CFNumberRef number;
-            int64_t reads = 0;
-            int64_t writes = 0;
-            int64_t read_bytes = 0;
-            int64_t write_bytes = 0;
-            int64_t read_time = 0;
-            int64_t write_time = 0;
-
-            // Get disk reads/writes
-            if ((number = (CFNumberRef)CFDictionaryGetValue(
-                    stats_dict,
-                    CFSTR(kIOBlockStorageDriverStatisticsReadsKey))))
-            {
-                CFNumberGetValue(number, kCFNumberSInt64Type, &reads);
-            }
-            if ((number = (CFNumberRef)CFDictionaryGetValue(
-                    stats_dict,
-                    CFSTR(kIOBlockStorageDriverStatisticsWritesKey))))
-            {
-                CFNumberGetValue(number, kCFNumberSInt64Type, &writes);
-            }
-
-            // Get disk bytes read/written
-            if ((number = (CFNumberRef)CFDictionaryGetValue(
-                    stats_dict,
-                    CFSTR(kIOBlockStorageDriverStatisticsBytesReadKey))))
-            {
-                CFNumberGetValue(number, kCFNumberSInt64Type, &read_bytes);
-            }
-            if ((number = (CFNumberRef)CFDictionaryGetValue(
-                    stats_dict,
-                    CFSTR(kIOBlockStorageDriverStatisticsBytesWrittenKey))))
-            {
-                CFNumberGetValue(number, kCFNumberSInt64Type, &write_bytes);
-            }
-
-            // Get disk time spent reading/writing (nanoseconds)
-            if ((number = (CFNumberRef)CFDictionaryGetValue(
-                    stats_dict,
-                    CFSTR(kIOBlockStorageDriverStatisticsTotalReadTimeKey))))
-            {
-                CFNumberGetValue(number, kCFNumberSInt64Type, &read_time);
-            }
-            if ((number = (CFNumberRef)CFDictionaryGetValue(
-                    stats_dict,
-                    CFSTR(kIOBlockStorageDriverStatisticsTotalWriteTimeKey))))
-            {
-                CFNumberGetValue(number, kCFNumberSInt64Type, &write_time);
-            }
-
-            // Read/Write time on OS X comes back in nanoseconds and in psutil
-            // we've standardized on milliseconds so do the conversion.
-            py_disk_info = Py_BuildValue(
-                "(KKKKKK)",
-                reads,
-                writes,
-                read_bytes,
-                write_bytes,
-                read_time / 1000 / 1000,
-                write_time / 1000 / 1000);
-           if (!py_disk_info)
-                goto error;
-            if (PyDict_SetItemString(py_retdict, disk_name, py_disk_info))
-                goto error;
-            Py_DECREF(py_disk_info);
-
-            CFRelease(parent_dict);
-            IOObjectRelease(parent);
-            CFRelease(props_dict);
-            IOObjectRelease(disk);
-        }
-    }
-
-    IOObjectRelease (disk_list);
-
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_disk_info);
-    Py_DECREF(py_retdict);
-    return NULL;
-}
-
-
-/*
- * Return currently connected users as a list of tuples.
- */
-static PyObject *
-psutil_users(PyObject *self, PyObject *args) {
-    struct utmpx *utx;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    while ((utx = getutxent()) != NULL) {
-        if (utx->ut_type != USER_PROCESS)
-            continue;
-        py_tuple = Py_BuildValue(
-            "(sssf)",
-            utx->ut_user,             // username
-            utx->ut_line,             // tty
-            utx->ut_host,             // hostname
-            (float)utx->ut_tv.tv_sec  // start time
-        );
-        if (!py_tuple) {
-            endutxent();
-            goto error;
-        }
-        if (PyList_Append(py_retlist, py_tuple)) {
-            endutxent();
-            goto error;
-        }
-        Py_DECREF(py_tuple);
-    }
-
-    endutxent();
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    return NULL;
-}
-
-
-/*
- * Return CPU statistics.
- */
-static PyObject *
-psutil_cpu_stats(PyObject *self, PyObject *args) {
-    struct vmmeter vmstat;
-    kern_return_t ret;
-    mach_msg_type_number_t count = sizeof(vmstat) / sizeof(integer_t);
-    mach_port_t mport = mach_host_self();
-
-    ret = host_statistics(mport, HOST_VM_INFO, (host_info_t)&vmstat, &count);
-    if (ret != KERN_SUCCESS) {
-        PyErr_Format(PyExc_RuntimeError,
-                     "host_statistics() failed: %s", mach_error_string(ret));
-        return NULL;
-    }
-    mach_port_deallocate(mach_task_self(), mport);
-
-    return Py_BuildValue(
-        "IIIII",
-        vmstat.v_swtch,  // ctx switches
-        vmstat.v_intr,  // interrupts
-        vmstat.v_soft,  // software interrupts
-        vmstat.v_syscall,  // syscalls
-        vmstat.v_trap  // traps
-    );
-}
-
-
-
-/*
- * define the psutil C module methods and initialize the module.
- */
-static PyMethodDef
-PsutilMethods[] = {
 
+static PyMethodDef mod_methods[] = {
     // --- per-process functions
-
-    {"proc_name", psutil_proc_name, METH_VARARGS,
-     "Return process name"},
-    {"proc_cmdline", psutil_proc_cmdline, METH_VARARGS,
-     "Return process cmdline as a list of cmdline arguments"},
-    {"proc_environ", psutil_proc_environ, METH_VARARGS,
-     "Return process environment data"},
-    {"proc_exe", psutil_proc_exe, METH_VARARGS,
-     "Return path of the process executable"},
-    {"proc_cwd", psutil_proc_cwd, METH_VARARGS,
-     "Return process current working directory."},
-    {"proc_ppid", psutil_proc_ppid, METH_VARARGS,
-     "Return process ppid as an integer"},
-    {"proc_uids", psutil_proc_uids, METH_VARARGS,
-     "Return process real user id as an integer"},
-    {"proc_gids", psutil_proc_gids, METH_VARARGS,
-     "Return process real group id as an integer"},
-    {"proc_cpu_times", psutil_proc_cpu_times, METH_VARARGS,
-     "Return tuple of user/kern time for the given PID"},
-    {"proc_create_time", psutil_proc_create_time, METH_VARARGS,
-     "Return a float indicating the process create time expressed in "
-     "seconds since the epoch"},
-    {"proc_memory_info", psutil_proc_memory_info, METH_VARARGS,
-     "Return memory information about a process"},
-    {"proc_memory_uss", psutil_proc_memory_uss, METH_VARARGS,
-     "Return process USS memory"},
-    {"proc_num_threads", psutil_proc_num_threads, METH_VARARGS,
-     "Return number of threads used by process"},
-    {"proc_status", psutil_proc_status, METH_VARARGS,
-     "Return process status as an integer"},
-    {"proc_threads", psutil_proc_threads, METH_VARARGS,
-     "Return process threads as a list of tuples"},
-    {"proc_open_files", psutil_proc_open_files, METH_VARARGS,
-     "Return files opened by process as a list of tuples"},
-    {"proc_num_fds", psutil_proc_num_fds, METH_VARARGS,
-     "Return the number of fds opened by process."},
-    {"proc_num_ctx_switches", psutil_proc_num_ctx_switches, METH_VARARGS,
-     "Return the number of context switches performed by process"},
-    {"proc_connections", psutil_proc_connections, METH_VARARGS,
-     "Get process TCP and UDP connections as a list of tuples"},
-    {"proc_tty_nr", psutil_proc_tty_nr, METH_VARARGS,
-     "Return process tty number as an integer"},
-    {"proc_memory_maps", psutil_proc_memory_maps, METH_VARARGS,
-     "Return a list of tuples for every process's memory map"},
+    // clang-format off
+    {"proc_cmdline", psutil_proc_cmdline, METH_VARARGS},
+    {"proc_cwd", psutil_proc_cwd, METH_VARARGS},
+    {"proc_environ", psutil_proc_environ, METH_VARARGS},
+    {"proc_exe", psutil_proc_exe, METH_VARARGS},
+    {"proc_is_zombie", psutil_proc_is_zombie, METH_VARARGS},
+    {"proc_memory_extras", psutil_proc_memory_extras, METH_VARARGS},
+    {"proc_memory_uss", psutil_proc_memory_uss, METH_VARARGS},
+    {"proc_name", psutil_proc_name, METH_VARARGS},
+    {"proc_net_connections", psutil_proc_net_connections, METH_VARARGS},
+    {"proc_num_fds", psutil_proc_num_fds, METH_VARARGS},
+    {"proc_oneshot_kinfo", psutil_proc_oneshot_kinfo, METH_VARARGS},
+    {"proc_oneshot_pidtaskinfo", psutil_proc_oneshot_pidtaskinfo, METH_VARARGS},
+    {"proc_open_files", psutil_proc_open_files, METH_VARARGS},
+    {"proc_threads", psutil_proc_threads, METH_VARARGS},
+    // clang-format on
 
     // --- system-related functions
-
-    {"pids", psutil_pids, METH_VARARGS,
-     "Returns a list of PIDs currently running on the system"},
-    {"cpu_count_logical", psutil_cpu_count_logical, METH_VARARGS,
-     "Return number of logical CPUs on the system"},
-    {"cpu_count_phys", psutil_cpu_count_phys, METH_VARARGS,
-     "Return number of physical CPUs on the system"},
-    {"virtual_mem", psutil_virtual_mem, METH_VARARGS,
-     "Return system virtual memory stats"},
-    {"swap_mem", psutil_swap_mem, METH_VARARGS,
-     "Return stats about swap memory, in bytes"},
-    {"cpu_times", psutil_cpu_times, METH_VARARGS,
-     "Return system cpu times as a tuple (user, system, nice, idle, irc)"},
-    {"per_cpu_times", psutil_per_cpu_times, METH_VARARGS,
-     "Return system per-cpu times as a list of tuples"},
-    {"boot_time", psutil_boot_time, METH_VARARGS,
-     "Return the system boot time expressed in seconds since the epoch."},
-    {"disk_partitions", psutil_disk_partitions, METH_VARARGS,
-     "Return a list of tuples including device, mount point and "
-     "fs type for all partitions mounted on the system."},
-    {"net_io_counters", psutil_net_io_counters, METH_VARARGS,
-     "Return dict of tuples of networks I/O information."},
-    {"disk_io_counters", psutil_disk_io_counters, METH_VARARGS,
-     "Return dict of tuples of disks I/O information."},
-    {"users", psutil_users, METH_VARARGS,
-     "Return currently connected users as a list of tuples"},
-    {"cpu_stats", psutil_cpu_stats, METH_VARARGS,
-     "Return CPU statistics"},
+    {"boot_time", psutil_boot_time, METH_VARARGS},
+    {"cpu_count_cores", psutil_cpu_count_cores, METH_VARARGS},
+    {"cpu_count_logical", psutil_cpu_count_logical, METH_VARARGS},
+    {"cpu_freq", psutil_cpu_freq, METH_VARARGS},
+    {"cpu_stats", psutil_cpu_stats, METH_VARARGS},
+    {"cpu_times", psutil_cpu_times, METH_VARARGS},
+    {"disk_io_counters", psutil_disk_io_counters, METH_VARARGS},
+    {"disk_partitions", psutil_disk_partitions, METH_VARARGS},
+    {"disk_usage_used", psutil_disk_usage_used, METH_VARARGS},
+    {"heap_info", psutil_heap_info, METH_VARARGS},
+    {"heap_trim", psutil_heap_trim, METH_VARARGS},
+    {"net_io_counters", psutil_net_io_counters, METH_VARARGS},
+    {"per_cpu_times", psutil_per_cpu_times, METH_VARARGS},
+    {"pids", psutil_pids, METH_VARARGS},
+    {"sensors_battery", psutil_sensors_battery, METH_VARARGS},
+    {"swap_mem", psutil_swap_mem, METH_VARARGS},
+    {"virtual_mem", psutil_virtual_mem, METH_VARARGS},
+
+    // --- others
+    {"check_pid_range", psutil_check_pid_range, METH_VARARGS},
+    {"set_debug", psutil_set_debug, METH_VARARGS},
 
     {NULL, NULL, 0, NULL}
 };
 
 
-struct module_state {
-    PyObject *error;
-};
-
-#if PY_MAJOR_VERSION >= 3
-#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
-#else
-#define GETSTATE(m) (&_state)
-#endif
-
-#if PY_MAJOR_VERSION >= 3
-
 static int
-psutil_osx_traverse(PyObject *m, visitproc visit, void *arg) {
-    Py_VISIT(GETSTATE(m)->error);
+psutil_add_constants(PyObject *mod) {
+    PSUTIL_ADD_INT(mod, "version", PSUTIL_VERSION);
+    // process status constants, defined in:
+    // http://fxr.watson.org/fxr/source/bsd/sys/proc.h?v=xnu-792.6.70#L149
+    PSUTIL_ADD_INT(mod, "SIDL", SIDL);
+    PSUTIL_ADD_INT(mod, "SRUN", SRUN);
+    PSUTIL_ADD_INT(mod, "SSLEEP", SSLEEP);
+    PSUTIL_ADD_INT(mod, "SSTOP", SSTOP);
+    PSUTIL_ADD_INT(mod, "SZOMB", SZOMB);
+    // for process tty
+    PSUTIL_ADD_INT(mod, "NODEV", (long)NODEV);
+    // connection status constants
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSED", TCPS_CLOSED);
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSING", TCPS_CLOSING);
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT);
+    PSUTIL_ADD_INT(mod, "TCPS_LISTEN", TCPS_LISTEN);
+    PSUTIL_ADD_INT(mod, "TCPS_ESTABLISHED", TCPS_ESTABLISHED);
+    PSUTIL_ADD_INT(mod, "TCPS_SYN_SENT", TCPS_SYN_SENT);
+    PSUTIL_ADD_INT(mod, "TCPS_SYN_RECEIVED", TCPS_SYN_RECEIVED);
+    PSUTIL_ADD_INT(mod, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1);
+    PSUTIL_ADD_INT(mod, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2);
+    PSUTIL_ADD_INT(mod, "TCPS_LAST_ACK", TCPS_LAST_ACK);
+    PSUTIL_ADD_INT(mod, "TCPS_TIME_WAIT", TCPS_TIME_WAIT);
+    PSUTIL_ADD_INT(mod, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE);
+
     return 0;
 }
 
+
 static int
-psutil_osx_clear(PyObject *m) {
-    Py_CLEAR(GETSTATE(m)->error);
+psutil_exec(PyObject *mod) {
+    if (psutil_setup() != 0)
+        return -1;
+    if (psutil_setup_osx() != 0)
+        return -1;
+    if (psutil_posix_add_constants(mod) != 0)
+        return -1;
+    if (psutil_posix_add_methods(mod) != 0)
+        return -1;
+    if (psutil_add_exceptions(mod) != 0)
+        return -1;
+    if (psutil_add_constants(mod) != 0)
+        return -1;
     return 0;
 }
 
-
-static struct PyModuleDef moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "psutil_osx",
-    NULL,
-    sizeof(struct module_state),
-    PsutilMethods,
-    NULL,
-    psutil_osx_traverse,
-    psutil_osx_clear,
-    NULL
-};
-
-#define INITERROR return NULL
-
-PyMODINIT_FUNC PyInit__psutil_osx(void)
-
-#else
-#define INITERROR return
-
-void
-init_psutil_osx(void)
-#endif
-{
-#if PY_MAJOR_VERSION >= 3
-    PyObject *module = PyModule_Create(&moduledef);
-#else
-    PyObject *module = Py_InitModule("_psutil_osx", PsutilMethods);
-#endif
-    PyModule_AddIntConstant(module, "version", PSUTIL_VERSION);
-    // process status constants, defined in:
-    // http://fxr.watson.org/fxr/source/bsd/sys/proc.h?v=xnu-792.6.70#L149
-    PyModule_AddIntConstant(module, "SIDL", SIDL);
-    PyModule_AddIntConstant(module, "SRUN", SRUN);
-    PyModule_AddIntConstant(module, "SSLEEP", SSLEEP);
-    PyModule_AddIntConstant(module, "SSTOP", SSTOP);
-    PyModule_AddIntConstant(module, "SZOMB", SZOMB);
-    // connection status constants
-    PyModule_AddIntConstant(module, "TCPS_CLOSED", TCPS_CLOSED);
-    PyModule_AddIntConstant(module, "TCPS_CLOSING", TCPS_CLOSING);
-    PyModule_AddIntConstant(module, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT);
-    PyModule_AddIntConstant(module, "TCPS_LISTEN", TCPS_LISTEN);
-    PyModule_AddIntConstant(module, "TCPS_ESTABLISHED", TCPS_ESTABLISHED);
-    PyModule_AddIntConstant(module, "TCPS_SYN_SENT", TCPS_SYN_SENT);
-    PyModule_AddIntConstant(module, "TCPS_SYN_RECEIVED", TCPS_SYN_RECEIVED);
-    PyModule_AddIntConstant(module, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1);
-    PyModule_AddIntConstant(module, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2);
-    PyModule_AddIntConstant(module, "TCPS_LAST_ACK", TCPS_LAST_ACK);
-    PyModule_AddIntConstant(module, "TCPS_TIME_WAIT", TCPS_TIME_WAIT);
-    PyModule_AddIntConstant(module, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE);
-
-    if (module == NULL)
-        INITERROR;
-#if PY_MAJOR_VERSION >= 3
-    return module;
-#endif
+PyMODINIT_FUNC
+PyInit__psutil(void) {
+    return psutil_mod_init("_psutil", mod_methods, psutil_exec);
 }
diff --git a/psutil/_psutil_posix.c b/psutil/_psutil_posix.c
deleted file mode 100644
index 075d51efd6..0000000000
--- a/psutil/_psutil_posix.c
+++ /dev/null
@@ -1,549 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Functions specific to all POSIX compliant platforms.
- */
-
-#include <Python.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <sys/resource.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/ioctl.h>
-#include <net/if.h>
-
-#ifdef PSUTIL_SUNOS10
-#include "arch/solaris/v10/ifaddrs.h"
-#else
-#include <ifaddrs.h>
-#endif
-
-#ifdef __linux
-#include <netdb.h>
-#include <linux/if_packet.h>
-#endif  // end linux
-
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__NetBSD__)
-#include <netdb.h>
-#include <netinet/in.h>
-#include <net/if_dl.h>
-#endif
-
-#if defined(__sun)
-#include <netdb.h>
-#endif
-
-#include "_psutil_posix.h"
-
-
-/*
- * Given a PID return process priority as a Python integer.
- */
-static PyObject *
-psutil_posix_getpriority(PyObject *self, PyObject *args) {
-    long pid;
-    int priority;
-    errno = 0;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    priority = getpriority(PRIO_PROCESS, pid);
-    if (errno != 0)
-        return PyErr_SetFromErrno(PyExc_OSError);
-    return Py_BuildValue("i", priority);
-}
-
-
-/*
- * Given a PID and a value change process priority.
- */
-static PyObject *
-psutil_posix_setpriority(PyObject *self, PyObject *args) {
-    long pid;
-    int priority;
-    int retval;
-
-    if (! PyArg_ParseTuple(args, "li", &pid, &priority))
-        return NULL;
-    retval = setpriority(PRIO_PROCESS, pid, priority);
-    if (retval == -1)
-        return PyErr_SetFromErrno(PyExc_OSError);
-    Py_RETURN_NONE;
-}
-
-
-/*
- * Translate a sockaddr struct into a Python string.
- * Return None if address family is not AF_INET* or AF_PACKET.
- */
-static PyObject *
-psutil_convert_ipaddr(struct sockaddr *addr, int family) {
-    char buf[NI_MAXHOST];
-    int err;
-    int addrlen;
-    size_t n;
-    size_t len;
-    const char *data;
-    char *ptr;
-
-    if (addr == NULL) {
-        Py_INCREF(Py_None);
-        return Py_None;
-    }
-    else if (family == AF_INET || family == AF_INET6) {
-        if (family == AF_INET)
-            addrlen = sizeof(struct sockaddr_in);
-        else
-            addrlen = sizeof(struct sockaddr_in6);
-        err = getnameinfo(addr, addrlen, buf, sizeof(buf), NULL, 0,
-                          NI_NUMERICHOST);
-        if (err != 0) {
-            // XXX we get here on FreeBSD when processing 'lo' / AF_INET6
-            // broadcast. Not sure what to do other than returning None.
-            // ifconfig does not show anything BTW.
-            //PyErr_Format(PyExc_RuntimeError, gai_strerror(err));
-            //return NULL;
-            Py_INCREF(Py_None);
-            return Py_None;
-        }
-        else {
-            return Py_BuildValue("s", buf);
-        }
-    }
-#ifdef __linux
-    else if (family == AF_PACKET) {
-        struct sockaddr_ll *lladdr = (struct sockaddr_ll *)addr;
-        len = lladdr->sll_halen;
-        data = (const char *)lladdr->sll_addr;
-    }
-#endif
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__NetBSD__)
-    else if (addr->sa_family == AF_LINK) {
-        // Note: prior to Python 3.4 socket module does not expose
-        // AF_LINK so we'll do.
-        struct sockaddr_dl *dladdr = (struct sockaddr_dl *)addr;
-        len = dladdr->sdl_alen;
-        data = LLADDR(dladdr);
-    }
-#endif
-    else {
-        // unknown family
-        Py_INCREF(Py_None);
-        return Py_None;
-    }
-
-    // AF_PACKET or AF_LINK
-    if (len > 0) {
-        ptr = buf;
-        for (n = 0; n < len; ++n) {
-            sprintf(ptr, "%02x:", data[n] & 0xff);
-            ptr += 3;
-        }
-        *--ptr = '\0';
-        return Py_BuildValue("s", buf);
-    }
-    else {
-        Py_INCREF(Py_None);
-        return Py_None;
-    }
-}
-
-
-/*
- * Return NICs information a-la ifconfig as a list of tuples.
- * TODO: on Solaris we won't get any MAC address.
- */
-static PyObject*
-psutil_net_if_addrs(PyObject* self, PyObject* args) {
-    struct ifaddrs *ifaddr, *ifa;
-    int family;
-
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_address = NULL;
-    PyObject *py_netmask = NULL;
-    PyObject *py_broadcast = NULL;
-    PyObject *py_ptp = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (getifaddrs(&ifaddr) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
-        if (!ifa->ifa_addr)
-            continue;
-        family = ifa->ifa_addr->sa_family;
-        py_address = psutil_convert_ipaddr(ifa->ifa_addr, family);
-        // If the primary address can't be determined just skip it.
-        // I've never seen this happen on Linux but I did on FreeBSD.
-        if (py_address == Py_None)
-            continue;
-        if (py_address == NULL)
-            goto error;
-        py_netmask = psutil_convert_ipaddr(ifa->ifa_netmask, family);
-        if (py_netmask == NULL)
-            goto error;
-
-        if (ifa->ifa_flags & IFF_BROADCAST) {
-            py_broadcast = psutil_convert_ipaddr(ifa->ifa_broadaddr, family);
-            Py_INCREF(Py_None);
-            py_ptp = Py_None;
-        }
-        else if (ifa->ifa_flags & IFF_POINTOPOINT) {
-            py_ptp = psutil_convert_ipaddr(ifa->ifa_dstaddr, family);
-            Py_INCREF(Py_None);
-            py_broadcast = Py_None;
-        }
-        else {
-            Py_INCREF(Py_None);
-            Py_INCREF(Py_None);
-            py_broadcast = Py_None;
-            py_ptp = Py_None;
-        }
-
-        if ((py_broadcast == NULL) || (py_ptp == NULL))
-            goto error;
-        py_tuple = Py_BuildValue(
-            "(siOOOO)",
-            ifa->ifa_name,
-            family,
-            py_address,
-            py_netmask,
-            py_broadcast,
-            py_ptp
-        );
-
-        if (! py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-        Py_DECREF(py_address);
-        Py_DECREF(py_netmask);
-        Py_DECREF(py_broadcast);
-        Py_DECREF(py_ptp);
-    }
-
-    freeifaddrs(ifaddr);
-    return py_retlist;
-
-error:
-    if (ifaddr != NULL)
-        freeifaddrs(ifaddr);
-    Py_DECREF(py_retlist);
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_address);
-    Py_XDECREF(py_netmask);
-    Py_XDECREF(py_broadcast);
-    Py_XDECREF(py_ptp);
-    return NULL;
-}
-
-
-/*
- * net_if_stats() implementation. This is here because it is common
- * to both OSX and FreeBSD and I didn't know where else to put it.
- */
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__NetBSD__)
-
-#include <sys/sockio.h>
-#include <net/if_media.h>
-#include <net/if.h>
-
-int psutil_get_nic_speed(int ifm_active) {
-    // Determine NIC speed. Taken from:
-    // http://www.i-scream.org/libstatgrab/
-    // Assuming only ETHER devices
-    switch(IFM_TYPE(ifm_active)) {
-        case IFM_ETHER:
-            switch(IFM_SUBTYPE(ifm_active)) {
-#if defined(IFM_HPNA_1) && ((!defined(IFM_10G_LR)) \
-    || (IFM_10G_LR != IFM_HPNA_1))
-                // HomePNA 1.0 (1Mb/s)
-                case(IFM_HPNA_1):
-                    return 1;
-#endif
-                // 10 Mbit
-                case(IFM_10_T):  // 10BaseT - RJ45
-                case(IFM_10_2):  // 10Base2 - Thinnet
-                case(IFM_10_5):  // 10Base5 - AUI
-                case(IFM_10_STP):  // 10BaseT over shielded TP
-                case(IFM_10_FL):  // 10baseFL - Fiber
-                    return 10;
-                // 100 Mbit
-                case(IFM_100_TX):  // 100BaseTX - RJ45
-                case(IFM_100_FX):  // 100BaseFX - Fiber
-                case(IFM_100_T4):  // 100BaseT4 - 4 pair cat 3
-                case(IFM_100_VG):  // 100VG-AnyLAN
-                case(IFM_100_T2):  // 100BaseT2
-                    return 100;
-                // 1000 Mbit
-                case(IFM_1000_SX):  // 1000BaseSX - multi-mode fiber
-                case(IFM_1000_LX):  // 1000baseLX - single-mode fiber
-                case(IFM_1000_CX):  // 1000baseCX - 150ohm STP
-#if defined(IFM_1000_TX) && !defined(__OpenBSD__)
-                // FreeBSD 4 and others (but NOT OpenBSD) -> #define IFM_1000_T in net/if_media.h
-                case(IFM_1000_TX):
-#endif
-#ifdef IFM_1000_FX
-                case(IFM_1000_FX):
-#endif
-#ifdef IFM_1000_T
-                case(IFM_1000_T):
-#endif
-                    return 1000;
-#if defined(IFM_10G_SR) || defined(IFM_10G_LR) || defined(IFM_10G_CX4) \
-         || defined(IFM_10G_T)
-#ifdef IFM_10G_SR
-                case(IFM_10G_SR):
-#endif
-#ifdef IFM_10G_LR
-                case(IFM_10G_LR):
-#endif
-#ifdef IFM_10G_CX4
-                case(IFM_10G_CX4):
-#endif
-#ifdef IFM_10G_TWINAX
-                case(IFM_10G_TWINAX):
-#endif
-#ifdef IFM_10G_TWINAX_LONG
-                case(IFM_10G_TWINAX_LONG):
-#endif
-#ifdef IFM_10G_T
-                case(IFM_10G_T):
-#endif
-                    return 10000;
-#endif
-#if defined(IFM_2500_SX)
-#ifdef IFM_2500_SX
-                case(IFM_2500_SX):
-#endif
-                    return 2500;
-#endif // any 2.5GBit stuff...
-                // We don't know what it is
-                default:
-                    return 0;
-            }
-            break;
-
-#ifdef IFM_TOKEN
-        case IFM_TOKEN:
-            switch(IFM_SUBTYPE(ifm_active)) {
-                case IFM_TOK_STP4:  // Shielded twisted pair 4m - DB9
-                case IFM_TOK_UTP4:  // Unshielded twisted pair 4m - RJ45
-                    return 4;
-                case IFM_TOK_STP16:  // Shielded twisted pair 16m - DB9
-                case IFM_TOK_UTP16:  // Unshielded twisted pair 16m - RJ45
-                    return 16;
-#if defined(IFM_TOK_STP100) || defined(IFM_TOK_UTP100)
-#ifdef IFM_TOK_STP100
-                case IFM_TOK_STP100:  // Shielded twisted pair 100m - DB9
-#endif
-#ifdef IFM_TOK_UTP100
-                case IFM_TOK_UTP100:  // Unshielded twisted pair 100m - RJ45
-#endif
-                    return 100;
-#endif
-                // We don't know what it is
-                default:
-                    return 0;
-            }
-            break;
-#endif
-
-#ifdef IFM_FDDI
-        case IFM_FDDI:
-            switch(IFM_SUBTYPE(ifm_active)) {
-                // We don't know what it is
-                default:
-                    return 0;
-            }
-            break;
-#endif
-        case IFM_IEEE80211:
-            switch(IFM_SUBTYPE(ifm_active)) {
-                case IFM_IEEE80211_FH1:  // Frequency Hopping 1Mbps
-                case IFM_IEEE80211_DS1:  // Direct Sequence 1Mbps
-                    return 1;
-                case IFM_IEEE80211_FH2:  // Frequency Hopping 2Mbps
-                case IFM_IEEE80211_DS2:  // Direct Sequence 2Mbps
-                    return 2;
-                case IFM_IEEE80211_DS5:  // Direct Sequence 5Mbps
-                    return 5;
-                case IFM_IEEE80211_DS11:  // Direct Sequence 11Mbps
-                    return 11;
-                case IFM_IEEE80211_DS22:  // Direct Sequence 22Mbps
-                    return 22;
-                // We don't know what it is
-                default:
-                    return 0;
-            }
-            break;
-
-        default:
-            return 0;
-    }
-}
-
-
-/*
- * Return stats about a particular network interface.
- * References:
- * http://www.i-scream.org/libstatgrab/
- */
-static PyObject *
-psutil_net_if_stats(PyObject *self, PyObject *args) {
-    char *nic_name;
-    int sock = 0;
-    int ret;
-    int duplex;
-    int speed;
-    int mtu;
-    struct ifreq ifr;
-    struct ifmediareq ifmed;
-
-    PyObject *py_is_up = NULL;
-
-    if (! PyArg_ParseTuple(args, "s", &nic_name))
-        return NULL;
-
-    sock = socket(AF_INET, SOCK_DGRAM, 0);
-    if (sock == -1)
-        goto error;
-    strncpy(ifr.ifr_name, nic_name, sizeof(ifr.ifr_name));
-
-    // is up?
-    ret = ioctl(sock, SIOCGIFFLAGS, &ifr);
-    if (ret == -1)
-        goto error;
-    if ((ifr.ifr_flags & IFF_UP) != 0)
-        py_is_up = Py_True;
-    else
-        py_is_up = Py_False;
-    Py_INCREF(py_is_up);
-
-    // MTU
-    ret = ioctl(sock, SIOCGIFMTU, &ifr);
-    if (ret == -1)
-        goto error;
-    mtu = ifr.ifr_mtu;
-
-    // speed / duplex
-    memset(&ifmed, 0, sizeof(struct ifmediareq));
-    strlcpy(ifmed.ifm_name, nic_name, sizeof(ifmed.ifm_name));
-    ret = ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifmed);
-    if (ret == -1) {
-        speed = 0;
-        duplex = 0;
-    }
-    else {
-        speed = psutil_get_nic_speed(ifmed.ifm_active);
-        if ((ifmed.ifm_active | IFM_FDX) == ifmed.ifm_active)
-            duplex = 2;
-        else if ((ifmed.ifm_active | IFM_HDX) == ifmed.ifm_active)
-            duplex = 1;
-        else
-            duplex = 0;
-    }
-
-    close(sock);
-    Py_DECREF(py_is_up);
-
-    return Py_BuildValue("[Oiii]", py_is_up, duplex, speed, mtu);
-
-error:
-    Py_XDECREF(py_is_up);
-    if (sock != 0)
-        close(sock);
-    PyErr_SetFromErrno(PyExc_OSError);
-    return NULL;
-}
-#endif  // net_if_stats() implementation
-
-
-/*
- * define the psutil C module methods and initialize the module.
- */
-static PyMethodDef
-PsutilMethods[] = {
-    {"getpriority", psutil_posix_getpriority, METH_VARARGS,
-     "Return process priority"},
-    {"setpriority", psutil_posix_setpriority, METH_VARARGS,
-     "Set process priority"},
-    {"net_if_addrs", psutil_net_if_addrs, METH_VARARGS,
-     "Retrieve NICs information"},
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__NetBSD__)
-    {"net_if_stats", psutil_net_if_stats, METH_VARARGS,
-     "Return NIC stats."},
-#endif
-    {NULL, NULL, 0, NULL}
-};
-
-struct module_state {
-    PyObject *error;
-};
-
-#if PY_MAJOR_VERSION >= 3
-#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
-#else
-#define GETSTATE(m) (&_state)
-#endif
-
-#if PY_MAJOR_VERSION >= 3
-
-static int
-psutil_posix_traverse(PyObject *m, visitproc visit, void *arg) {
-    Py_VISIT(GETSTATE(m)->error);
-    return 0;
-}
-
-static int
-psutil_posix_clear(PyObject *m) {
-    Py_CLEAR(GETSTATE(m)->error);
-    return 0;
-}
-
-static struct PyModuleDef moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "psutil_posix",
-    NULL,
-    sizeof(struct module_state),
-    PsutilMethods,
-    NULL,
-    psutil_posix_traverse,
-    psutil_posix_clear,
-    NULL
-};
-
-#define INITERROR return NULL
-
-PyMODINIT_FUNC PyInit__psutil_posix(void)
-
-#else
-#define INITERROR return
-
-void init_psutil_posix(void)
-#endif
-{
-#if PY_MAJOR_VERSION >= 3
-    PyObject *module = PyModule_Create(&moduledef);
-#else
-    PyObject *module = Py_InitModule("_psutil_posix", PsutilMethods);
-#endif
-
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__APPLE__) || defined(__sun) || defined(__NetBSD__)
-    PyModule_AddIntConstant(module, "AF_LINK", AF_LINK);
-#endif
-
-    if (module == NULL)
-        INITERROR;
-#if PY_MAJOR_VERSION >= 3
-    return module;
-#endif
-}
diff --git a/psutil/_psutil_posix.h b/psutil/_psutil_posix.h
deleted file mode 100644
index bbe6fc5ad2..0000000000
--- a/psutil/_psutil_posix.h
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include <Python.h>
-
-static PyObject* psutil_net_if_addrs(PyObject* self, PyObject* args);
-static PyObject* psutil_posix_getpriority(PyObject* self, PyObject* args);
-static PyObject* psutil_posix_setpriority(PyObject* self, PyObject* args);
-
-#if defined(__FreeBSD__) || defined(__APPLE__)
-static PyObject* psutil_net_if_stats(PyObject* self, PyObject* args);
-#endif
diff --git a/psutil/_psutil_sunos.c b/psutil/_psutil_sunos.c
index 0ceec54c24..b393221a06 100644
--- a/psutil/_psutil_sunos.c
+++ b/psutil/_psutil_sunos.c
@@ -2,1455 +2,121 @@
  * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
- *
- * Functions specific to Sun OS Solaris platforms.
- *
- * Thanks to Justin Venus who originally wrote a consistent part of
- * this in Cython which I later on translated in C.
  */
 
-
-#include <Python.h>
-
-// fix for "Cannot use procfs in the large file compilation environment"
-// error, see:
-// http://sourceware.org/ml/gdb-patches/2010-11/msg00336.html
-#undef _FILE_OFFSET_BITS
-#define _STRUCTURED_PROC 1
-
-// fix compilation issue on SunOS 5.10, see:
+// Functions specific to Sun OS Solaris platforms.
+//
+// Thanks to Justin Venus who originally wrote a consistent part of
+// this in Cython which I later on translated in C.
+//
+// Fix compilation issue on SunOS 5.10, see:
 // https://github.com/giampaolo/psutil/issues/421
-#define NEW_MIB_COMPLIANT
-
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/proc.h>
-#include <sys/swap.h>
-#include <sys/sysinfo.h>
-#include <sys/mntent.h>  // for MNTTAB
-#include <sys/mnttab.h>
-#include <sys/procfs.h>
-#include <sys/sockio.h>
-#include <sys/socket.h>
-#include <fcntl.h>
-#include <utmpx.h>
-#include <kstat.h>
-#include <sys/ioctl.h>
-#include <sys/tihdr.h>
-#include <stropts.h>
-#include <inet/tcp.h>
-#include <arpa/inet.h>
-#include <net/if.h>
-
-
-#define PSUTIL_TV2DOUBLE(t) (((t).tv_nsec * 0.000000001) + (t).tv_sec)
-#ifndef EXPER_IP_AND_ALL_IRES
-#define EXPER_IP_AND_ALL_IRES (1024+4)
-#endif
-// a signaler for connections without an actual status
-static int PSUTIL_CONN_NONE = 128;
-
-
-/*
- * Read a file content and fills a C structure with it.
- */
-int
-psutil_file_to_struct(char *path, void *fstruct, size_t size) {
-    int fd;
-    size_t nbytes;
-    fd = open(path, O_RDONLY);
-    if (fd == -1) {
-        PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
-        return 0;
-    }
-    nbytes = read(fd, fstruct, size);
-    if (nbytes == -1) {
-        close(fd);
-        PyErr_SetFromErrno(PyExc_OSError);
-        return 0;
-    }
-    if (nbytes != size) {
-        close(fd);
-        PyErr_SetString(PyExc_RuntimeError, "structure size mismatch");
-        return 0;
-    }
-    close(fd);
-    return nbytes;
-}
-
-
-/*
- * Return process ppid, rss, vms, ctime, nice, nthreads, status and tty
- * as a Python tuple.
- */
-static PyObject *
-psutil_proc_basic_info(PyObject *self, PyObject *args) {
-    int pid;
-    char path[1000];
-    psinfo_t info;
-    const char *procfs_path;
-
-    if (! PyArg_ParseTuple(args, "is", &pid, &procfs_path))
-        return NULL;
-
-    sprintf(path, "%s/%i/psinfo", procfs_path, pid);
-    if (! psutil_file_to_struct(path, (void *)&info, sizeof(info)))
-        return NULL;
-    return Py_BuildValue("ikkdiiik",
-                         info.pr_ppid,              // parent pid
-                         info.pr_rssize,            // rss
-                         info.pr_size,              // vms
-                         PSUTIL_TV2DOUBLE(info.pr_start),  // create time
-                         info.pr_lwp.pr_nice,       // nice
-                         info.pr_nlwp,              // no. of threads
-                         info.pr_lwp.pr_state,      // status code
-                         info.pr_ttydev             // tty nr
-                        );
-}
-
-
-/*
- * Return process name and args as a Python tuple.
- */
-static PyObject *
-psutil_proc_name_and_args(PyObject *self, PyObject *args) {
-    int pid;
-    char path[1000];
-    psinfo_t info;
-    const char *procfs_path;
-    PyObject *py_name;
-    PyObject *py_args;
-
-    if (! PyArg_ParseTuple(args, "is", &pid, &procfs_path))
-        return NULL;
-    sprintf(path, "%s/%i/psinfo", procfs_path, pid);
-    if (! psutil_file_to_struct(path, (void *)&info, sizeof(info)))
-        return NULL;
-
-#if PY_MAJOR_VERSION >= 3
-    py_name = PyUnicode_DecodeFSDefault(info.pr_fname);
-    if (!py_name)
-        return NULL;
-    py_args = PyUnicode_DecodeFSDefault(info.pr_psargs);
-    if (!py_args)
-        return NULL;
-    return Py_BuildValue("OO", py_name, py_args);
-#else
-    return Py_BuildValue("ss", info.pr_fname, info.pr_psargs);
-#endif
-}
-
-
-/*
- * Return process user and system CPU times as a Python tuple.
- */
-static PyObject *
-psutil_proc_cpu_times(PyObject *self, PyObject *args) {
-    int pid;
-    char path[1000];
-    pstatus_t info;
-    const char *procfs_path;
-
-    if (! PyArg_ParseTuple(args, "is", &pid, &procfs_path))
-        return NULL;
-    sprintf(path, "%s/%i/status", procfs_path, pid);
-    if (! psutil_file_to_struct(path, (void *)&info, sizeof(info)))
-        return NULL;
-    // results are more precise than os.times()
-    return Py_BuildValue(
-        "(dddd)",
-         PSUTIL_TV2DOUBLE(info.pr_utime),
-         PSUTIL_TV2DOUBLE(info.pr_stime),
-         PSUTIL_TV2DOUBLE(info.pr_cutime),
-         PSUTIL_TV2DOUBLE(info.pr_cstime)
-    );
-}
-
-
-/*
- * Return process uids/gids as a Python tuple.
- */
-static PyObject *
-psutil_proc_cred(PyObject *self, PyObject *args) {
-    int pid;
-    char path[1000];
-    prcred_t info;
-    const char *procfs_path;
-
-    if (! PyArg_ParseTuple(args, "is", &pid, &procfs_path))
-        return NULL;
-    sprintf(path, "%s/%i/cred", procfs_path, pid);
-    if (! psutil_file_to_struct(path, (void *)&info, sizeof(info)))
-        return NULL;
-    return Py_BuildValue("iiiiii",
-                         info.pr_ruid, info.pr_euid, info.pr_suid,
-                         info.pr_rgid, info.pr_egid, info.pr_sgid);
-}
-
-
-/*
- * Return process uids/gids as a Python tuple.
- */
-static PyObject *
-psutil_proc_num_ctx_switches(PyObject *self, PyObject *args) {
-    int pid;
-    char path[1000];
-    prusage_t info;
-    const char *procfs_path;
-
-    if (! PyArg_ParseTuple(args, "is", &pid, &procfs_path))
-        return NULL;
-    sprintf(path, "%s/%i/usage", procfs_path, pid);
-    if (! psutil_file_to_struct(path, (void *)&info, sizeof(info)))
-        return NULL;
-    return Py_BuildValue("kk", info.pr_vctx, info.pr_ictx);
-}
-
-
-/*
- * Process IO counters.
- *
- * Commented out and left here as a reminder.  Apparently we cannot
- * retrieve process IO stats because:
- * - 'pr_ioch' is a sum of chars read and written, with no distinction
- * - 'pr_inblk' and 'pr_oublk', which should be the number of bytes
- *    read and written, hardly increase and according to:
- *    http://www.brendangregg.com/Perf/paper_diskubyp1.pdf
- *    ...they should be meaningless anyway.
- *
-static PyObject*
-proc_io_counters(PyObject* self, PyObject* args) {
-    int pid;
-    char path[1000];
-    prusage_t info;
-    const char *procfs_path;
-
-    if (! PyArg_ParseTuple(args, "is", &pid, &procfs_path))
-        return NULL;
-    sprintf(path, "%s/%i/usage", procfs_path, pid);
-    if (! psutil_file_to_struct(path, (void *)&info, sizeof(info)))
-        return NULL;
-
-    // On Solaris we only have 'pr_ioch' which accounts for bytes read
-    // *and* written.
-    // 'pr_inblk' and 'pr_oublk' should be expressed in blocks of
-    // 8KB according to:
-    // http://www.brendangregg.com/Perf/paper_diskubyp1.pdf  (pag. 8)
-    return Py_BuildValue("kkkk",
-                         info.pr_ioch,
-                         info.pr_ioch,
-                         info.pr_inblk,
-                         info.pr_oublk);
-}
- */
-
-
-/*
- * Return information about a given process thread.
- */
-static PyObject *
-psutil_proc_query_thread(PyObject *self, PyObject *args) {
-    int pid, tid;
-    char path[1000];
-    lwpstatus_t info;
-    const char *procfs_path;
-
-    if (! PyArg_ParseTuple(args, "iis", &pid, &tid, &procfs_path))
-        return NULL;
-    sprintf(path, "%s/%i/lwp/%i/lwpstatus", procfs_path, pid, tid);
-    if (! psutil_file_to_struct(path, (void *)&info, sizeof(info)))
-        return NULL;
-    return Py_BuildValue("dd",
-                         PSUTIL_TV2DOUBLE(info.pr_utime),
-                         PSUTIL_TV2DOUBLE(info.pr_stime));
-}
-
-
-/*
- * Return information about system virtual memory.
- */
-static PyObject *
-psutil_swap_mem(PyObject *self, PyObject *args) {
-// XXX (arghhh!)
-// total/free swap mem: commented out as for some reason I can't
-// manage to get the same results shown by "swap -l", despite the
-// code below is exactly the same as:
-// http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/
-//    cmd/swap/swap.c
-// We're going to parse "swap -l" output from Python (sigh!)
-
-/*
-    struct swaptable     *st;
-    struct swapent    *swapent;
-    int    i;
-    struct stat64 statbuf;
-    char *path;
-    char fullpath[MAXPATHLEN+1];
-    int    num;
-
-    if ((num = swapctl(SC_GETNSWP, NULL)) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-    if (num == 0) {
-        PyErr_SetString(PyExc_RuntimeError, "no swap devices configured");
-        return NULL;
-    }
-    if ((st = malloc(num * sizeof(swapent_t) + sizeof (int))) == NULL) {
-        PyErr_SetString(PyExc_RuntimeError, "malloc failed");
-        return NULL;
-    }
-    if ((path = malloc(num * MAXPATHLEN)) == NULL) {
-        PyErr_SetString(PyExc_RuntimeError, "malloc failed");
-        return NULL;
-    }
-    swapent = st->swt_ent;
-    for (i = 0; i < num; i++, swapent++) {
-        swapent->ste_path = path;
-        path += MAXPATHLEN;
-    }
-    st->swt_n = num;
-    if ((num = swapctl(SC_LIST, st)) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    swapent = st->swt_ent;
-    long t = 0, f = 0;
-    for (i = 0; i < num; i++, swapent++) {
-        int diskblks_per_page =(int)(sysconf(_SC_PAGESIZE) >> DEV_BSHIFT);
-        t += (long)swapent->ste_pages;
-        f += (long)swapent->ste_free;
-    }
-
-    free(st);
-    return Py_BuildValue("(kk)", t, f);
-*/
-
-    kstat_ctl_t *kc;
-    kstat_t     *k;
-    cpu_stat_t  *cpu;
-    int         cpu_count = 0;
-    int         flag = 0;
-    uint_t      sin = 0;
-    uint_t      sout = 0;
-
-    kc = kstat_open();
-    if (kc == NULL)
-        return PyErr_SetFromErrno(PyExc_OSError);;
-
-    k = kc->kc_chain;
-    while (k != NULL) {
-        if ((strncmp(k->ks_name, "cpu_stat", 8) == 0) && \
-                (kstat_read(kc, k, NULL) != -1) )
-        {
-            flag = 1;
-            cpu = (cpu_stat_t *) k->ks_data;
-            sin += cpu->cpu_vminfo.pgswapin;    // num pages swapped in
-            sout += cpu->cpu_vminfo.pgswapout;  // num pages swapped out
-        }
-        cpu_count += 1;
-        k = k->ks_next;
-    }
-    kstat_close(kc);
-    if (!flag) {
-        PyErr_SetString(PyExc_RuntimeError, "no swap device was found");
-        return NULL;
-    }
-    return Py_BuildValue("(II)", sin, sout);
-}
-
-
-/*
- * Return users currently connected on the system.
- */
-static PyObject *
-psutil_users(PyObject *self, PyObject *args) {
-    struct utmpx *ut;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_user_proc = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    while (NULL != (ut = getutxent())) {
-        if (ut->ut_type == USER_PROCESS)
-            py_user_proc = Py_True;
-        else
-            py_user_proc = Py_False;
-        py_tuple = Py_BuildValue(
-            "(sssfO)",
-            ut->ut_user,              // username
-            ut->ut_line,              // tty
-            ut->ut_host,              // hostname
-            (float)ut->ut_tv.tv_sec,  // tstamp
-            py_user_proc);            // (bool) user process
-        if (py_tuple == NULL)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-    endutent();
-
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (ut != NULL)
-        endutent();
-    return NULL;
-}
-
-
-/*
- * Return disk mounted partitions as a list of tuples including device,
- * mount point and filesystem type.
- */
-static PyObject *
-psutil_disk_partitions(PyObject *self, PyObject *args) {
-    FILE *file;
-    struct mnttab mt;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    file = fopen(MNTTAB, "rb");
-    if (file == NULL) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    while (getmntent(file, &mt) == 0) {
-        py_tuple = Py_BuildValue(
-            "(ssss)",
-            mt.mnt_special,   // device
-            mt.mnt_mountp,    // mount point
-            mt.mnt_fstype,    // fs type
-            mt.mnt_mntopts);  // options
-        if (py_tuple == NULL)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-
-    }
-    fclose(file);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (file != NULL)
-        fclose(file);
-    return NULL;
-}
-
-
-/*
- * Return system-wide CPU times.
- */
-static PyObject *
-psutil_per_cpu_times(PyObject *self, PyObject *args) {
-    kstat_ctl_t *kc;
-    kstat_t *ksp;
-    cpu_stat_t cs;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_cputime = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    kc = kstat_open();
-    if (kc == NULL) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    for (ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) {
-        if (strcmp(ksp->ks_module, "cpu_stat") == 0) {
-            if (kstat_read(kc, ksp, &cs) == -1) {
-                PyErr_SetFromErrno(PyExc_OSError);
-                goto error;
-            }
-            py_cputime = Py_BuildValue("ffff",
-                                       (float)cs.cpu_sysinfo.cpu[CPU_USER],
-                                       (float)cs.cpu_sysinfo.cpu[CPU_KERNEL],
-                                       (float)cs.cpu_sysinfo.cpu[CPU_IDLE],
-                                       (float)cs.cpu_sysinfo.cpu[CPU_WAIT]);
-            if (py_cputime == NULL)
-                goto error;
-            if (PyList_Append(py_retlist, py_cputime))
-                goto error;
-            Py_DECREF(py_cputime);
-            py_cputime = NULL;
-        }
-    }
-
-    kstat_close(kc);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_cputime);
-    Py_DECREF(py_retlist);
-    if (kc != NULL)
-        kstat_close(kc);
-    return NULL;
-}
-
-
-/*
- * Return disk IO statistics.
- */
-static PyObject *
-psutil_disk_io_counters(PyObject *self, PyObject *args) {
-    kstat_ctl_t *kc;
-    kstat_t *ksp;
-    kstat_io_t kio;
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_disk_info = NULL;
-
-    if (py_retdict == NULL)
-        return NULL;
-    kc = kstat_open();
-    if (kc == NULL) {
-        PyErr_SetFromErrno(PyExc_OSError);;
-        goto error;
-    }
-    ksp = kc->kc_chain;
-    while (ksp != NULL) {
-        if (ksp->ks_type == KSTAT_TYPE_IO) {
-            if (strcmp(ksp->ks_class, "disk") == 0) {
-                if (kstat_read(kc, ksp, &kio) == -1) {
-                    kstat_close(kc);
-                    return PyErr_SetFromErrno(PyExc_OSError);;
-                }
-                py_disk_info = Py_BuildValue(
-                    "(IIKKLL)",
-                    kio.reads,
-                    kio.writes,
-                    kio.nread,
-                    kio.nwritten,
-                    kio.rtime / 1000 / 1000,  // from nano to milli secs
-                    kio.wtime / 1000 / 1000   // from nano to milli secs
-                );
-                if (!py_disk_info)
-                    goto error;
-                if (PyDict_SetItemString(py_retdict, ksp->ks_name,
-                                         py_disk_info))
-                    goto error;
-                Py_DECREF(py_disk_info);
-            }
-        }
-        ksp = ksp->ks_next;
-    }
-    kstat_close(kc);
-
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_disk_info);
-    Py_DECREF(py_retdict);
-    if (kc != NULL)
-        kstat_close(kc);
-    return NULL;
-}
-
-
-/*
- * Return process memory mappings.
- */
-static PyObject *
-psutil_proc_memory_maps(PyObject *self, PyObject *args) {
-    int pid;
-    int fd = -1;
-    char path[1000];
-    char perms[10];
-    char *name;
-    struct stat st;
-    pstatus_t status;
-
-    prxmap_t *xmap = NULL, *p;
-    off_t size;
-    size_t nread;
-    int nmap;
-    uintptr_t pr_addr_sz;
-    uintptr_t stk_base_sz, brk_base_sz;
-    const char *procfs_path;
-
-    PyObject *py_tuple = NULL;
-    PyObject *py_retlist = PyList_New(0);
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "is", &pid, &procfs_path))
-        goto error;
-
-    sprintf(path, "%s/%i/status", procfs_path, pid);
-    if (! psutil_file_to_struct(path, (void *)&status, sizeof(status)))
-        goto error;
-
-    sprintf(path, "%s/%i/xmap", procfs_path, pid);
-    if (stat(path, &st) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    size = st.st_size;
+// https://github.com/giampaolo/psutil/issues/1077
 
-    fd = open(path, O_RDONLY);
-    if (fd == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    xmap = (prxmap_t *)malloc(size);
-    if (xmap == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    nread = pread(fd, xmap, size, 0);
-    nmap = nread / sizeof(prxmap_t);
-    p = xmap;
-
-    while (nmap) {
-        nmap -= 1;
-        if (p == NULL) {
-            p += 1;
-            continue;
-        }
-
-        perms[0] = '\0';
-        pr_addr_sz = p->pr_vaddr + p->pr_size;
-
-        // perms
-        sprintf(perms, "%c%c%c%c%c%c", p->pr_mflags & MA_READ ? 'r' : '-',
-                p->pr_mflags & MA_WRITE ? 'w' : '-',
-                p->pr_mflags & MA_EXEC ? 'x' : '-',
-                p->pr_mflags & MA_SHARED ? 's' : '-',
-                p->pr_mflags & MA_NORESERVE ? 'R' : '-',
-                p->pr_mflags & MA_RESERVED1 ? '*' : ' ');
-
-        // name
-        if (strlen(p->pr_mapname) > 0) {
-            name = p->pr_mapname;
-        }
-        else {
-            if ((p->pr_mflags & MA_ISM) || (p->pr_mflags & MA_SHM)) {
-                name = "[shmid]";
-            }
-            else {
-                stk_base_sz = status.pr_stkbase + status.pr_stksize;
-                brk_base_sz = status.pr_brkbase + status.pr_brksize;
-
-                if ((pr_addr_sz > status.pr_stkbase) &&
-                        (p->pr_vaddr < stk_base_sz)) {
-                    name = "[stack]";
-                }
-                else if ((p->pr_mflags & MA_ANON) && \
-                         (pr_addr_sz > status.pr_brkbase) && \
-                         (p->pr_vaddr < brk_base_sz)) {
-                    name = "[heap]";
-                }
-                else {
-                    name = "[anon]";
-                }
-            }
-        }
-
-        py_tuple = Py_BuildValue(
-            "iisslll",
-            p->pr_vaddr,
-            pr_addr_sz,
-            perms,
-            name,
-            (long)p->pr_rss * p->pr_pagesize,
-            (long)p->pr_anon * p->pr_pagesize,
-            (long)p->pr_locked * p->pr_pagesize);
-        if (!py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-
-        // increment pointer
-        p += 1;
-    }
-
-    close(fd);
-    free(xmap);
-    return py_retlist;
-
-error:
-    if (fd != -1)
-        close(fd);
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (xmap != NULL)
-        free(xmap);
-    return NULL;
-}
-
-
-/*
- * Return a list of tuples for network I/O statistics.
- */
-static PyObject *
-psutil_net_io_counters(PyObject *self, PyObject *args) {
-    kstat_ctl_t    *kc = NULL;
-    kstat_t *ksp;
-    kstat_named_t *rbytes, *wbytes, *rpkts, *wpkts, *ierrs, *oerrs;
-    int ret;
-    int sock = -1;
-    struct lifreq ifr;
-
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_ifc_info = NULL;
-
-    if (py_retdict == NULL)
-        return NULL;
-    kc = kstat_open();
-    if (kc == NULL)
-        goto error;
-
-    sock = socket(AF_INET, SOCK_DGRAM, 0);
-    if (sock == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    ksp = kc->kc_chain;
-    while (ksp != NULL) {
-        if (ksp->ks_type != KSTAT_TYPE_NAMED)
-            goto next;
-        if (strcmp(ksp->ks_class, "net") != 0)
-            goto next;
-        // skip 'lo' (localhost) because it doesn't have the statistics we need
-        // and it makes kstat_data_lookup() fail
-        if (strcmp(ksp->ks_module, "lo") == 0)
-            goto next;
-
-        // check if this is a network interface by sending a ioctl
-        strncpy(ifr.lifr_name, ksp->ks_name, sizeof(ifr.lifr_name));
-        ret = ioctl(sock, SIOCGLIFFLAGS, &ifr);
-        if (ret == -1)
-            goto next;
-
-        if (kstat_read(kc, ksp, NULL) == -1) {
-            errno = 0;
-            goto next;
-        }
-
-        rbytes = (kstat_named_t *)kstat_data_lookup(ksp, "rbytes");
-        wbytes = (kstat_named_t *)kstat_data_lookup(ksp, "obytes");
-        rpkts = (kstat_named_t *)kstat_data_lookup(ksp, "ipackets");
-        wpkts = (kstat_named_t *)kstat_data_lookup(ksp, "opackets");
-        ierrs = (kstat_named_t *)kstat_data_lookup(ksp, "ierrors");
-        oerrs = (kstat_named_t *)kstat_data_lookup(ksp, "oerrors");
-
-        if ((rbytes == NULL) || (wbytes == NULL) || (rpkts == NULL) ||
-                (wpkts == NULL) || (ierrs == NULL) || (oerrs == NULL))
-        {
-            PyErr_SetString(PyExc_RuntimeError, "kstat_data_lookup() failed");
-            goto error;
-        }
-
-        if (rbytes->data_type == KSTAT_DATA_UINT64)
-        {
-            py_ifc_info = Py_BuildValue("(KKKKIIii)",
-                                        wbytes->value.ui64,
-                                        rbytes->value.ui64,
-                                        wpkts->value.ui64,
-                                        rpkts->value.ui64,
-                                        ierrs->value.ui32,
-                                        oerrs->value.ui32,
-                                        0,  // dropin not supported
-                                        0   // dropout not supported
-                                       );
-        }
-        else
-        {
-            py_ifc_info = Py_BuildValue("(IIIIIIii)",
-                                        wbytes->value.ui32,
-                                        rbytes->value.ui32,
-                                        wpkts->value.ui32,
-                                        rpkts->value.ui32,
-                                        ierrs->value.ui32,
-                                        oerrs->value.ui32,
-                                        0,  // dropin not supported
-                                        0   // dropout not supported
-                                       );
-        }
-        if (!py_ifc_info)
-            goto error;
-        if (PyDict_SetItemString(py_retdict, ksp->ks_name, py_ifc_info))
-            goto error;
-        Py_DECREF(py_ifc_info);
-        goto next;
-
-next:
-        ksp = ksp->ks_next;
-    }
-
-    kstat_close(kc);
-    close(sock);
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_ifc_info);
-    Py_DECREF(py_retdict);
-    if (kc != NULL)
-        kstat_close(kc);
-    if (sock != -1) {
-        close(sock);
-    }
-    return NULL;
-}
-
-
-/*
- * Return TCP and UDP connections opened by process.
- * UNIX sockets are excluded.
- *
- * Thanks to:
- * https://github.com/DavidGriffith/finx/blob/master/
- *     nxsensor-3.5.0-1/src/sysdeps/solaris.c
- * ...and:
- * https://hg.java.net/hg/solaris~on-src/file/tip/usr/src/cmd/
- *     cmd-inet/usr.bin/netstat/netstat.c
- */
-static PyObject *
-psutil_net_connections(PyObject *self, PyObject *args) {
-    long pid;
-    int sd = 0;
-    mib2_tcpConnEntry_t *tp = NULL;
-    mib2_udpEntry_t     *ude;
-#if defined(AF_INET6)
-    mib2_tcp6ConnEntry_t *tp6;
-    mib2_udp6Entry_t     *ude6;
-#endif
-    char buf[512];
-    int i, flags, getcode, num_ent, state;
-    char lip[200], rip[200];
-    int lport, rport;
-    int processed_pid;
-    int databuf_init = 0;
-    struct strbuf ctlbuf, databuf;
-    struct T_optmgmt_req *tor = (struct T_optmgmt_req *)buf;
-    struct T_optmgmt_ack *toa = (struct T_optmgmt_ack *)buf;
-    struct T_error_ack   *tea = (struct T_error_ack *)buf;
-    struct opthdr        *mibhdr;
-
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_laddr = NULL;
-    PyObject *py_raddr = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-
-    sd = open("/dev/arp", O_RDWR);
-    if (sd == -1) {
-        PyErr_SetFromErrnoWithFilename(PyExc_OSError, "/dev/arp");
-        goto error;
-    }
-
-    /*
-    XXX - These 2 are used in ifconfig.c but they seem unnecessary
-    ret = ioctl(sd, I_PUSH, "tcp");
-    if (ret == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-    ret = ioctl(sd, I_PUSH, "udp");
-    if (ret == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-    */
-
-    // OK, this mess is basically copied and pasted from nxsensor project
-    // which copied and pasted it from netstat source code, mibget()
-    // function.  Also see:
-    // http://stackoverflow.com/questions/8723598/
-    tor->PRIM_type = T_SVR4_OPTMGMT_REQ;
-    tor->OPT_offset = sizeof (struct T_optmgmt_req);
-    tor->OPT_length = sizeof (struct opthdr);
-    tor->MGMT_flags = T_CURRENT;
-    mibhdr = (struct opthdr *)&tor[1];
-    mibhdr->level = EXPER_IP_AND_ALL_IRES;
-    mibhdr->name  = 0;
-    mibhdr->len   = 0;
-
-    ctlbuf.buf = buf;
-    ctlbuf.len = tor->OPT_offset + tor->OPT_length;
-    flags = 0;  // request to be sent in non-priority
-
-    if (putmsg(sd, &ctlbuf, (struct strbuf *)0, flags) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    mibhdr = (struct opthdr *)&toa[1];
-    ctlbuf.maxlen = sizeof (buf);
-
-    for (;;) {
-        flags = 0;
-        getcode = getmsg(sd, &ctlbuf, (struct strbuf *)0, &flags);
-
-        if (getcode != MOREDATA ||
-                ctlbuf.len < sizeof (struct T_optmgmt_ack) ||
-                toa->PRIM_type != T_OPTMGMT_ACK ||
-                toa->MGMT_flags != T_SUCCESS)
-        {
-            break;
-        }
-        if (ctlbuf.len >= sizeof (struct T_error_ack) &&
-                tea->PRIM_type == T_ERROR_ACK)
-        {
-            PyErr_SetString(PyExc_RuntimeError, "ERROR_ACK");
-            goto error;
-        }
-        if (getcode == 0 &&
-                ctlbuf.len >= sizeof (struct T_optmgmt_ack) &&
-                toa->PRIM_type == T_OPTMGMT_ACK &&
-                toa->MGMT_flags == T_SUCCESS)
-        {
-            PyErr_SetString(PyExc_RuntimeError, "ERROR_T_OPTMGMT_ACK");
-            goto error;
-        }
-
-        databuf.maxlen = mibhdr->len;
-        databuf.len = 0;
-        databuf.buf = (char *)malloc((int)mibhdr->len);
-        if (!databuf.buf) {
-            PyErr_NoMemory();
-            goto error;
-        }
-        databuf_init = 1;
-
-        flags = 0;
-        getcode = getmsg(sd, (struct strbuf *)0, &databuf, &flags);
-        if (getcode < 0) {
-            PyErr_SetFromErrno(PyExc_OSError);
-            goto error;
-        }
-
-        // TCPv4
-        if (mibhdr->level == MIB2_TCP && mibhdr->name == MIB2_TCP_13) {
-            tp = (mib2_tcpConnEntry_t *)databuf.buf;
-            num_ent = mibhdr->len / sizeof(mib2_tcpConnEntry_t);
-            for (i = 0; i < num_ent; i++, tp++) {
-                processed_pid = tp->tcpConnCreationProcess;
-                if (pid != -1 && processed_pid != pid)
-                    continue;
-                // construct local/remote addresses
-                inet_ntop(AF_INET, &tp->tcpConnLocalAddress, lip, sizeof(lip));
-                inet_ntop(AF_INET, &tp->tcpConnRemAddress, rip, sizeof(rip));
-                lport = tp->tcpConnLocalPort;
-                rport = tp->tcpConnRemPort;
-
-                // contruct python tuple/list
-                py_laddr = Py_BuildValue("(si)", lip, lport);
-                if (!py_laddr)
-                    goto error;
-                if (rport != 0)
-                    py_raddr = Py_BuildValue("(si)", rip, rport);
-                else {
-                    py_raddr = Py_BuildValue("()");
-                }
-                if (!py_raddr)
-                    goto error;
-                state = tp->tcpConnEntryInfo.ce_state;
-
-                // add item
-                py_tuple = Py_BuildValue("(iiiNNiI)", -1, AF_INET, SOCK_STREAM,
-                                         py_laddr, py_raddr, state,
-                                         processed_pid);
-                if (!py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-            }
-        }
-#if defined(AF_INET6)
-        // TCPv6
-        else if (mibhdr->level == MIB2_TCP6 && mibhdr->name == MIB2_TCP6_CONN)
-        {
-            tp6 = (mib2_tcp6ConnEntry_t *)databuf.buf;
-            num_ent = mibhdr->len / sizeof(mib2_tcp6ConnEntry_t);
-
-            for (i = 0; i < num_ent; i++, tp6++) {
-                processed_pid = tp6->tcp6ConnCreationProcess;
-                if (pid != -1 && processed_pid != pid)
-                    continue;
-                // construct local/remote addresses
-                inet_ntop(AF_INET6, &tp6->tcp6ConnLocalAddress, lip, sizeof(lip));
-                inet_ntop(AF_INET6, &tp6->tcp6ConnRemAddress, rip, sizeof(rip));
-                lport = tp6->tcp6ConnLocalPort;
-                rport = tp6->tcp6ConnRemPort;
+#define _STRUCTURED_PROC 1
+#define NEW_MIB_COMPLIANT 1
 
-                // contruct python tuple/list
-                py_laddr = Py_BuildValue("(si)", lip, lport);
-                if (!py_laddr)
-                    goto error;
-                if (rport != 0)
-                    py_raddr = Py_BuildValue("(si)", rip, rport);
-                else
-                    py_raddr = Py_BuildValue("()");
-                if (!py_raddr)
-                    goto error;
-                state = tp6->tcp6ConnEntryInfo.ce_state;
+#include <Python.h>
 
-                // add item
-                py_tuple = Py_BuildValue("(iiiNNiI)", -1, AF_INET6, SOCK_STREAM,
-                                         py_laddr, py_raddr, state, processed_pid);
-                if (!py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-            }
-        }
-#endif
-        // UDPv4
-        else if (mibhdr->level == MIB2_UDP || mibhdr->level == MIB2_UDP_ENTRY) {
-            ude = (mib2_udpEntry_t *)databuf.buf;
-            num_ent = mibhdr->len / sizeof(mib2_udpEntry_t);
-            for (i = 0; i < num_ent; i++, ude++) {
-                processed_pid = ude->udpCreationProcess;
-                if (pid != -1 && processed_pid != pid)
-                    continue;
-                // XXX Very ugly hack! It seems we get here only the first
-                // time we bump into a UDPv4 socket.  PID is a very high
-                // number (clearly impossible) and the address does not
-                // belong to any valid interface.  Not sure what else
-                // to do other than skipping.
-                if (processed_pid > 131072)
-                    continue;
-                inet_ntop(AF_INET, &ude->udpLocalAddress, lip, sizeof(lip));
-                lport = ude->udpLocalPort;
-                py_laddr = Py_BuildValue("(si)", lip, lport);
-                if (!py_laddr)
-                    goto error;
-                py_raddr = Py_BuildValue("()");
-                if (!py_raddr)
-                    goto error;
-                py_tuple = Py_BuildValue("(iiiNNiI)", -1, AF_INET, SOCK_DGRAM,
-                                         py_laddr, py_raddr, PSUTIL_CONN_NONE,
-                                         processed_pid);
-                if (!py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-            }
-        }
-#if defined(AF_INET6)
-        // UDPv6
-        else if (mibhdr->level == MIB2_UDP6 ||
-                    mibhdr->level == MIB2_UDP6_ENTRY)
-            {
-            ude6 = (mib2_udp6Entry_t *)databuf.buf;
-            num_ent = mibhdr->len / sizeof(mib2_udp6Entry_t);
-            for (i = 0; i < num_ent; i++, ude6++) {
-                processed_pid = ude6->udp6CreationProcess;
-                if (pid != -1 && processed_pid != pid)
-                    continue;
-                inet_ntop(AF_INET6, &ude6->udp6LocalAddress, lip, sizeof(lip));
-                lport = ude6->udp6LocalPort;
-                py_laddr = Py_BuildValue("(si)", lip, lport);
-                if (!py_laddr)
-                    goto error;
-                py_raddr = Py_BuildValue("()");
-                if (!py_raddr)
-                    goto error;
-                py_tuple = Py_BuildValue("(iiiNNiI)", -1, AF_INET6, SOCK_DGRAM,
-                                         py_laddr, py_raddr, PSUTIL_CONN_NONE,
-                                         processed_pid);
-                if (!py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-            }
-        }
+#if !defined(_LP64) && _FILE_OFFSET_BITS == 64
+#undef _FILE_OFFSET_BITS
+#undef _LARGEFILE64_SOURCE
 #endif
-        free(databuf.buf);
-    }
-
-    close(sd);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_laddr);
-    Py_XDECREF(py_raddr);
-    Py_DECREF(py_retlist);
-    if (databuf_init == 1)
-        free(databuf.buf);
-    if (sd != 0)
-        close(sd);
-    return NULL;
-}
-
-
-static PyObject *
-psutil_boot_time(PyObject *self, PyObject *args) {
-    float boot_time = 0.0;
-    struct utmpx *ut;
-
-    while (NULL != (ut = getutxent())) {
-        if (ut->ut_type == BOOT_TIME) {
-            boot_time = (float)ut->ut_tv.tv_sec;
-            break;
-        }
-    }
-    endutent();
-    if (boot_time != 0.0) {
-        return Py_BuildValue("f", boot_time);
-    }
-    else {
-        PyErr_SetString(PyExc_RuntimeError, "can't determine boot time");
-        return NULL;
-    }
-}
-
 
-/*
- * Return the number of physical CPU cores on the system.
- */
-static PyObject *
-psutil_cpu_count_phys(PyObject *self, PyObject *args) {
-    kstat_ctl_t *kc;
-    kstat_t *ksp;
-    int ncpus = 0;
-
-    kc = kstat_open();
-    if (kc == NULL)
-        goto error;
-    ksp = kstat_lookup(kc, "cpu_info", -1, NULL);
-    if (ksp == NULL)
-        goto error;
-
-    for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
-        if (strcmp(ksp->ks_module, "cpu_info") != 0)
-            continue;
-        if (kstat_read(kc, ksp, NULL) == -1)
-            goto error;
-        ncpus += 1;
-    }
-
-    kstat_close(kc);
-    if (ncpus > 0)
-        return Py_BuildValue("i", ncpus);
-    else
-        goto error;
-
-error:
-    // mimic os.cpu_count()
-    if (kc != NULL)
-        kstat_close(kc);
-    Py_RETURN_NONE;
-}
-
-
-/*
- * Return stats about a particular network
- * interface.  References:
- * https://github.com/dpaleino/wicd/blob/master/wicd/backends/be-ioctl.py
- * http://www.i-scream.org/libstatgrab/
- */
-static PyObject*
-psutil_net_if_stats(PyObject* self, PyObject* args) {
-    kstat_ctl_t *kc = NULL;
-    kstat_t *ksp;
-    kstat_named_t *knp;
-    int ret;
-    int sock = -1;
-    int duplex;
-    int speed;
-
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_ifc_info = NULL;
-    PyObject *py_is_up = NULL;
-
-    if (py_retdict == NULL)
-        return NULL;
-    kc = kstat_open();
-    if (kc == NULL)
-        goto error;
-    sock = socket(AF_INET, SOCK_DGRAM, 0);
-    if (sock == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
-        if (strcmp(ksp->ks_class, "net") == 0) {
-            struct lifreq ifr;
-
-            kstat_read(kc, ksp, NULL);
-            if (ksp->ks_type != KSTAT_TYPE_NAMED)
-                continue;
-            if (strcmp(ksp->ks_class, "net") != 0)
-                continue;
-
-            strncpy(ifr.lifr_name, ksp->ks_name, sizeof(ifr.lifr_name));
-            ret = ioctl(sock, SIOCGLIFFLAGS, &ifr);
-            if (ret == -1)
-                continue;  // not a network interface
-
-            // is up?
-            if ((ifr.lifr_flags & IFF_UP) != 0) {
-                if ((knp = kstat_data_lookup(ksp, "link_up")) != NULL) {
-                    if (knp->value.ui32 != 0u)
-                        py_is_up = Py_True;
-                    else
-                        py_is_up = Py_False;
-                }
-                else {
-                    py_is_up = Py_True;
-                }
-            }
-            else {
-                py_is_up = Py_False;
-            }
-            Py_INCREF(py_is_up);
-
-            // duplex
-            duplex = 0;  // unknown
-            if ((knp = kstat_data_lookup(ksp, "link_duplex")) != NULL) {
-                if (knp->value.ui32 == 1)
-                    duplex = 1;  // half
-                else if (knp->value.ui32 == 2)
-                    duplex = 2;  // full
-            }
-
-            // speed
-            if ((knp = kstat_data_lookup(ksp, "ifspeed")) != NULL)
-                // expressed in bits per sec, we want mega bits per sec
-                speed = (int)knp->value.ui64 / 1000000;
-            else
-                speed = 0;
-
-            // mtu
-            ret = ioctl(sock, SIOCGLIFMTU, &ifr);
-            if (ret == -1)
-                goto error;
-
-            py_ifc_info = Py_BuildValue("(Oiii)", py_is_up, duplex, speed,
-                                        ifr.lifr_mtu);
-            if (!py_ifc_info)
-                goto error;
-            if (PyDict_SetItemString(py_retdict, ksp->ks_name, py_ifc_info))
-                goto error;
-            Py_DECREF(py_ifc_info);
-        }
-    }
-
-    close(sock);
-    kstat_close(kc);
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_is_up);
-    Py_XDECREF(py_ifc_info);
-    Py_DECREF(py_retdict);
-    if (sock != -1)
-        close(sock);
-    if (kc != NULL)
-        kstat_close(kc);
-    PyErr_SetFromErrno(PyExc_OSError);
-    return NULL;
-}
-
-
-/*
- * Return CPU statistics.
- */
-static PyObject *
-psutil_cpu_stats(PyObject *self, PyObject *args) {
-    kstat_ctl_t *kc;
-    kstat_t *ksp;
-    cpu_stat_t cs;
-    unsigned int ctx_switches = 0;
-    unsigned int interrupts = 0;
-    unsigned int traps = 0;
-    unsigned int syscalls = 0;
-
-    kc = kstat_open();
-    if (kc == NULL) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    for (ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) {
-        if (strcmp(ksp->ks_module, "cpu_stat") == 0) {
-            if (kstat_read(kc, ksp, &cs) == -1) {
-                PyErr_SetFromErrno(PyExc_OSError);
-                goto error;
-            }
-            // voluntary + involuntary
-            ctx_switches += cs.cpu_sysinfo.pswitch + cs.cpu_sysinfo.inv_swtch;
-            interrupts += cs.cpu_sysinfo.intr;
-            traps += cs.cpu_sysinfo.trap;
-            syscalls += cs.cpu_sysinfo.syscall;
-        }
-    }
-
-    kstat_close(kc);
-    return Py_BuildValue(
-        "IIII", ctx_switches, interrupts, syscalls, traps);
-
-error:
-    if (kc != NULL)
-        kstat_close(kc);
-    return NULL;
-}
+#include <inet/tcp.h>
+#include <sys/proc.h>
 
+#include "arch/all/init.h"
 
-/*
- * define the psutil C module methods and initialize the module.
- */
-static PyMethodDef
-PsutilMethods[] = {
 
+static PyMethodDef mod_methods[] = {
     // --- process-related functions
-    {"proc_basic_info", psutil_proc_basic_info, METH_VARARGS,
-     "Return process ppid, rss, vms, ctime, nice, nthreads, status and tty"},
-    {"proc_name_and_args", psutil_proc_name_and_args, METH_VARARGS,
-     "Return process name and args."},
-    {"proc_cpu_times", psutil_proc_cpu_times, METH_VARARGS,
-     "Return process user and system CPU times."},
-    {"proc_cred", psutil_proc_cred, METH_VARARGS,
-     "Return process uids/gids."},
-    {"query_process_thread", psutil_proc_query_thread, METH_VARARGS,
-     "Return info about a process thread"},
-    {"proc_memory_maps", psutil_proc_memory_maps, METH_VARARGS,
-     "Return process memory mappings"},
-    {"proc_num_ctx_switches", psutil_proc_num_ctx_switches, METH_VARARGS,
-     "Return the number of context switches performed by process"},
+    {"proc_cpu_num", psutil_proc_cpu_num, METH_VARARGS},
+    {"proc_cpu_times", psutil_proc_cpu_times, METH_VARARGS},
+    {"proc_cred", psutil_proc_cred, METH_VARARGS},
+    {"proc_environ", psutil_proc_environ, METH_VARARGS},
+    {"proc_memory_maps", psutil_proc_memory_maps, METH_VARARGS},
+    {"proc_name_and_args", psutil_proc_name_and_args, METH_VARARGS},
+    {"proc_num_ctx_switches", psutil_proc_num_ctx_switches, METH_VARARGS},
+    {"proc_oneshot", psutil_proc_oneshot, METH_VARARGS},
+    {"proc_page_faults", psutil_proc_page_faults, METH_VARARGS},
+    {"query_process_thread", psutil_proc_query_thread, METH_VARARGS},
 
     // --- system-related functions
-    {"swap_mem", psutil_swap_mem, METH_VARARGS,
-     "Return information about system swap memory."},
-    {"users", psutil_users, METH_VARARGS,
-     "Return currently connected users."},
-    {"disk_partitions", psutil_disk_partitions, METH_VARARGS,
-     "Return disk partitions."},
-    {"per_cpu_times", psutil_per_cpu_times, METH_VARARGS,
-     "Return system per-CPU times."},
-    {"disk_io_counters", psutil_disk_io_counters, METH_VARARGS,
-     "Return a Python dict of tuples for disk I/O statistics."},
-    {"net_io_counters", psutil_net_io_counters, METH_VARARGS,
-     "Return a Python dict of tuples for network I/O statistics."},
-    {"boot_time", psutil_boot_time, METH_VARARGS,
-     "Return system boot time in seconds since the EPOCH."},
-    {"cpu_count_phys", psutil_cpu_count_phys, METH_VARARGS,
-     "Return the number of physical CPUs on the system."},
-    {"net_connections", psutil_net_connections, METH_VARARGS,
-     "Return TCP and UDP syste-wide open connections."},
-    {"net_if_stats", psutil_net_if_stats, METH_VARARGS,
-     "Return NIC stats (isup, duplex, speed, mtu)"},
-    {"cpu_stats", psutil_cpu_stats, METH_VARARGS,
-     "Return CPU statistics"},
+    {"boot_time", psutil_boot_time, METH_VARARGS},
+    {"cpu_count_cores", psutil_cpu_count_cores, METH_VARARGS},
+    {"cpu_stats", psutil_cpu_stats, METH_VARARGS},
+    {"disk_io_counters", psutil_disk_io_counters, METH_VARARGS},
+    {"disk_partitions", psutil_disk_partitions, METH_VARARGS},
+    {"net_connections", psutil_net_connections, METH_VARARGS},
+    {"net_if_stats", psutil_net_if_stats, METH_VARARGS},
+    {"net_io_counters", psutil_net_io_counters, METH_VARARGS},
+    {"per_cpu_times", psutil_per_cpu_times, METH_VARARGS},
+    {"swap_mem", psutil_swap_mem, METH_VARARGS},
+
+    // --- others
+    {"check_pid_range", psutil_check_pid_range, METH_VARARGS},
+    {"set_debug", psutil_set_debug, METH_VARARGS},
 
     {NULL, NULL, 0, NULL}
 };
 
 
-struct module_state {
-    PyObject *error;
-};
-
-#if PY_MAJOR_VERSION >= 3
-#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
+static int
+psutil_add_constants(PyObject *mod) {
+    PSUTIL_ADD_INT(mod, "version", PSUTIL_VERSION);
+    PSUTIL_ADD_INT(mod, "SSLEEP", SSLEEP);
+    PSUTIL_ADD_INT(mod, "SRUN", SRUN);
+    PSUTIL_ADD_INT(mod, "SZOMB", SZOMB);
+    PSUTIL_ADD_INT(mod, "SSTOP", SSTOP);
+    PSUTIL_ADD_INT(mod, "SIDL", SIDL);
+    PSUTIL_ADD_INT(mod, "SONPROC", SONPROC);
+#ifdef SWAIT
+    PSUTIL_ADD_INT(mod, "SWAIT", SWAIT);
 #else
-#define GETSTATE(m) (&_state)
+    // sys/proc.h started defining SWAIT somewhere
+    // after Update 3 and prior to Update 5 included.
+    PSUTIL_ADD_INT(mod, "SWAIT", 0);
 #endif
+    // for process tty
+    PSUTIL_ADD_INT(mod, "PRNODEV", PRNODEV);
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSED", TCPS_CLOSED);
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSING", TCPS_CLOSING);
+    PSUTIL_ADD_INT(mod, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT);
+    PSUTIL_ADD_INT(mod, "TCPS_LISTEN", TCPS_LISTEN);
+    PSUTIL_ADD_INT(mod, "TCPS_ESTABLISHED", TCPS_ESTABLISHED);
+    PSUTIL_ADD_INT(mod, "TCPS_SYN_SENT", TCPS_SYN_SENT);
+    PSUTIL_ADD_INT(mod, "TCPS_SYN_RCVD", TCPS_SYN_RCVD);
+    PSUTIL_ADD_INT(mod, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1);
+    PSUTIL_ADD_INT(mod, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2);
+    PSUTIL_ADD_INT(mod, "TCPS_LAST_ACK", TCPS_LAST_ACK);
+    PSUTIL_ADD_INT(mod, "TCPS_TIME_WAIT", TCPS_TIME_WAIT);
+    // sunos specific
+    PSUTIL_ADD_INT(mod, "TCPS_IDLE", TCPS_IDLE);
+    // sunos specific
+    PSUTIL_ADD_INT(mod, "TCPS_BOUND", TCPS_BOUND);
+    PSUTIL_ADD_INT(mod, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE);
 
-#if PY_MAJOR_VERSION >= 3
-
-static int
-psutil_sunos_traverse(PyObject *m, visitproc visit, void *arg) {
-    Py_VISIT(GETSTATE(m)->error);
     return 0;
 }
 
+
 static int
-psutil_sunos_clear(PyObject *m) {
-    Py_CLEAR(GETSTATE(m)->error);
+psutil_exec(PyObject *mod) {
+    if (psutil_setup() != 0)
+        return -1;
+    if (psutil_posix_add_constants(mod) != 0)
+        return -1;
+    if (psutil_posix_add_methods(mod) != 0)
+        return -1;
+    if (psutil_add_exceptions(mod) != 0)
+        return -1;
+    if (psutil_add_constants(mod) != 0)
+        return -1;
     return 0;
 }
 
-static struct PyModuleDef moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "psutil_sunos",
-    NULL,
-    sizeof(struct module_state),
-    PsutilMethods,
-    NULL,
-    psutil_sunos_traverse,
-    psutil_sunos_clear,
-    NULL
-};
-
-#define INITERROR return NULL
-
-PyMODINIT_FUNC PyInit__psutil_sunos(void)
-
-#else
-#define INITERROR return
-
-void init_psutil_sunos(void)
-#endif
-{
-#if PY_MAJOR_VERSION >= 3
-    PyObject *module = PyModule_Create(&moduledef);
-#else
-    PyObject *module = Py_InitModule("_psutil_sunos", PsutilMethods);
-#endif
-    PyModule_AddIntConstant(module, "version", PSUTIL_VERSION);
-
-    PyModule_AddIntConstant(module, "SSLEEP", SSLEEP);
-    PyModule_AddIntConstant(module, "SRUN", SRUN);
-    PyModule_AddIntConstant(module, "SZOMB", SZOMB);
-    PyModule_AddIntConstant(module, "SSTOP", SSTOP);
-    PyModule_AddIntConstant(module, "SIDL", SIDL);
-    PyModule_AddIntConstant(module, "SONPROC", SONPROC);
-    PyModule_AddIntConstant(module, "SWAIT", SWAIT);
-
-    PyModule_AddIntConstant(module, "PRNODEV", PRNODEV);  // for process tty
-
-    PyModule_AddIntConstant(module, "TCPS_CLOSED", TCPS_CLOSED);
-    PyModule_AddIntConstant(module, "TCPS_CLOSING", TCPS_CLOSING);
-    PyModule_AddIntConstant(module, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT);
-    PyModule_AddIntConstant(module, "TCPS_LISTEN", TCPS_LISTEN);
-    PyModule_AddIntConstant(module, "TCPS_ESTABLISHED", TCPS_ESTABLISHED);
-    PyModule_AddIntConstant(module, "TCPS_SYN_SENT", TCPS_SYN_SENT);
-    PyModule_AddIntConstant(module, "TCPS_SYN_RCVD", TCPS_SYN_RCVD);
-    PyModule_AddIntConstant(module, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1);
-    PyModule_AddIntConstant(module, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2);
-    PyModule_AddIntConstant(module, "TCPS_LAST_ACK", TCPS_LAST_ACK);
-    PyModule_AddIntConstant(module, "TCPS_TIME_WAIT", TCPS_TIME_WAIT);
-    // sunos specific
-    PyModule_AddIntConstant(module, "TCPS_IDLE", TCPS_IDLE);
-    // sunos specific
-    PyModule_AddIntConstant(module, "TCPS_BOUND", TCPS_BOUND);
-    PyModule_AddIntConstant(module, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE);
-
-    if (module == NULL)
-        INITERROR;
-#if PY_MAJOR_VERSION >= 3
-    return module;
-#endif
+PyMODINIT_FUNC
+PyInit__psutil(void) {
+    return psutil_mod_init("_psutil", mod_methods, psutil_exec);
 }
diff --git a/psutil/_psutil_windows.c b/psutil/_psutil_windows.c
index 8b80f27de5..0b01ed429d 100644
--- a/psutil/_psutil_windows.c
+++ b/psutil/_psutil_windows.c
@@ -2,3581 +2,177 @@
  * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
- *
- * Windows platform-specific module methods for _psutil_windows
  */
 
-// Fixes clash between winsock2.h and windows.h
-#define WIN32_LEAN_AND_MEAN
+// Windows module methods.
+//
+// List of undocumented Windows NT APIs which are used in here and in
+// other modules:
+// - NtQuerySystemInformation
+// - NtQueryInformationProcess
+// - NtQueryObject
+// - NtSuspendProcess
+// - NtResumeProcess
 
 #include <Python.h>
 #include <windows.h>
-#include <Psapi.h>
-#include <time.h>
-#include <lm.h>
-#include <WinIoCtl.h>
-#include <tchar.h>
-#include <tlhelp32.h>
-#include <winsock2.h>
-#if (_WIN32_WINNT >= 0x0600) // Windows Vista and above
-#include <ws2tcpip.h>
-#endif
-#include <iphlpapi.h>
-#include <wtsapi32.h>
-#include <Winsvc.h>
 
-// Link with Iphlpapi.lib
-#pragma comment(lib, "IPHLPAPI.lib")
+#include "arch/all/init.h"
+#include "arch/windows/init.h"
 
-#include "_psutil_common.h"
-#include "arch/windows/security.h"
-#include "arch/windows/process_info.h"
-#include "arch/windows/process_handles.h"
-#include "arch/windows/ntextapi.h"
-#include "arch/windows/inet_ntop.h"
-#include "arch/windows/services.h"
-
-#ifdef __MINGW32__
-#include "arch/windows/glpi.h"
-#endif
-
-
-/*
- * ============================================================================
- * Utilities
- * ============================================================================
- */
-
- // a flag for connections without an actual status
-static int PSUTIL_CONN_NONE = 128;
-
-#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
-#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))
-#define LO_T ((float)1e-7)
-#define HI_T (LO_T*4294967296.0)
-#define BYTESWAP_USHORT(x) ((((USHORT)(x) << 8) | ((USHORT)(x) >> 8)) & 0xffff)
-#ifndef AF_INET6
-#define AF_INET6 23
-#endif
-#define _psutil_conn_decref_objs() \
-    Py_DECREF(_AF_INET); \
-    Py_DECREF(_AF_INET6);\
-    Py_DECREF(_SOCK_STREAM);\
-    Py_DECREF(_SOCK_DGRAM);
-
-typedef BOOL (WINAPI *LPFN_GLPI)
-    (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION,  PDWORD);
-
-// fix for mingw32, see
-// https://github.com/giampaolo/psutil/issues/351#c2
-typedef struct _DISK_PERFORMANCE_WIN_2008 {
-    LARGE_INTEGER BytesRead;
-    LARGE_INTEGER BytesWritten;
-    LARGE_INTEGER ReadTime;
-    LARGE_INTEGER WriteTime;
-    LARGE_INTEGER IdleTime;
-    DWORD         ReadCount;
-    DWORD         WriteCount;
-    DWORD         QueueDepth;
-    DWORD         SplitCount;
-    LARGE_INTEGER QueryTime;
-    DWORD         StorageDeviceNumber;
-    WCHAR         StorageManagerName[8];
-} DISK_PERFORMANCE_WIN_2008;
-
-// --- network connections mingw32 support
-#ifndef _IPRTRMIB_H
-#if (_WIN32_WINNT < 0x0600) // Windows XP
-typedef struct _MIB_TCP6ROW_OWNER_PID {
-    UCHAR ucLocalAddr[16];
-    DWORD dwLocalScopeId;
-    DWORD dwLocalPort;
-    UCHAR ucRemoteAddr[16];
-    DWORD dwRemoteScopeId;
-    DWORD dwRemotePort;
-    DWORD dwState;
-    DWORD dwOwningPid;
-} MIB_TCP6ROW_OWNER_PID, *PMIB_TCP6ROW_OWNER_PID;
-
-typedef struct _MIB_TCP6TABLE_OWNER_PID {
-    DWORD dwNumEntries;
-    MIB_TCP6ROW_OWNER_PID table[ANY_SIZE];
-} MIB_TCP6TABLE_OWNER_PID, *PMIB_TCP6TABLE_OWNER_PID;
-#endif
-#endif
-
-#ifndef __IPHLPAPI_H__
-typedef struct in6_addr {
-    union {
-        UCHAR Byte[16];
-        USHORT Word[8];
-    } u;
-} IN6_ADDR, *PIN6_ADDR, FAR *LPIN6_ADDR;
-
-typedef enum _UDP_TABLE_CLASS {
-    UDP_TABLE_BASIC,
-    UDP_TABLE_OWNER_PID,
-    UDP_TABLE_OWNER_MODULE
-} UDP_TABLE_CLASS, *PUDP_TABLE_CLASS;
-
-typedef struct _MIB_UDPROW_OWNER_PID {
-    DWORD dwLocalAddr;
-    DWORD dwLocalPort;
-    DWORD dwOwningPid;
-} MIB_UDPROW_OWNER_PID, *PMIB_UDPROW_OWNER_PID;
-
-typedef struct _MIB_UDPTABLE_OWNER_PID {
-    DWORD dwNumEntries;
-    MIB_UDPROW_OWNER_PID table[ANY_SIZE];
-} MIB_UDPTABLE_OWNER_PID, *PMIB_UDPTABLE_OWNER_PID;
-#endif
-
-#if (_WIN32_WINNT < 0x0600) // Windows XP
-typedef struct _MIB_UDP6ROW_OWNER_PID {
-    UCHAR ucLocalAddr[16];
-    DWORD dwLocalScopeId;
-    DWORD dwLocalPort;
-    DWORD dwOwningPid;
-} MIB_UDP6ROW_OWNER_PID, *PMIB_UDP6ROW_OWNER_PID;
-
-typedef struct _MIB_UDP6TABLE_OWNER_PID {
-    DWORD dwNumEntries;
-    MIB_UDP6ROW_OWNER_PID table[ANY_SIZE];
-} MIB_UDP6TABLE_OWNER_PID, *PMIB_UDP6TABLE_OWNER_PID;
-#endif
-
-PIP_ADAPTER_ADDRESSES
-psutil_get_nic_addresses() {
-    // allocate a 15 KB buffer to start with
-    int outBufLen = 15000;
-    DWORD dwRetVal = 0;
-    ULONG attempts = 0;
-    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
-
-    do {
-        pAddresses = (IP_ADAPTER_ADDRESSES *) malloc(outBufLen);
-        if (pAddresses == NULL) {
-            PyErr_NoMemory();
-            return NULL;
-        }
-
-        dwRetVal = GetAdaptersAddresses(AF_UNSPEC, 0, NULL, pAddresses,
-                                        &outBufLen);
-        if (dwRetVal == ERROR_BUFFER_OVERFLOW) {
-            free(pAddresses);
-            pAddresses = NULL;
-        }
-        else {
-            break;
-        }
-
-        attempts++;
-    } while ((dwRetVal == ERROR_BUFFER_OVERFLOW) && (attempts < 3));
-
-    if (dwRetVal != NO_ERROR) {
-        PyErr_SetString(PyExc_RuntimeError, "GetAdaptersAddresses() failed.");
-        return NULL;
-    }
-
-    return pAddresses;
-}
-
-
-/*
- * ============================================================================
- * Public Python API
- * ============================================================================
- */
-
-
-static ULONGLONG (*psutil_GetTickCount64)(void) = NULL;
-
-/*
- * Return a Python float representing the system uptime expressed in seconds
- * since the epoch.
- */
-static PyObject *
-psutil_boot_time(PyObject *self, PyObject *args) {
-#if (_WIN32_WINNT >= 0x0600)  // Windows Vista
-    ULONGLONG uptime;
-#else
-    double uptime;
-#endif
-    time_t pt;
-    FILETIME fileTime;
-    long long ll;
-    HINSTANCE hKernel32;
-    psutil_GetTickCount64 = NULL;
-
-    GetSystemTimeAsFileTime(&fileTime);
-
-    /*
-    HUGE thanks to:
-    http://johnstewien.spaces.live.com/blog/cns!E6885DB5CEBABBC8!831.entry
-
-    This function converts the FILETIME structure to the 32 bit
-    Unix time structure.
-    The time_t is a 32-bit value for the number of seconds since
-    January 1, 1970. A FILETIME is a 64-bit for the number of
-    100-nanosecond periods since January 1, 1601. Convert by
-    subtracting the number of 100-nanosecond period betwee 01-01-1970
-    and 01-01-1601, from time_t the divide by 1e+7 to get to the same
-    base granularity.
-    */
-    ll = (((LONGLONG)(fileTime.dwHighDateTime)) << 32) \
-        + fileTime.dwLowDateTime;
-    pt = (time_t)((ll - 116444736000000000ull) / 10000000ull);
-
-    // GetTickCount64() is Windows Vista+ only. Dinamically load
-    // GetTickCount64() at runtime. We may have used
-    // "#if (_WIN32_WINNT >= 0x0600)" pre-processor but that way
-    // the produced exe/wheels cannot be used on Windows XP, see:
-    // https://github.com/giampaolo/psutil/issues/811#issuecomment-230639178
-    hKernel32 = GetModuleHandleW(L"KERNEL32");
-    psutil_GetTickCount64 = (void*)GetProcAddress(hKernel32, "GetTickCount64");
-    if (psutil_GetTickCount64 != NULL) {
-        // Windows >= Vista
-        uptime = psutil_GetTickCount64() / (ULONGLONG)1000.00f;
-    }
-    else {
-        // Windows XP.
-        // GetTickCount() time will wrap around to zero if the
-        // system is run continuously for 49.7 days.
-        uptime = GetTickCount() / 1000.00f;
-    }
-
-    return Py_BuildValue("d", (double)pt - (double)uptime);
-}
-
-
-/*
- * Return 1 if PID exists in the current process list, else 0.
- */
-static PyObject *
-psutil_pid_exists(PyObject *self, PyObject *args) {
-    long pid;
-    int status;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    status = psutil_pid_is_running(pid);
-    if (-1 == status)
-        return NULL; // exception raised in psutil_pid_is_running()
-    return PyBool_FromLong(status);
-}
-
-
-/*
- * Return a Python list of all the PIDs running on the system.
- */
-static PyObject *
-psutil_pids(PyObject *self, PyObject *args) {
-    DWORD *proclist = NULL;
-    DWORD numberOfReturnedPIDs;
-    DWORD i;
-    PyObject *py_pid = NULL;
-    PyObject *py_retlist = PyList_New(0);
-
-    if (py_retlist == NULL)
-        return NULL;
-    proclist = psutil_get_pids(&numberOfReturnedPIDs);
-    if (proclist == NULL)
-        goto error;
-
-    for (i = 0; i < numberOfReturnedPIDs; i++) {
-        py_pid = Py_BuildValue("I", proclist[i]);
-        if (!py_pid)
-            goto error;
-        if (PyList_Append(py_retlist, py_pid))
-            goto error;
-        Py_DECREF(py_pid);
-    }
-
-    // free C array allocated for PIDs
-    free(proclist);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_pid);
-    Py_DECREF(py_retlist);
-    if (proclist != NULL)
-        free(proclist);
-    return NULL;
-}
-
-
-/*
- * Kill a process given its PID.
- */
-static PyObject *
-psutil_proc_kill(PyObject *self, PyObject *args) {
-    HANDLE hProcess;
-    long pid;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (pid == 0)
-        return AccessDenied();
-
-    hProcess = OpenProcess(PROCESS_TERMINATE, FALSE, pid);
-    if (hProcess == NULL) {
-        if (GetLastError() == ERROR_INVALID_PARAMETER) {
-            // see https://github.com/giampaolo/psutil/issues/24
-            NoSuchProcess();
-        }
-        else {
-            PyErr_SetFromWindowsErr(0);
-        }
-        return NULL;
-    }
-
-    // kill the process
-    if (! TerminateProcess(hProcess, 0)) {
-        PyErr_SetFromWindowsErr(0);
-        CloseHandle(hProcess);
-        return NULL;
-    }
-
-    CloseHandle(hProcess);
-    Py_RETURN_NONE;
-}
-
-
-/*
- * Wait for process to terminate and return its exit code.
- */
-static PyObject *
-psutil_proc_wait(PyObject *self, PyObject *args) {
-    HANDLE hProcess;
-    DWORD ExitCode;
-    DWORD retVal;
-    long pid;
-    long timeout;
-
-    if (! PyArg_ParseTuple(args, "ll", &pid, &timeout))
-        return NULL;
-    if (pid == 0)
-        return AccessDenied();
-
-    hProcess = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION,
-                           FALSE, pid);
-    if (hProcess == NULL) {
-        if (GetLastError() == ERROR_INVALID_PARAMETER) {
-            // no such process; we do not want to raise NSP but
-            // return None instead.
-            Py_RETURN_NONE;
-        }
-        else {
-            PyErr_SetFromWindowsErr(0);
-            return NULL;
-        }
-    }
-
-    // wait until the process has terminated
-    Py_BEGIN_ALLOW_THREADS
-    retVal = WaitForSingleObject(hProcess, timeout);
-    Py_END_ALLOW_THREADS
-
-    if (retVal == WAIT_FAILED) {
-        CloseHandle(hProcess);
-        return PyErr_SetFromWindowsErr(GetLastError());
-    }
-    if (retVal == WAIT_TIMEOUT) {
-        CloseHandle(hProcess);
-        return Py_BuildValue("l", WAIT_TIMEOUT);
-    }
-
-    // get the exit code; note: subprocess module (erroneously?) uses
-    // what returned by WaitForSingleObject
-    if (GetExitCodeProcess(hProcess, &ExitCode) == 0) {
-        CloseHandle(hProcess);
-        return PyErr_SetFromWindowsErr(GetLastError());
-    }
-    CloseHandle(hProcess);
-#if PY_MAJOR_VERSION >= 3
-    return PyLong_FromLong((long) ExitCode);
-#else
-    return PyInt_FromLong((long) ExitCode);
-#endif
-}
-
-
-/*
- * Return a Python tuple (user_time, kernel_time)
- */
-static PyObject *
-psutil_proc_cpu_times(PyObject *self, PyObject *args) {
-    long        pid;
-    HANDLE      hProcess;
-    FILETIME    ftCreate, ftExit, ftKernel, ftUser;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    hProcess = psutil_handle_from_pid(pid);
-    if (hProcess == NULL)
-        return NULL;
-    if (! GetProcessTimes(hProcess, &ftCreate, &ftExit, &ftKernel, &ftUser)) {
-        CloseHandle(hProcess);
-        if (GetLastError() == ERROR_ACCESS_DENIED) {
-            // usually means the process has died so we throw a NoSuchProcess
-            // here
-            return NoSuchProcess();
-        }
-        else {
-            PyErr_SetFromWindowsErr(0);
-            return NULL;
-        }
-    }
-
-    CloseHandle(hProcess);
-
-    /*
-     * User and kernel times are represented as a FILETIME structure
-     * wich contains a 64-bit value representing the number of
-     * 100-nanosecond intervals since January 1, 1601 (UTC):
-     * http://msdn.microsoft.com/en-us/library/ms724284(VS.85).aspx
-     * To convert it into a float representing the seconds that the
-     * process has executed in user/kernel mode I borrowed the code
-     * below from Python's Modules/posixmodule.c
-     */
-    return Py_BuildValue(
-       "(dd)",
-       (double)(ftUser.dwHighDateTime * 429.4967296 + \
-                ftUser.dwLowDateTime * 1e-7),
-       (double)(ftKernel.dwHighDateTime * 429.4967296 + \
-                ftKernel.dwLowDateTime * 1e-7)
-   );
-}
-
-
-/*
- * Return a Python float indicating the process create time expressed in
- * seconds since the epoch.
- */
-static PyObject *
-psutil_proc_create_time(PyObject *self, PyObject *args) {
-    long        pid;
-    long long   unix_time;
-    DWORD       exitCode;
-    HANDLE      hProcess;
-    BOOL        ret;
-    FILETIME    ftCreate, ftExit, ftKernel, ftUser;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    // special case for PIDs 0 and 4, return system boot time
-    if (0 == pid || 4 == pid)
-        return psutil_boot_time(NULL, NULL);
-
-    hProcess = psutil_handle_from_pid(pid);
-    if (hProcess == NULL)
-        return NULL;
-    if (! GetProcessTimes(hProcess, &ftCreate, &ftExit, &ftKernel, &ftUser)) {
-        CloseHandle(hProcess);
-        if (GetLastError() == ERROR_ACCESS_DENIED) {
-            // usually means the process has died so we throw a
-            // NoSuchProcess here
-            return NoSuchProcess();
-        }
-        else {
-            PyErr_SetFromWindowsErr(0);
-            return NULL;
-        }
-    }
-
-    // Make sure the process is not gone as OpenProcess alone seems to be
-    // unreliable in doing so (it seems a previous call to p.wait() makes
-    // it unreliable).
-    // This check is important as creation time is used to make sure the
-    // process is still running.
-    ret = GetExitCodeProcess(hProcess, &exitCode);
-    CloseHandle(hProcess);
-    if (ret != 0) {
-        if (exitCode != STILL_ACTIVE)
-            return NoSuchProcess();
-    }
-    else {
-        // Ignore access denied as it means the process is still alive.
-        // For all other errors, we want an exception.
-        if (GetLastError() != ERROR_ACCESS_DENIED) {
-            PyErr_SetFromWindowsErr(0);
-            return NULL;
-        }
-    }
-
-    /*
-    Convert the FILETIME structure to a Unix time.
-    It's the best I could find by googling and borrowing code here and there.
-    The time returned has a precision of 1 second.
-    */
-    unix_time = ((LONGLONG)ftCreate.dwHighDateTime) << 32;
-    unix_time += ftCreate.dwLowDateTime - 116444736000000000LL;
-    unix_time /= 10000000;
-    return Py_BuildValue("d", (double)unix_time);
-}
-
-
-
-/*
- * Return the number of logical CPUs.
- */
-static PyObject *
-psutil_cpu_count_logical(PyObject *self, PyObject *args) {
-    SYSTEM_INFO system_info;
-    system_info.dwNumberOfProcessors = 0;
-
-    GetSystemInfo(&system_info);
-    if (system_info.dwNumberOfProcessors == 0)
-        Py_RETURN_NONE;  // mimic os.cpu_count()
-    else
-        return Py_BuildValue("I", system_info.dwNumberOfProcessors);
-}
-
-
-/*
- * Return the number of physical CPU cores.
- */
-static PyObject *
-psutil_cpu_count_phys(PyObject *self, PyObject *args) {
-    LPFN_GLPI glpi;
-    DWORD rc;
-    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION buffer = NULL;
-    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION ptr = NULL;
-    DWORD length = 0;
-    DWORD offset = 0;
-    int ncpus = 0;
-
-    glpi = (LPFN_GLPI)GetProcAddress(GetModuleHandle(TEXT("kernel32")),
-                                     "GetLogicalProcessorInformation");
-    if (glpi == NULL)
-        goto return_none;
-
-    while (1) {
-        rc = glpi(buffer, &length);
-        if (rc == FALSE) {
-            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
-                if (buffer)
-                    free(buffer);
-                buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION)malloc(
-                    length);
-                if (NULL == buffer) {
-                    PyErr_NoMemory();
-                    return NULL;
-                }
-            }
-            else {
-                goto return_none;
-            }
-        }
-        else {
-            break;
-        }
-    }
-
-    ptr = buffer;
-    while (offset + sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION) <= length) {
-        if (ptr->Relationship == RelationProcessorCore)
-            ncpus += 1;
-        offset += sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
-        ptr++;
-    }
-
-    free(buffer);
-    if (ncpus == 0)
-        goto return_none;
-    else
-        return Py_BuildValue("i", ncpus);
-
-return_none:
-    // mimic os.cpu_count()
-    if (buffer != NULL)
-        free(buffer);
-    Py_RETURN_NONE;
-}
-
-
-/*
- * Return process cmdline as a Python list of cmdline arguments.
- */
-static PyObject *
-psutil_proc_cmdline(PyObject *self, PyObject *args) {
-    long pid;
-    int pid_return;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if ((pid == 0) || (pid == 4))
-        return Py_BuildValue("[]");
-
-    pid_return = psutil_pid_is_running(pid);
-    if (pid_return == 0)
-        return NoSuchProcess();
-    if (pid_return == -1)
-        return NULL;
-
-    return psutil_get_cmdline(pid);
-}
-
-
-/*
- * Return process cmdline as a Python list of cmdline arguments.
- */
-static PyObject *
-psutil_proc_environ(PyObject *self, PyObject *args) {
-    long pid;
-    int pid_return;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if ((pid == 0) || (pid == 4))
-        return Py_BuildValue("s", "");
-
-    pid_return = psutil_pid_is_running(pid);
-    if (pid_return == 0)
-        return NoSuchProcess();
-    if (pid_return == -1)
-        return NULL;
-
-    return psutil_get_environ(pid);
-}
-
-
-/*
- * Return process executable path.
- */
-static PyObject *
-psutil_proc_exe(PyObject *self, PyObject *args) {
-    long pid;
-    HANDLE hProcess;
-    wchar_t exe[MAX_PATH];
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    hProcess = psutil_handle_from_pid_waccess(pid, PROCESS_QUERY_INFORMATION);
-    if (NULL == hProcess)
-        return NULL;
-    if (GetProcessImageFileNameW(hProcess, exe, MAX_PATH) == 0) {
-        CloseHandle(hProcess);
-        PyErr_SetFromWindowsErr(0);
-        return NULL;
-    }
-    CloseHandle(hProcess);
-    return Py_BuildValue("u", exe);
-}
-
-
-/*
- * Return process base name.
- * Note: psutil_proc_exe() is attempted first because it's faster
- * but it raise AccessDenied for processes owned by other users
- * in which case we fall back on using this.
- */
-static PyObject *
-psutil_proc_name(PyObject *self, PyObject *args) {
-    long pid;
-    int ok;
-    PROCESSENTRY32W pentry;
-    HANDLE hSnapShot;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, pid);
-    if (hSnapShot == INVALID_HANDLE_VALUE) {
-        PyErr_SetFromWindowsErr(0);
-        return NULL;
-    }
-    pentry.dwSize = sizeof(PROCESSENTRY32W);
-    ok = Process32FirstW(hSnapShot, &pentry);
-    if (! ok) {
-        CloseHandle(hSnapShot);
-        PyErr_SetFromWindowsErr(0);
-        return NULL;
-    }
-    while (ok) {
-        if (pentry.th32ProcessID == pid) {
-            CloseHandle(hSnapShot);
-            return PyUnicode_FromWideChar(
-                pentry.szExeFile, wcslen(pentry.szExeFile));
-        }
-        ok = Process32NextW(hSnapShot, &pentry);
-    }
-
-    CloseHandle(hSnapShot);
-    NoSuchProcess();
-    return NULL;
-}
-
-
-/*
- * Return process memory information as a Python tuple.
- */
-static PyObject *
-psutil_proc_memory_info(PyObject *self, PyObject *args) {
-    HANDLE hProcess;
-    DWORD pid;
-#if (_WIN32_WINNT >= 0x0501)  // Windows XP with SP2
-    PROCESS_MEMORY_COUNTERS_EX cnt;
-#else
-    PROCESS_MEMORY_COUNTERS cnt;
-#endif
-    SIZE_T private = 0;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    hProcess = psutil_handle_from_pid(pid);
-    if (NULL == hProcess)
-        return NULL;
-
-    if (! GetProcessMemoryInfo(hProcess, (PPROCESS_MEMORY_COUNTERS)&cnt,
-                               sizeof(cnt))) {
-        CloseHandle(hProcess);
-        return PyErr_SetFromWindowsErr(0);
-    }
-
-#if (_WIN32_WINNT >= 0x0501)  // Windows XP with SP2
-    private = cnt.PrivateUsage;
-#endif
-
-    CloseHandle(hProcess);
-
-    // PROCESS_MEMORY_COUNTERS values are defined as SIZE_T which on 64bits
-    // is an (unsigned long long) and on 32bits is an (unsigned int).
-    // "_WIN64" is defined if we're running a 64bit Python interpreter not
-    // exclusively if the *system* is 64bit.
-#if defined(_WIN64)
-    return Py_BuildValue(
-        "(kKKKKKKKKK)",
-        cnt.PageFaultCount,  // unsigned long
-        (unsigned long long)cnt.PeakWorkingSetSize,
-        (unsigned long long)cnt.WorkingSetSize,
-        (unsigned long long)cnt.QuotaPeakPagedPoolUsage,
-        (unsigned long long)cnt.QuotaPagedPoolUsage,
-        (unsigned long long)cnt.QuotaPeakNonPagedPoolUsage,
-        (unsigned long long)cnt.QuotaNonPagedPoolUsage,
-        (unsigned long long)cnt.PagefileUsage,
-        (unsigned long long)cnt.PeakPagefileUsage,
-        (unsigned long long)private);
-#else
-    return Py_BuildValue(
-        "(kIIIIIIIII)",
-        cnt.PageFaultCount,    // unsigned long
-        (unsigned int)cnt.PeakWorkingSetSize,
-        (unsigned int)cnt.WorkingSetSize,
-        (unsigned int)cnt.QuotaPeakPagedPoolUsage,
-        (unsigned int)cnt.QuotaPagedPoolUsage,
-        (unsigned int)cnt.QuotaPeakNonPagedPoolUsage,
-        (unsigned int)cnt.QuotaNonPagedPoolUsage,
-        (unsigned int)cnt.PagefileUsage,
-        (unsigned int)cnt.PeakPagefileUsage,
-        (unsigned int)private);
-#endif
-}
-
-
-/*
- * Alternative implementation of the one above but bypasses ACCESS DENIED.
- */
-static PyObject *
-psutil_proc_memory_info_2(PyObject *self, PyObject *args) {
-    DWORD pid;
-    PSYSTEM_PROCESS_INFORMATION process;
-    PVOID buffer;
-    SIZE_T private;
-    unsigned long pfault_count;
-
-#if defined(_WIN64)
-    unsigned long long m1, m2, m3, m4, m5, m6, m7, m8;
-#else
-    unsigned int m1, m2, m3, m4, m5, m6, m7, m8;
-#endif
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (! psutil_get_proc_info(pid, &process, &buffer))
-        return NULL;
-
-#if (_WIN32_WINNT >= 0x0501)  // Windows XP with SP2
-    private = process->PrivatePageCount;
-#else
-    private = 0;
-#endif
-    pfault_count = process->PageFaultCount;
-
-    m1 = process->PeakWorkingSetSize;
-    m2 = process->WorkingSetSize;
-    m3 = process->QuotaPeakPagedPoolUsage;
-    m4 = process->QuotaPagedPoolUsage;
-    m5 = process->QuotaPeakNonPagedPoolUsage;
-    m6 = process->QuotaNonPagedPoolUsage;
-    m7 = process->PagefileUsage;
-    m8 = process->PeakPagefileUsage;
-
-    free(buffer);
-
-    // SYSTEM_PROCESS_INFORMATION values are defined as SIZE_T which on 64
-    // bits is an (unsigned long long) and on 32bits is an (unsigned int).
-    // "_WIN64" is defined if we're running a 64bit Python interpreter not
-    // exclusively if the *system* is 64bit.
-#if defined(_WIN64)
-    return Py_BuildValue("(kKKKKKKKKK)",
-#else
-    return Py_BuildValue("(kIIIIIIIII)",
-#endif
-        pfault_count, m1, m2, m3, m4, m5, m6, m7, m8, private);
-}
-
-/**
- * Returns the USS of the process.
- * Reference:
- * https://dxr.mozilla.org/mozilla-central/source/xpcom/base/
- *     nsMemoryReporterManager.cpp
- */
-static PyObject *
-psutil_proc_memory_uss(PyObject *self, PyObject *args)
-{
-    DWORD pid;
-    HANDLE proc;
-    PSAPI_WORKING_SET_INFORMATION tmp;
-    DWORD tmp_size = sizeof(tmp);
-    size_t entries;
-    size_t private_pages;
-    size_t i;
-    DWORD info_array_size;
-    PSAPI_WORKING_SET_INFORMATION* info_array;
-    SYSTEM_INFO system_info;
-    PyObject* py_result = NULL;
-    unsigned long long total = 0;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    proc = psutil_handle_from_pid(pid);
-    if (proc == NULL)
-        return NULL;
-
-    // Determine how many entries we need.
-    memset(&tmp, 0, tmp_size);
-    if (!QueryWorkingSet(proc, &tmp, tmp_size)) {
-        // NB: QueryWorkingSet is expected to fail here due to the
-        // buffer being too small.
-        if (tmp.NumberOfEntries == 0) {
-            PyErr_SetFromWindowsErr(0);
-            goto done;
-        }
-    }
-
-    // Fudge the size in case new entries are added between calls.
-    entries = tmp.NumberOfEntries * 2;
-
-    if (!entries) {
-        goto done;
-    }
-
-    info_array_size = tmp_size + (entries * sizeof(PSAPI_WORKING_SET_BLOCK));
-    info_array = (PSAPI_WORKING_SET_INFORMATION*)malloc(info_array_size);
-    if (!info_array) {
-        PyErr_NoMemory();
-        goto done;
-    }
-
-    if (!QueryWorkingSet(proc, info_array, info_array_size)) {
-        PyErr_SetFromWindowsErr(0);
-        goto done;
-    }
-
-    entries = (size_t)info_array->NumberOfEntries;
-    private_pages = 0;
-    for (i = 0; i < entries; i++) {
-        // Count shared pages that only one process is using as private.
-        if (!info_array->WorkingSetInfo[i].Shared ||
-                info_array->WorkingSetInfo[i].ShareCount <= 1) {
-            private_pages++;
-        }
-    }
-
-    // GetSystemInfo has no return value.
-    GetSystemInfo(&system_info);
-    total = private_pages * system_info.dwPageSize;
-    py_result = Py_BuildValue("K", total);
-
-done:
-    if (proc) {
-        CloseHandle(proc);
-    }
-
-    if (info_array) {
-        free(info_array);
-    }
-
-    return py_result;
-}
-
-
-/*
- * Return a Python integer indicating the total amount of physical memory
- * in bytes.
- */
-static PyObject *
-psutil_virtual_mem(PyObject *self, PyObject *args) {
-    MEMORYSTATUSEX memInfo;
-    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
-
-    if (! GlobalMemoryStatusEx(&memInfo))
-        return PyErr_SetFromWindowsErr(0);
-    return Py_BuildValue("(LLLLLL)",
-                         memInfo.ullTotalPhys,      // total
-                         memInfo.ullAvailPhys,      // avail
-                         memInfo.ullTotalPageFile,  // total page file
-                         memInfo.ullAvailPageFile,  // avail page file
-                         memInfo.ullTotalVirtual,   // total virtual
-                         memInfo.ullAvailVirtual);  // avail virtual
-}
-
-
-/*
- * Retrieves system CPU timing information as a (user, system, idle)
- * tuple. On a multiprocessor system, the values returned are the
- * sum of the designated times across all processors.
- */
-static PyObject *
-psutil_cpu_times(PyObject *self, PyObject *args) {
-    float idle, kernel, user, system;
-    FILETIME idle_time, kernel_time, user_time;
-
-    if (!GetSystemTimes(&idle_time, &kernel_time, &user_time))
-        return PyErr_SetFromWindowsErr(0);
-
-    idle = (float)((HI_T * idle_time.dwHighDateTime) + \
-                   (LO_T * idle_time.dwLowDateTime));
-    user = (float)((HI_T * user_time.dwHighDateTime) + \
-                   (LO_T * user_time.dwLowDateTime));
-    kernel = (float)((HI_T * kernel_time.dwHighDateTime) + \
-                     (LO_T * kernel_time.dwLowDateTime));
-
-    // Kernel time includes idle time.
-    // We return only busy kernel time subtracting idle time from
-    // kernel time.
-    system = (kernel - idle);
-    return Py_BuildValue("(fff)", user, system, idle);
-}
-
-
-/*
- * Same as above but for all system CPUs.
- */
-static PyObject *
-psutil_per_cpu_times(PyObject *self, PyObject *args) {
-    // NtQuerySystemInformation stuff
-    typedef DWORD (_stdcall * NTQSI_PROC) (int, PVOID, ULONG, PULONG);
-    NTQSI_PROC NtQuerySystemInformation;
-    HINSTANCE hNtDll;
-
-    float idle, kernel, systemt, user, interrupt, dpc;
-    NTSTATUS status;
-    _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *sppi = NULL;
-    SYSTEM_INFO si;
-    UINT i;
-    PyObject *py_tuple = NULL;
-    PyObject *py_retlist = PyList_New(0);
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    // obtain NtQuerySystemInformation
-    hNtDll = LoadLibrary(TEXT("ntdll.dll"));
-    if (hNtDll == NULL) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-    NtQuerySystemInformation = (NTQSI_PROC)GetProcAddress(
-        hNtDll, "NtQuerySystemInformation");
-    if (NtQuerySystemInformation == NULL) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    // retrives number of processors
-    GetSystemInfo(&si);
-
-    // allocates an array of _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
-    // structures, one per processor
-    sppi = (_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *) \
-           malloc(si.dwNumberOfProcessors * \
-                  sizeof(_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION));
-    if (sppi == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    // gets cpu time informations
-    status = NtQuerySystemInformation(
-        SystemProcessorPerformanceInformation,
-        sppi,
-        si.dwNumberOfProcessors * sizeof
-            (_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION),
-        NULL);
-    if (status != 0) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    // computes system global times summing each
-    // processor value
-    idle = user = kernel = interrupt = dpc = 0;
-    for (i = 0; i < si.dwNumberOfProcessors; i++) {
-        py_tuple = NULL;
-        user = (float)((HI_T * sppi[i].UserTime.HighPart) +
-                       (LO_T * sppi[i].UserTime.LowPart));
-        idle = (float)((HI_T * sppi[i].IdleTime.HighPart) +
-                       (LO_T * sppi[i].IdleTime.LowPart));
-        kernel = (float)((HI_T * sppi[i].KernelTime.HighPart) +
-                         (LO_T * sppi[i].KernelTime.LowPart));
-        interrupt = (float)((HI_T * sppi[i].InterruptTime.HighPart) +
-                            (LO_T * sppi[i].InterruptTime.LowPart));
-        dpc = (float)((HI_T * sppi[i].DpcTime.HighPart) +
-                      (LO_T * sppi[i].DpcTime.LowPart));
-
-        // kernel time includes idle time on windows
-        // we return only busy kernel time subtracting
-        // idle time from kernel time
-        systemt = kernel - idle;
-        py_tuple = Py_BuildValue(
-            "(ddddd)",
-            user,
-            systemt,
-            idle,
-            interrupt,
-            dpc
-        );
-        if (!py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-
-    free(sppi);
-    FreeLibrary(hNtDll);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (sppi)
-        free(sppi);
-    if (hNtDll)
-        FreeLibrary(hNtDll);
-    return NULL;
-}
-
-
-/*
- * Return process current working directory as a Python string.
- */
-
-static PyObject *
-psutil_proc_cwd(PyObject *self, PyObject *args) {
-    long pid;
-    int pid_return;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    pid_return = psutil_pid_is_running(pid);
-    if (pid_return == 0)
-        return NoSuchProcess();
-    if (pid_return == -1)
-        return NULL;
-
-    return psutil_get_cwd(pid);
-}
-
-
-/*
- * Resume or suspends a process
- */
-int
-psutil_proc_suspend_or_resume(DWORD pid, int suspend) {
-    // a huge thanks to http://www.codeproject.com/KB/threads/pausep.aspx
-    HANDLE hThreadSnap = NULL;
-    THREADENTRY32  te32 = {0};
-
-    if (pid == 0) {
-        AccessDenied();
-        return FALSE;
-    }
-
-    hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
-    if (hThreadSnap == INVALID_HANDLE_VALUE) {
-        PyErr_SetFromWindowsErr(0);
-        return FALSE;
-    }
-
-    // Fill in the size of the structure before using it
-    te32.dwSize = sizeof(THREADENTRY32);
-
-    if (! Thread32First(hThreadSnap, &te32)) {
-        PyErr_SetFromWindowsErr(0);
-        CloseHandle(hThreadSnap);
-        return FALSE;
-    }
-
-    // Walk the thread snapshot to find all threads of the process.
-    // If the thread belongs to the process, add its information
-    // to the display list.
-    do
-    {
-        if (te32.th32OwnerProcessID == pid)
-        {
-            HANDLE hThread = OpenThread(THREAD_SUSPEND_RESUME, FALSE,
-                                        te32.th32ThreadID);
-            if (hThread == NULL) {
-                PyErr_SetFromWindowsErr(0);
-                CloseHandle(hThread);
-                CloseHandle(hThreadSnap);
-                return FALSE;
-            }
-            if (suspend == 1)
-            {
-                if (SuspendThread(hThread) == (DWORD) - 1) {
-                    PyErr_SetFromWindowsErr(0);
-                    CloseHandle(hThread);
-                    CloseHandle(hThreadSnap);
-                    return FALSE;
-                }
-            }
-            else
-            {
-                if (ResumeThread(hThread) == (DWORD) - 1) {
-                    PyErr_SetFromWindowsErr(0);
-                    CloseHandle(hThread);
-                    CloseHandle(hThreadSnap);
-                    return FALSE;
-                }
-            }
-            CloseHandle(hThread);
-        }
-    } while (Thread32Next(hThreadSnap, &te32));
-
-    CloseHandle(hThreadSnap);
-    return TRUE;
-}
-
-
-static PyObject *
-psutil_proc_suspend(PyObject *self, PyObject *args) {
-    long pid;
-    int suspend = 1;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (! psutil_proc_suspend_or_resume(pid, suspend))
-        return NULL;
-    Py_RETURN_NONE;
-}
-
-
-static PyObject *
-psutil_proc_resume(PyObject *self, PyObject *args) {
-    long pid;
-    int suspend = 0;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (! psutil_proc_suspend_or_resume(pid, suspend))
-        return NULL;
-    Py_RETURN_NONE;
-}
-
-
-static PyObject *
-psutil_proc_threads(PyObject *self, PyObject *args) {
-    HANDLE hThread;
-    THREADENTRY32 te32 = {0};
-    long pid;
-    int pid_return;
-    int rc;
-    FILETIME ftDummy, ftKernel, ftUser;
-    HANDLE hThreadSnap = NULL;
-    PyObject *py_tuple = NULL;
-    PyObject *py_retlist = PyList_New(0);
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-    if (pid == 0) {
-        // raise AD instead of returning 0 as procexp is able to
-        // retrieve useful information somehow
-        AccessDenied();
-        goto error;
-    }
-
-    pid_return = psutil_pid_is_running(pid);
-    if (pid_return == 0) {
-        NoSuchProcess();
-        goto error;
-    }
-    if (pid_return == -1)
-        goto error;
-
-    hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
-    if (hThreadSnap == INVALID_HANDLE_VALUE) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    // Fill in the size of the structure before using it
-    te32.dwSize = sizeof(THREADENTRY32);
-
-    if (! Thread32First(hThreadSnap, &te32)) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    // Walk the thread snapshot to find all threads of the process.
-    // If the thread belongs to the process, increase the counter.
-    do {
-        if (te32.th32OwnerProcessID == pid) {
-            py_tuple = NULL;
-            hThread = NULL;
-            hThread = OpenThread(THREAD_QUERY_INFORMATION,
-                                 FALSE, te32.th32ThreadID);
-            if (hThread == NULL) {
-                // thread has disappeared on us
-                continue;
-            }
-
-            rc = GetThreadTimes(hThread, &ftDummy, &ftDummy, &ftKernel,
-                                &ftUser);
-            if (rc == 0) {
-                PyErr_SetFromWindowsErr(0);
-                goto error;
-            }
-
-            /*
-             * User and kernel times are represented as a FILETIME structure
-             * wich contains a 64-bit value representing the number of
-             * 100-nanosecond intervals since January 1, 1601 (UTC):
-             * http://msdn.microsoft.com/en-us/library/ms724284(VS.85).aspx
-             * To convert it into a float representing the seconds that the
-             * process has executed in user/kernel mode I borrowed the code
-             * below from Python's Modules/posixmodule.c
-             */
-            py_tuple = Py_BuildValue(
-                "kdd",
-                te32.th32ThreadID,
-                (double)(ftUser.dwHighDateTime * 429.4967296 + \
-                         ftUser.dwLowDateTime * 1e-7),
-                (double)(ftKernel.dwHighDateTime * 429.4967296 + \
-                         ftKernel.dwLowDateTime * 1e-7));
-            if (!py_tuple)
-                goto error;
-            if (PyList_Append(py_retlist, py_tuple))
-                goto error;
-            Py_DECREF(py_tuple);
-
-            CloseHandle(hThread);
-        }
-    } while (Thread32Next(hThreadSnap, &te32));
-
-    CloseHandle(hThreadSnap);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (hThread != NULL)
-        CloseHandle(hThread);
-    if (hThreadSnap != NULL)
-        CloseHandle(hThreadSnap);
-    return NULL;
-}
-
-
-static PyObject *
-psutil_proc_open_files(PyObject *self, PyObject *args) {
-    long       pid;
-    HANDLE     processHandle;
-    DWORD      access = PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION;
-    PyObject  *py_retlist;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    processHandle = psutil_handle_from_pid_waccess(pid, access);
-    if (processHandle == NULL)
-        return NULL;
-    py_retlist = psutil_get_open_files(pid, processHandle);
-    CloseHandle(processHandle);
-    if (py_retlist == NULL)
-        return PyErr_SetFromWindowsErr(0);
-    return py_retlist;
-}
-
-
-/*
- Accept a filename's drive in native  format like "\Device\HarddiskVolume1\"
- and return the corresponding drive letter (e.g. "C:\\").
- If no match is found return an empty string.
-*/
-static PyObject *
-psutil_win32_QueryDosDevice(PyObject *self, PyObject *args) {
-    LPCTSTR   lpDevicePath;
-    TCHAR d = TEXT('A');
-    TCHAR     szBuff[5];
-
-    if (!PyArg_ParseTuple(args, "s", &lpDevicePath))
-        return NULL;
-
-    while (d <= TEXT('Z')) {
-        TCHAR szDeviceName[3] = {d, TEXT(':'), TEXT('\0')};
-        TCHAR szTarget[512] = {0};
-        if (QueryDosDevice(szDeviceName, szTarget, 511) != 0) {
-            if (_tcscmp(lpDevicePath, szTarget) == 0) {
-                _stprintf_s(szBuff, _countof(szBuff), TEXT("%c:"), d);
-                return Py_BuildValue("s", szBuff);
-            }
-        }
-        d++;
-    }
-    return Py_BuildValue("s", "");
-}
-
-
-/*
- * Return process username as a "DOMAIN//USERNAME" string.
- */
-static PyObject *
-psutil_proc_username(PyObject *self, PyObject *args) {
-    long pid;
-    HANDLE processHandle;
-    HANDLE tokenHandle;
-    PTOKEN_USER user;
-    ULONG bufferSize;
-    PTSTR name;
-    ULONG nameSize;
-    PTSTR domainName;
-    ULONG domainNameSize;
-    SID_NAME_USE nameUse;
-    PTSTR fullName;
-    PyObject *py_unicode;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    processHandle = psutil_handle_from_pid_waccess(
-        pid, PROCESS_QUERY_INFORMATION);
-    if (processHandle == NULL)
-        return NULL;
-
-    if (!OpenProcessToken(processHandle, TOKEN_QUERY, &tokenHandle)) {
-        CloseHandle(processHandle);
-        return PyErr_SetFromWindowsErr(0);
-    }
-
-    CloseHandle(processHandle);
-
-    // Get the user SID.
-
-    bufferSize = 0x100;
-    user = malloc(bufferSize);
-    if (user == NULL)
-        return PyErr_NoMemory();
-
-    if (!GetTokenInformation(tokenHandle, TokenUser, user, bufferSize,
-                             &bufferSize))
-    {
-        free(user);
-        user = malloc(bufferSize);
-        if (user == NULL) {
-            CloseHandle(tokenHandle);
-            return PyErr_NoMemory();
-        }
-        if (!GetTokenInformation(tokenHandle, TokenUser, user, bufferSize,
-                                 &bufferSize))
-        {
-            free(user);
-            CloseHandle(tokenHandle);
-            return PyErr_SetFromWindowsErr(0);
-        }
-    }
-
-    CloseHandle(tokenHandle);
-
-    // resolve the SID to a name
-    nameSize = 0x100;
-    domainNameSize = 0x100;
-
-    name = malloc(nameSize * sizeof(TCHAR));
-    if (name == NULL)
-        return PyErr_NoMemory();
-    domainName = malloc(domainNameSize * sizeof(TCHAR));
-    if (domainName == NULL)
-        return PyErr_NoMemory();
-
-    if (!LookupAccountSid(NULL, user->User.Sid, name, &nameSize, domainName,
-                          &domainNameSize, &nameUse))
-    {
-        free(name);
-        free(domainName);
-        name = malloc(nameSize * sizeof(TCHAR));
-        if (name == NULL)
-            return PyErr_NoMemory();
-        domainName = malloc(domainNameSize * sizeof(TCHAR));
-        if (domainName == NULL)
-            return PyErr_NoMemory();
-        if (!LookupAccountSid(NULL, user->User.Sid, name, &nameSize,
-                              domainName, &domainNameSize, &nameUse))
-        {
-            free(name);
-            free(domainName);
-            free(user);
-
-            return PyErr_SetFromWindowsErr(0);
-        }
-    }
-
-    nameSize = _tcslen(name);
-    domainNameSize = _tcslen(domainName);
-
-    // build the full username string
-    fullName = malloc((domainNameSize + 1 + nameSize + 1) * sizeof(TCHAR));
-    if (fullName == NULL) {
-        free(name);
-        free(domainName);
-        free(user);
-        return PyErr_NoMemory();
-    }
-    memcpy(fullName, domainName, domainNameSize);
-    fullName[domainNameSize] = '\\';
-    memcpy(&fullName[domainNameSize + 1], name, nameSize);
-    fullName[domainNameSize + 1 + nameSize] = '\0';
-
-    py_unicode = PyUnicode_Decode(
-        fullName, _tcslen(fullName), Py_FileSystemDefaultEncoding, "replace");
-
-    free(fullName);
-    free(name);
-    free(domainName);
-    free(user);
-
-    return py_unicode;
-}
-
-
-/*
- * Return a list of network connections opened by a process
- */
-static PyObject *
-psutil_net_connections(PyObject *self, PyObject *args) {
-    static long null_address[4] = { 0, 0, 0, 0 };
-    unsigned long pid;
-    typedef PSTR (NTAPI * _RtlIpv4AddressToStringA)(struct in_addr *, PSTR);
-    _RtlIpv4AddressToStringA rtlIpv4AddressToStringA;
-    typedef PSTR (NTAPI * _RtlIpv6AddressToStringA)(struct in6_addr *, PSTR);
-    _RtlIpv6AddressToStringA rtlIpv6AddressToStringA;
-    typedef DWORD (WINAPI * _GetExtendedTcpTable)(PVOID, PDWORD, BOOL, ULONG,
-                                                  TCP_TABLE_CLASS, ULONG);
-    _GetExtendedTcpTable getExtendedTcpTable;
-    typedef DWORD (WINAPI * _GetExtendedUdpTable)(PVOID, PDWORD, BOOL, ULONG,
-                                                  UDP_TABLE_CLASS, ULONG);
-    _GetExtendedUdpTable getExtendedUdpTable;
-    PVOID table = NULL;
-    DWORD tableSize;
-    PMIB_TCPTABLE_OWNER_PID tcp4Table;
-    PMIB_UDPTABLE_OWNER_PID udp4Table;
-    PMIB_TCP6TABLE_OWNER_PID tcp6Table;
-    PMIB_UDP6TABLE_OWNER_PID udp6Table;
-    ULONG i;
-    CHAR addressBufferLocal[65];
-    CHAR addressBufferRemote[65];
-
-    PyObject *py_retlist;
-    PyObject *py_conn_tuple = NULL;
-    PyObject *py_af_filter = NULL;
-    PyObject *py_type_filter = NULL;
-    PyObject *py_addr_tuple_local = NULL;
-    PyObject *py_addr_tuple_remote = NULL;
-    PyObject *_AF_INET = PyLong_FromLong((long)AF_INET);
-    PyObject *_AF_INET6 = PyLong_FromLong((long)AF_INET6);
-    PyObject *_SOCK_STREAM = PyLong_FromLong((long)SOCK_STREAM);
-    PyObject *_SOCK_DGRAM = PyLong_FromLong((long)SOCK_DGRAM);
-
-    if (! PyArg_ParseTuple(args, "lOO", &pid, &py_af_filter, &py_type_filter))
-    {
-        _psutil_conn_decref_objs();
-        return NULL;
-    }
-
-    if (!PySequence_Check(py_af_filter) || !PySequence_Check(py_type_filter)) {
-        _psutil_conn_decref_objs();
-        PyErr_SetString(PyExc_TypeError, "arg 2 or 3 is not a sequence");
-        return NULL;
-    }
-
-    if (pid != -1) {
-        if (psutil_pid_is_running(pid) == 0) {
-            _psutil_conn_decref_objs();
-            return NoSuchProcess();
-        }
-    }
-
-    // Import some functions.
-    {
-        HMODULE ntdll;
-        HMODULE iphlpapi;
-
-        ntdll = LoadLibrary(TEXT("ntdll.dll"));
-        rtlIpv4AddressToStringA = (_RtlIpv4AddressToStringA)GetProcAddress(
-                                   ntdll, "RtlIpv4AddressToStringA");
-        rtlIpv6AddressToStringA = (_RtlIpv6AddressToStringA)GetProcAddress(
-                                   ntdll, "RtlIpv6AddressToStringA");
-        /* TODO: Check these two function pointers */
-
-        iphlpapi = LoadLibrary(TEXT("iphlpapi.dll"));
-        getExtendedTcpTable = (_GetExtendedTcpTable)GetProcAddress(iphlpapi,
-                              "GetExtendedTcpTable");
-        getExtendedUdpTable = (_GetExtendedUdpTable)GetProcAddress(iphlpapi,
-                              "GetExtendedUdpTable");
-        FreeLibrary(ntdll);
-        FreeLibrary(iphlpapi);
-    }
-
-    if ((getExtendedTcpTable == NULL) || (getExtendedUdpTable == NULL)) {
-        PyErr_SetString(PyExc_NotImplementedError,
-                        "feature not supported on this Windows version");
-        _psutil_conn_decref_objs();
-        return NULL;
-    }
-
-    py_retlist = PyList_New(0);
-    if (py_retlist == NULL) {
-        _psutil_conn_decref_objs();
-        return NULL;
-    }
-
-    // TCP IPv4
-
-    if ((PySequence_Contains(py_af_filter, _AF_INET) == 1) &&
-            (PySequence_Contains(py_type_filter, _SOCK_STREAM) == 1))
-    {
-        table = NULL;
-        py_conn_tuple = NULL;
-        py_addr_tuple_local = NULL;
-        py_addr_tuple_remote = NULL;
-        tableSize = 0;
-        getExtendedTcpTable(NULL, &tableSize, FALSE, AF_INET,
-                            TCP_TABLE_OWNER_PID_ALL, 0);
-
-        table = malloc(tableSize);
-        if (table == NULL) {
-            PyErr_NoMemory();
-            goto error;
-        }
-
-        if (getExtendedTcpTable(table, &tableSize, FALSE, AF_INET,
-                                TCP_TABLE_OWNER_PID_ALL, 0) == 0)
-        {
-            tcp4Table = table;
-
-            for (i = 0; i < tcp4Table->dwNumEntries; i++)
-            {
-                if (pid != -1) {
-                    if (tcp4Table->table[i].dwOwningPid != pid) {
-                        continue;
-                    }
-                }
-
-                if (tcp4Table->table[i].dwLocalAddr != 0 ||
-                        tcp4Table->table[i].dwLocalPort != 0)
-                {
-                    struct in_addr addr;
-
-                    addr.S_un.S_addr = tcp4Table->table[i].dwLocalAddr;
-                    rtlIpv4AddressToStringA(&addr, addressBufferLocal);
-                    py_addr_tuple_local = Py_BuildValue(
-                        "(si)",
-                        addressBufferLocal,
-                        BYTESWAP_USHORT(tcp4Table->table[i].dwLocalPort));
-                }
-                else {
-                    py_addr_tuple_local = PyTuple_New(0);
-                }
-
-                if (py_addr_tuple_local == NULL)
-                    goto error;
-
-                // On Windows <= XP, remote addr is filled even if socket
-                // is in LISTEN mode in which case we just ignore it.
-                if ((tcp4Table->table[i].dwRemoteAddr != 0 ||
-                        tcp4Table->table[i].dwRemotePort != 0) &&
-                        (tcp4Table->table[i].dwState != MIB_TCP_STATE_LISTEN))
-                {
-                    struct in_addr addr;
-
-                    addr.S_un.S_addr = tcp4Table->table[i].dwRemoteAddr;
-                    rtlIpv4AddressToStringA(&addr, addressBufferRemote);
-                    py_addr_tuple_remote = Py_BuildValue(
-                        "(si)",
-                        addressBufferRemote,
-                        BYTESWAP_USHORT(tcp4Table->table[i].dwRemotePort));
-                }
-                else
-                {
-                    py_addr_tuple_remote = PyTuple_New(0);
-                }
-
-                if (py_addr_tuple_remote == NULL)
-                    goto error;
-
-                py_conn_tuple = Py_BuildValue(
-                    "(iiiNNiI)",
-                    -1,
-                    AF_INET,
-                    SOCK_STREAM,
-                    py_addr_tuple_local,
-                    py_addr_tuple_remote,
-                    tcp4Table->table[i].dwState,
-                    tcp4Table->table[i].dwOwningPid);
-                if (!py_conn_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_conn_tuple))
-                    goto error;
-                Py_DECREF(py_conn_tuple);
-            }
-        }
-
-        free(table);
-    }
-
-    // TCP IPv6
-    if ((PySequence_Contains(py_af_filter, _AF_INET6) == 1) &&
-            (PySequence_Contains(py_type_filter, _SOCK_STREAM) == 1))
-    {
-        table = NULL;
-        py_conn_tuple = NULL;
-        py_addr_tuple_local = NULL;
-        py_addr_tuple_remote = NULL;
-        tableSize = 0;
-        getExtendedTcpTable(NULL, &tableSize, FALSE, AF_INET6,
-                            TCP_TABLE_OWNER_PID_ALL, 0);
-
-        table = malloc(tableSize);
-        if (table == NULL) {
-            PyErr_NoMemory();
-            goto error;
-        }
-
-        if (getExtendedTcpTable(table, &tableSize, FALSE, AF_INET6,
-                                TCP_TABLE_OWNER_PID_ALL, 0) == 0)
-        {
-            tcp6Table = table;
-
-            for (i = 0; i < tcp6Table->dwNumEntries; i++)
-            {
-                if (pid != -1) {
-                    if (tcp6Table->table[i].dwOwningPid != pid) {
-                        continue;
-                    }
-                }
-
-                if (memcmp(tcp6Table->table[i].ucLocalAddr, null_address, 16)
-                        != 0 || tcp6Table->table[i].dwLocalPort != 0)
-                {
-                    struct in6_addr addr;
-
-                    memcpy(&addr, tcp6Table->table[i].ucLocalAddr, 16);
-                    rtlIpv6AddressToStringA(&addr, addressBufferLocal);
-                    py_addr_tuple_local = Py_BuildValue(
-                        "(si)",
-                        addressBufferLocal,
-                        BYTESWAP_USHORT(tcp6Table->table[i].dwLocalPort));
-                }
-                else {
-                    py_addr_tuple_local = PyTuple_New(0);
-                }
-
-                if (py_addr_tuple_local == NULL)
-                    goto error;
-
-                // On Windows <= XP, remote addr is filled even if socket
-                // is in LISTEN mode in which case we just ignore it.
-                if ((memcmp(tcp6Table->table[i].ucRemoteAddr, null_address, 16)
-                        != 0 ||
-                        tcp6Table->table[i].dwRemotePort != 0) &&
-                        (tcp6Table->table[i].dwState != MIB_TCP_STATE_LISTEN))
-                {
-                    struct in6_addr addr;
-
-                    memcpy(&addr, tcp6Table->table[i].ucRemoteAddr, 16);
-                    rtlIpv6AddressToStringA(&addr, addressBufferRemote);
-                    py_addr_tuple_remote = Py_BuildValue(
-                        "(si)",
-                        addressBufferRemote,
-                        BYTESWAP_USHORT(tcp6Table->table[i].dwRemotePort));
-                }
-                else {
-                    py_addr_tuple_remote = PyTuple_New(0);
-                }
-
-                if (py_addr_tuple_remote == NULL)
-                    goto error;
-
-                py_conn_tuple = Py_BuildValue(
-                    "(iiiNNiI)",
-                    -1,
-                    AF_INET6,
-                    SOCK_STREAM,
-                    py_addr_tuple_local,
-                    py_addr_tuple_remote,
-                    tcp6Table->table[i].dwState,
-                    tcp6Table->table[i].dwOwningPid);
-                if (!py_conn_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_conn_tuple))
-                    goto error;
-                Py_DECREF(py_conn_tuple);
-            }
-        }
-
-        free(table);
-    }
-
-    // UDP IPv4
-
-    if ((PySequence_Contains(py_af_filter, _AF_INET) == 1) &&
-            (PySequence_Contains(py_type_filter, _SOCK_DGRAM) == 1))
-    {
-        table = NULL;
-        py_conn_tuple = NULL;
-        py_addr_tuple_local = NULL;
-        py_addr_tuple_remote = NULL;
-        tableSize = 0;
-        getExtendedUdpTable(NULL, &tableSize, FALSE, AF_INET,
-                            UDP_TABLE_OWNER_PID, 0);
-
-        table = malloc(tableSize);
-        if (table == NULL) {
-            PyErr_NoMemory();
-            goto error;
-        }
-
-        if (getExtendedUdpTable(table, &tableSize, FALSE, AF_INET,
-                                UDP_TABLE_OWNER_PID, 0) == 0)
-        {
-            udp4Table = table;
-
-            for (i = 0; i < udp4Table->dwNumEntries; i++)
-            {
-                if (pid != -1) {
-                    if (udp4Table->table[i].dwOwningPid != pid) {
-                        continue;
-                    }
-                }
-
-                if (udp4Table->table[i].dwLocalAddr != 0 ||
-                    udp4Table->table[i].dwLocalPort != 0)
-                {
-                    struct in_addr addr;
-
-                    addr.S_un.S_addr = udp4Table->table[i].dwLocalAddr;
-                    rtlIpv4AddressToStringA(&addr, addressBufferLocal);
-                    py_addr_tuple_local = Py_BuildValue(
-                        "(si)",
-                        addressBufferLocal,
-                        BYTESWAP_USHORT(udp4Table->table[i].dwLocalPort));
-                }
-                else {
-                    py_addr_tuple_local = PyTuple_New(0);
-                }
-
-                if (py_addr_tuple_local == NULL)
-                    goto error;
-
-                py_conn_tuple = Py_BuildValue(
-                    "(iiiNNiI)",
-                    -1,
-                    AF_INET,
-                    SOCK_DGRAM,
-                    py_addr_tuple_local,
-                    PyTuple_New(0),
-                    PSUTIL_CONN_NONE,
-                    udp4Table->table[i].dwOwningPid);
-                if (!py_conn_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_conn_tuple))
-                    goto error;
-                Py_DECREF(py_conn_tuple);
-            }
-        }
-
-        free(table);
-    }
-
-    // UDP IPv6
-
-    if ((PySequence_Contains(py_af_filter, _AF_INET6) == 1) &&
-            (PySequence_Contains(py_type_filter, _SOCK_DGRAM) == 1))
-    {
-        table = NULL;
-        py_conn_tuple = NULL;
-        py_addr_tuple_local = NULL;
-        py_addr_tuple_remote = NULL;
-        tableSize = 0;
-        getExtendedUdpTable(NULL, &tableSize, FALSE,
-                            AF_INET6, UDP_TABLE_OWNER_PID, 0);
-
-        table = malloc(tableSize);
-        if (table == NULL) {
-            PyErr_NoMemory();
-            goto error;
-        }
-
-        if (getExtendedUdpTable(table, &tableSize, FALSE, AF_INET6,
-                                UDP_TABLE_OWNER_PID, 0) == 0)
-        {
-            udp6Table = table;
-
-            for (i = 0; i < udp6Table->dwNumEntries; i++) {
-                if (pid != -1) {
-                    if (udp6Table->table[i].dwOwningPid != pid) {
-                        continue;
-                    }
-                }
-
-                if (memcmp(udp6Table->table[i].ucLocalAddr, null_address, 16)
-                        != 0 || udp6Table->table[i].dwLocalPort != 0)
-                {
-                    struct in6_addr addr;
-
-                    memcpy(&addr, udp6Table->table[i].ucLocalAddr, 16);
-                    rtlIpv6AddressToStringA(&addr, addressBufferLocal);
-                    py_addr_tuple_local = Py_BuildValue(
-                        "(si)",
-                        addressBufferLocal,
-                        BYTESWAP_USHORT(udp6Table->table[i].dwLocalPort));
-                }
-                else {
-                    py_addr_tuple_local = PyTuple_New(0);
-                }
-
-                if (py_addr_tuple_local == NULL)
-                    goto error;
-
-                py_conn_tuple = Py_BuildValue(
-                    "(iiiNNiI)",
-                    -1,
-                    AF_INET6,
-                    SOCK_DGRAM,
-                    py_addr_tuple_local,
-                    PyTuple_New(0),
-                    PSUTIL_CONN_NONE,
-                    udp6Table->table[i].dwOwningPid);
-                if (!py_conn_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_conn_tuple))
-                    goto error;
-                Py_DECREF(py_conn_tuple);
-            }
-        }
-
-        free(table);
-    }
-
-    _psutil_conn_decref_objs();
-    return py_retlist;
-
-error:
-    _psutil_conn_decref_objs();
-    Py_XDECREF(py_conn_tuple);
-    Py_XDECREF(py_addr_tuple_local);
-    Py_XDECREF(py_addr_tuple_remote);
-    Py_DECREF(py_retlist);
-    if (table != NULL)
-        free(table);
-    return NULL;
-}
-
-
-/*
- * Get process priority as a Python integer.
- */
-static PyObject *
-psutil_proc_priority_get(PyObject *self, PyObject *args) {
-    long pid;
-    DWORD priority;
-    HANDLE hProcess;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    hProcess = psutil_handle_from_pid(pid);
-    if (hProcess == NULL)
-        return NULL;
-    priority = GetPriorityClass(hProcess);
-    CloseHandle(hProcess);
-    if (priority == 0) {
-        PyErr_SetFromWindowsErr(0);
-        return NULL;
-    }
-    return Py_BuildValue("i", priority);
-}
-
-
-/*
- * Set process priority.
- */
-static PyObject *
-psutil_proc_priority_set(PyObject *self, PyObject *args) {
-    long pid;
-    int priority;
-    int retval;
-    HANDLE hProcess;
-    DWORD access = PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION;
-
-    if (! PyArg_ParseTuple(args, "li", &pid, &priority))
-        return NULL;
-    hProcess = psutil_handle_from_pid_waccess(pid, access);
-    if (hProcess == NULL)
-        return NULL;
-    retval = SetPriorityClass(hProcess, priority);
-    CloseHandle(hProcess);
-    if (retval == 0) {
-        PyErr_SetFromWindowsErr(0);
-        return NULL;
-    }
-    Py_RETURN_NONE;
-}
-
-
-#if (_WIN32_WINNT >= 0x0600)  // Windows Vista
-/*
- * Get process IO priority as a Python integer.
- */
-static PyObject *
-psutil_proc_io_priority_get(PyObject *self, PyObject *args) {
-    long pid;
-    HANDLE hProcess;
-    PULONG IoPriority;
-
-    _NtQueryInformationProcess NtQueryInformationProcess =
-        (_NtQueryInformationProcess)GetProcAddress(
-            GetModuleHandleA("ntdll.dll"), "NtQueryInformationProcess");
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    hProcess = psutil_handle_from_pid(pid);
-    if (hProcess == NULL)
-        return NULL;
-
-    NtQueryInformationProcess(
-        hProcess,
-        ProcessIoPriority,
-        &IoPriority,
-        sizeof(ULONG),
-        NULL
-    );
-    CloseHandle(hProcess);
-    return Py_BuildValue("i", IoPriority);
-}
-
-
-/*
- * Set process IO priority.
- */
-static PyObject *
-psutil_proc_io_priority_set(PyObject *self, PyObject *args) {
-    long pid;
-    int prio;
-    HANDLE hProcess;
-
-    _NtSetInformationProcess NtSetInformationProcess =
-        (_NtSetInformationProcess)GetProcAddress(
-            GetModuleHandleA("ntdll.dll"), "NtSetInformationProcess");
-
-    if (NtSetInformationProcess == NULL) {
-        PyErr_SetString(PyExc_RuntimeError,
-                        "couldn't get NtSetInformationProcess");
-        return NULL;
-    }
-
-    if (! PyArg_ParseTuple(args, "li", &pid, &prio))
-        return NULL;
-    hProcess = psutil_handle_from_pid_waccess(pid, PROCESS_ALL_ACCESS);
-    if (hProcess == NULL)
-        return NULL;
-
-    NtSetInformationProcess(
-        hProcess,
-        ProcessIoPriority,
-        (PVOID)&prio,
-        sizeof((PVOID)prio)
-    );
-
-    CloseHandle(hProcess);
-    Py_RETURN_NONE;
-}
-#endif
-
-
-/*
- * Return a Python tuple referencing process I/O counters.
- */
-static PyObject *
-psutil_proc_io_counters(PyObject *self, PyObject *args) {
-    DWORD pid;
-    HANDLE hProcess;
-    IO_COUNTERS IoCounters;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    hProcess = psutil_handle_from_pid(pid);
-    if (NULL == hProcess)
-        return NULL;
-    if (! GetProcessIoCounters(hProcess, &IoCounters)) {
-        CloseHandle(hProcess);
-        return PyErr_SetFromWindowsErr(0);
-    }
-    CloseHandle(hProcess);
-    return Py_BuildValue("(KKKK)",
-                         IoCounters.ReadOperationCount,
-                         IoCounters.WriteOperationCount,
-                         IoCounters.ReadTransferCount,
-                         IoCounters.WriteTransferCount);
-}
-
-
-/*
- * Return process CPU affinity as a bitmask
- */
-static PyObject *
-psutil_proc_cpu_affinity_get(PyObject *self, PyObject *args) {
-    DWORD pid;
-    HANDLE hProcess;
-    DWORD_PTR proc_mask;
-    DWORD_PTR system_mask;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    hProcess = psutil_handle_from_pid(pid);
-    if (hProcess == NULL) {
-        return NULL;
-    }
-    if (GetProcessAffinityMask(hProcess, &proc_mask, &system_mask) == 0) {
-        CloseHandle(hProcess);
-        return PyErr_SetFromWindowsErr(0);
-    }
-
-    CloseHandle(hProcess);
-#ifdef _WIN64
-    return Py_BuildValue("K", (unsigned long long)proc_mask);
-#else
-    return Py_BuildValue("k", (unsigned long)proc_mask);
-#endif
-}
-
-
-/*
- * Set process CPU affinity
- */
-static PyObject *
-psutil_proc_cpu_affinity_set(PyObject *self, PyObject *args) {
-    DWORD pid;
-    HANDLE hProcess;
-    DWORD dwDesiredAccess = \
-        PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION;
-    DWORD_PTR mask;
-
-#ifdef _WIN64
-    if (! PyArg_ParseTuple(args, "lK", &pid, &mask))
-#else
-    if (! PyArg_ParseTuple(args, "lk", &pid, &mask))
-#endif
-    {
-        return NULL;
-    }
-    hProcess = psutil_handle_from_pid_waccess(pid, dwDesiredAccess);
-    if (hProcess == NULL)
-        return NULL;
-
-    if (SetProcessAffinityMask(hProcess, mask) == 0) {
-        CloseHandle(hProcess);
-        return PyErr_SetFromWindowsErr(0);
-    }
-
-    CloseHandle(hProcess);
-    Py_RETURN_NONE;
-}
-
-
-/*
- * Return True if one of the process threads is in a waiting or
- * suspended status.
- */
-static PyObject *
-psutil_proc_is_suspended(PyObject *self, PyObject *args) {
-    DWORD pid;
-    ULONG i;
-    PSYSTEM_PROCESS_INFORMATION process;
-    PVOID buffer;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (! psutil_get_proc_info(pid, &process, &buffer)) {
-        return NULL;
-    }
-    for (i = 0; i < process->NumberOfThreads; i++) {
-        if (process->Threads[i].ThreadState != Waiting ||
-                process->Threads[i].WaitReason != Suspended)
-        {
-            free(buffer);
-            Py_RETURN_FALSE;
-        }
-    }
-    free(buffer);
-    Py_RETURN_TRUE;
-}
-
-
-/*
- * Return path's disk total and free as a Python tuple.
- */
-static PyObject *
-psutil_disk_usage(PyObject *self, PyObject *args) {
-    BOOL retval;
-    ULARGE_INTEGER _, total, free;
-    char *path;
-
-    if (PyArg_ParseTuple(args, "u", &path)) {
-        Py_BEGIN_ALLOW_THREADS
-        retval = GetDiskFreeSpaceExW((LPCWSTR)path, &_, &total, &free);
-        Py_END_ALLOW_THREADS
-        goto return_;
-    }
-
-    // on Python 2 we also want to accept plain strings other
-    // than Unicode
-#if PY_MAJOR_VERSION <= 2
-    PyErr_Clear();  // drop the argument parsing error
-    if (PyArg_ParseTuple(args, "s", &path)) {
-        Py_BEGIN_ALLOW_THREADS
-        retval = GetDiskFreeSpaceEx(path, &_, &total, &free);
-        Py_END_ALLOW_THREADS
-        goto return_;
-    }
-#endif
-
-    return NULL;
-
-return_:
-    if (retval == 0)
-        return PyErr_SetFromWindowsErr(0);
-    else
-        return Py_BuildValue("(LL)", total.QuadPart, free.QuadPart);
-}
-
-
-/*
- * Return a Python list of named tuples with overall network I/O information
- */
-static PyObject *
-psutil_net_io_counters(PyObject *self, PyObject *args) {
-    DWORD dwRetVal = 0;
-
-#if (_WIN32_WINNT >= 0x0600) // Windows Vista and above
-    MIB_IF_ROW2 *pIfRow = NULL;
-#else // Windows XP
-    MIB_IFROW *pIfRow = NULL;
-#endif
-
-    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
-    PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_nic_info = NULL;
-    PyObject *py_nic_name = NULL;
-
-    if (py_retdict == NULL)
-        return NULL;
-    pAddresses = psutil_get_nic_addresses();
-    if (pAddresses == NULL)
-        goto error;
-    pCurrAddresses = pAddresses;
-
-    while (pCurrAddresses) {
-        py_nic_name = NULL;
-        py_nic_info = NULL;
-
-#if (_WIN32_WINNT >= 0x0600) // Windows Vista and above
-        pIfRow = (MIB_IF_ROW2 *) malloc(sizeof(MIB_IF_ROW2));
-#else // Windows XP
-        pIfRow = (MIB_IFROW *) malloc(sizeof(MIB_IFROW));
-#endif
-
-        if (pIfRow == NULL) {
-            PyErr_NoMemory();
-            goto error;
-        }
-
-#if (_WIN32_WINNT >= 0x0600) // Windows Vista and above
-        SecureZeroMemory((PVOID)pIfRow, sizeof(MIB_IF_ROW2));
-        pIfRow->InterfaceIndex = pCurrAddresses->IfIndex;
-        dwRetVal = GetIfEntry2(pIfRow);
-#else // Windows XP
-        pIfRow->dwIndex = pCurrAddresses->IfIndex;
-        dwRetVal = GetIfEntry(pIfRow);
-#endif
-
-        if (dwRetVal != NO_ERROR) {
-            PyErr_SetString(PyExc_RuntimeError,
-                            "GetIfEntry() or GetIfEntry2() failed.");
-            goto error;
-        }
-
-#if (_WIN32_WINNT >= 0x0600) // Windows Vista and above
-        py_nic_info = Py_BuildValue("(KKKKKKKK)",
-                                    pIfRow->OutOctets,
-                                    pIfRow->InOctets,
-                                    pIfRow->OutUcastPkts,
-                                    pIfRow->InUcastPkts,
-                                    pIfRow->InErrors,
-                                    pIfRow->OutErrors,
-                                    pIfRow->InDiscards,
-                                    pIfRow->OutDiscards);
-#else // Windows XP
-        py_nic_info = Py_BuildValue("(kkkkkkkk)",
-                                    pIfRow->dwOutOctets,
-                                    pIfRow->dwInOctets,
-                                    pIfRow->dwOutUcastPkts,
-                                    pIfRow->dwInUcastPkts,
-                                    pIfRow->dwInErrors,
-                                    pIfRow->dwOutErrors,
-                                    pIfRow->dwInDiscards,
-                                    pIfRow->dwOutDiscards);
-#endif
-
-        if (!py_nic_info)
-            goto error;
-
-        py_nic_name = PyUnicode_FromWideChar(
-            pCurrAddresses->FriendlyName,
-            wcslen(pCurrAddresses->FriendlyName));
-
-        if (py_nic_name == NULL)
-            goto error;
-        if (PyDict_SetItem(py_retdict, py_nic_name, py_nic_info))
-            goto error;
-        Py_XDECREF(py_nic_name);
-        Py_XDECREF(py_nic_info);
-
-        free(pIfRow);
-        pCurrAddresses = pCurrAddresses->Next;
-    }
-
-    free(pAddresses);
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_nic_name);
-    Py_XDECREF(py_nic_info);
-    Py_DECREF(py_retdict);
-    if (pAddresses != NULL)
-        free(pAddresses);
-    if (pIfRow != NULL)
-        free(pIfRow);
-    return NULL;
-}
-
-
-/*
- * Return a Python dict of tuples for disk I/O information
- */
-static PyObject *
-psutil_disk_io_counters(PyObject *self, PyObject *args) {
-    DISK_PERFORMANCE_WIN_2008 diskPerformance;
-    DWORD dwSize;
-    HANDLE hDevice = NULL;
-    char szDevice[MAX_PATH];
-    char szDeviceDisplay[MAX_PATH];
-    int devNum;
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_tuple = NULL;
-
-    if (py_retdict == NULL)
-        return NULL;
-    // Apparently there's no way to figure out how many times we have
-    // to iterate in order to find valid drives.
-    // Let's assume 32, which is higher than 26, the number of letters
-    // in the alphabet (from A:\ to Z:\).
-    for (devNum = 0; devNum <= 32; ++devNum) {
-        py_tuple = NULL;
-        sprintf_s(szDevice, MAX_PATH, "\\\\.\\PhysicalDrive%d", devNum);
-        hDevice = CreateFile(szDevice, 0, FILE_SHARE_READ | FILE_SHARE_WRITE,
-                             NULL, OPEN_EXISTING, 0, NULL);
-
-        if (hDevice == INVALID_HANDLE_VALUE)
-            continue;
-        if (DeviceIoControl(hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0,
-                            &diskPerformance, sizeof(diskPerformance),
-                            &dwSize, NULL))
-        {
-            sprintf_s(szDeviceDisplay, MAX_PATH, "PhysicalDrive%d", devNum);
-            py_tuple = Py_BuildValue(
-                "(IILLKK)",
-                diskPerformance.ReadCount,
-                diskPerformance.WriteCount,
-                diskPerformance.BytesRead,
-                diskPerformance.BytesWritten,
-                (unsigned long long)(diskPerformance.ReadTime.QuadPart * 10) / 1000,
-                (unsigned long long)(diskPerformance.WriteTime.QuadPart * 10) / 1000);
-            if (!py_tuple)
-                goto error;
-            if (PyDict_SetItemString(py_retdict, szDeviceDisplay,
-                                     py_tuple))
-            {
-                goto error;
-            }
-            Py_XDECREF(py_tuple);
-        }
-        else {
-            // XXX we might get here with ERROR_INSUFFICIENT_BUFFER when
-            // compiling with mingw32; not sure what to do.
-            // return PyErr_SetFromWindowsErr(0);
-            ;;
-        }
-
-        CloseHandle(hDevice);
-    }
-
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retdict);
-    if (hDevice != NULL)
-        CloseHandle(hDevice);
-    return NULL;
-}
-
-
-static char *psutil_get_drive_type(int type) {
-    switch (type) {
-        case DRIVE_FIXED:
-            return "fixed";
-        case DRIVE_CDROM:
-            return "cdrom";
-        case DRIVE_REMOVABLE:
-            return "removable";
-        case DRIVE_UNKNOWN:
-            return "unknown";
-        case DRIVE_NO_ROOT_DIR:
-            return "unmounted";
-        case DRIVE_REMOTE:
-            return "remote";
-        case DRIVE_RAMDISK:
-            return "ramdisk";
-        default:
-            return "?";
-    }
-}
-
-
-#ifndef _ARRAYSIZE
-#define _ARRAYSIZE(a) (sizeof(a)/sizeof(a[0]))
-#endif
-
-/*
- * Return disk partitions as a list of tuples such as
- * (drive_letter, drive_letter, type, "")
- */
-static PyObject *
-psutil_disk_partitions(PyObject *self, PyObject *args) {
-    DWORD num_bytes;
-    char drive_strings[255];
-    char *drive_letter = drive_strings;
-    int all;
-    int type;
-    int ret;
-    char opts[20];
-    LPTSTR fs_type[MAX_PATH + 1] = { 0 };
-    DWORD pflags = 0;
-    PyObject *py_all;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL) {
-        return NULL;
-    }
-
-    // avoid to visualize a message box in case something goes wrong
-    // see https://github.com/giampaolo/psutil/issues/264
-    SetErrorMode(SEM_FAILCRITICALERRORS);
-
-    if (! PyArg_ParseTuple(args, "O", &py_all))
-        goto error;
-    all = PyObject_IsTrue(py_all);
-
-    Py_BEGIN_ALLOW_THREADS
-    num_bytes = GetLogicalDriveStrings(254, drive_letter);
-    Py_END_ALLOW_THREADS
-
-    if (num_bytes == 0) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    while (*drive_letter != 0) {
-        py_tuple = NULL;
-        opts[0] = 0;
-        fs_type[0] = 0;
-
-        Py_BEGIN_ALLOW_THREADS
-        type = GetDriveType(drive_letter);
-        Py_END_ALLOW_THREADS
-
-        // by default we only show hard drives and cd-roms
-        if (all == 0) {
-            if ((type == DRIVE_UNKNOWN) ||
-                    (type == DRIVE_NO_ROOT_DIR) ||
-                    (type == DRIVE_REMOTE) ||
-                    (type == DRIVE_RAMDISK)) {
-                goto next;
-            }
-            // floppy disk: skip it by default as it introduces a
-            // considerable slowdown.
-            if ((type == DRIVE_REMOVABLE) &&
-                    (strcmp(drive_letter, "A:\\")  == 0)) {
-                goto next;
-            }
-        }
-
-        ret = GetVolumeInformation(
-            (LPCTSTR)drive_letter, NULL, _ARRAYSIZE(drive_letter),
-            NULL, NULL, &pflags, (LPTSTR)fs_type, _ARRAYSIZE(fs_type));
-        if (ret == 0) {
-            // We might get here in case of a floppy hard drive, in
-            // which case the error is (21, "device not ready").
-            // Let's pretend it didn't happen as we already have
-            // the drive name and type ('removable').
-            strcat_s(opts, _countof(opts), "");
-            SetLastError(0);
-        }
-        else {
-            if (pflags & FILE_READ_ONLY_VOLUME)
-                strcat_s(opts, _countof(opts), "ro");
-            else
-                strcat_s(opts, _countof(opts), "rw");
-            if (pflags & FILE_VOLUME_IS_COMPRESSED)
-                strcat_s(opts, _countof(opts), ",compressed");
-        }
-
-        if (strlen(opts) > 0)
-            strcat_s(opts, _countof(opts), ",");
-        strcat_s(opts, _countof(opts), psutil_get_drive_type(type));
-
-        py_tuple = Py_BuildValue(
-            "(ssss)",
-            drive_letter,
-            drive_letter,
-            fs_type,  // either FAT, FAT32, NTFS, HPFS, CDFS, UDF or NWFS
-            opts);
-        if (!py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-        goto next;
-
-next:
-        drive_letter = strchr(drive_letter, 0) + 1;
-    }
-
-    SetErrorMode(0);
-    return py_retlist;
-
-error:
-    SetErrorMode(0);
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    return NULL;
-}
-
-/*
- * Return a Python dict of tuples for disk I/O information
- */
-static PyObject *
-psutil_users(PyObject *self, PyObject *args) {
-    HANDLE hServer = NULL;
-    LPTSTR buffer_user = NULL;
-    LPTSTR buffer_addr = NULL;
-    PWTS_SESSION_INFO sessions = NULL;
-    DWORD count;
-    DWORD i;
-    DWORD sessionId;
-    DWORD bytes;
-    PWTS_CLIENT_ADDRESS address;
-    char address_str[50];
-    long long unix_time;
-
-    PWINSTATIONQUERYINFORMATIONW WinStationQueryInformationW;
-    WINSTATION_INFO station_info;
-    HINSTANCE hInstWinSta = NULL;
-    ULONG returnLen;
-
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_address = NULL;
-    PyObject *py_buffer_user_encoded = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    hInstWinSta = LoadLibraryA("winsta.dll");
-    WinStationQueryInformationW = (PWINSTATIONQUERYINFORMATIONW) \
-        GetProcAddress(hInstWinSta, "WinStationQueryInformationW");
-
-    hServer = WTSOpenServer('\0');
-    if (hServer == NULL) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    if (WTSEnumerateSessions(hServer, 0, 1, &sessions, &count) == 0) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    for (i = 0; i < count; i++) {
-        py_address = NULL;
-        py_tuple = NULL;
-        sessionId = sessions[i].SessionId;
-        if (buffer_user != NULL)
-            WTSFreeMemory(buffer_user);
-        if (buffer_addr != NULL)
-            WTSFreeMemory(buffer_addr);
-
-        buffer_user = NULL;
-        buffer_addr = NULL;
-
-        // username
-        bytes = 0;
-        if (WTSQuerySessionInformation(hServer, sessionId, WTSUserName,
-                                       &buffer_user, &bytes) == 0) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-        if (bytes == 1)
-            continue;
-
-        // address
-        bytes = 0;
-        if (WTSQuerySessionInformation(hServer, sessionId, WTSClientAddress,
-                                       &buffer_addr, &bytes) == 0) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-
-        address = (PWTS_CLIENT_ADDRESS)buffer_addr;
-        if (address->AddressFamily == 0) {  // AF_INET
-            sprintf_s(address_str,
-                      _countof(address_str),
-                      "%u.%u.%u.%u",
-                      address->Address[0],
-                      address->Address[1],
-                      address->Address[2],
-                      address->Address[3]);
-            py_address = Py_BuildValue("s", address_str);
-            if (!py_address)
-                goto error;
-        }
-        else {
-            py_address = Py_None;
-        }
-
-        // login time
-        if (!WinStationQueryInformationW(hServer,
-                                         sessionId,
-                                         WinStationInformation,
-                                         &station_info,
-                                         sizeof(station_info),
-                                         &returnLen))
-        {
-            goto error;
-        }
-
-        unix_time = ((LONGLONG)station_info.ConnectTime.dwHighDateTime) << 32;
-        unix_time += \
-            station_info.ConnectTime.dwLowDateTime - 116444736000000000LL;
-        unix_time /= 10000000;
-
-        py_buffer_user_encoded = PyUnicode_Decode(
-            buffer_user, _tcslen(buffer_user), Py_FileSystemDefaultEncoding,
-            "replace");
-        if (py_buffer_user_encoded == NULL)
-            goto error;
-        py_tuple = Py_BuildValue("OOd", py_buffer_user_encoded, py_address,
-                                 (double)unix_time);
-        if (!py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_XDECREF(py_buffer_user_encoded);
-        Py_XDECREF(py_address);
-        Py_XDECREF(py_tuple);
-    }
-
-    WTSCloseServer(hServer);
-    WTSFreeMemory(sessions);
-    WTSFreeMemory(buffer_user);
-    WTSFreeMemory(buffer_addr);
-    FreeLibrary(hInstWinSta);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_buffer_user_encoded);
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_address);
-    Py_DECREF(py_retlist);
-
-    if (hInstWinSta != NULL)
-        FreeLibrary(hInstWinSta);
-    if (hServer != NULL)
-        WTSCloseServer(hServer);
-    if (sessions != NULL)
-        WTSFreeMemory(sessions);
-    if (buffer_user != NULL)
-        WTSFreeMemory(buffer_user);
-    if (buffer_addr != NULL)
-        WTSFreeMemory(buffer_addr);
-    return NULL;
-}
-
-
-/*
- * Return the number of handles opened by process.
- */
-static PyObject *
-psutil_proc_num_handles(PyObject *self, PyObject *args) {
-    DWORD pid;
-    HANDLE hProcess;
-    DWORD handleCount;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    hProcess = psutil_handle_from_pid(pid);
-    if (NULL == hProcess)
-        return NULL;
-    if (! GetProcessHandleCount(hProcess, &handleCount)) {
-        CloseHandle(hProcess);
-        return PyErr_SetFromWindowsErr(0);
-    }
-    CloseHandle(hProcess);
-    return Py_BuildValue("k", handleCount);
-}
-
-
-/*
- * Get various process information by using NtQuerySystemInformation.
- * We use this as a fallback when faster functions fail with access
- * denied. This is slower because it iterates over all processes.
- * Returned tuple includes the following process info:
- *
- * - num_threads
- * - ctx_switches
- * - num_handles (fallback)
- * - user/kernel times (fallback)
- * - create time (fallback)
- * - io counters (fallback)
- */
-static PyObject *
-psutil_proc_info(PyObject *self, PyObject *args) {
-    DWORD pid;
-    PSYSTEM_PROCESS_INFORMATION process;
-    PVOID buffer;
-    ULONG num_handles;
-    ULONG i;
-    ULONG ctx_switches = 0;
-    double user_time;
-    double kernel_time;
-    long long create_time;
-    int num_threads;
-    LONGLONG io_rcount, io_wcount, io_rbytes, io_wbytes;
-
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (! psutil_get_proc_info(pid, &process, &buffer))
-        return NULL;
-
-    num_handles = process->HandleCount;
-    for (i = 0; i < process->NumberOfThreads; i++)
-        ctx_switches += process->Threads[i].ContextSwitches;
-    user_time = (double)process->UserTime.HighPart * 429.4967296 + \
-                (double)process->UserTime.LowPart * 1e-7;
-    kernel_time = (double)process->KernelTime.HighPart * 429.4967296 + \
-                  (double)process->KernelTime.LowPart * 1e-7;
-    // Convert the LARGE_INTEGER union to a Unix time.
-    // It's the best I could find by googling and borrowing code here
-    // and there. The time returned has a precision of 1 second.
-    if (0 == pid || 4 == pid) {
-        // the python module will translate this into BOOT_TIME later
-        create_time = 0;
-    }
-    else {
-        create_time = ((LONGLONG)process->CreateTime.HighPart) << 32;
-        create_time += process->CreateTime.LowPart - 116444736000000000LL;
-        create_time /= 10000000;
-    }
-    num_threads = (int)process->NumberOfThreads;
-    io_rcount = process->ReadOperationCount.QuadPart;
-    io_wcount = process->WriteOperationCount.QuadPart;
-    io_rbytes = process->ReadTransferCount.QuadPart;
-    io_wbytes = process->WriteTransferCount.QuadPart;
-    free(buffer);
-
-    return Py_BuildValue(
-        "kkdddiKKKK",
-        num_handles,
-        ctx_switches,
-        user_time,
-        kernel_time,
-        (double)create_time,
-        num_threads,
-        io_rcount,
-        io_wcount,
-        io_rbytes,
-        io_wbytes
-    );
-}
-
-
-static char *get_region_protection_string(ULONG protection) {
-    switch (protection & 0xff) {
-        case PAGE_NOACCESS:
-            return "";
-        case PAGE_READONLY:
-            return "r";
-        case PAGE_READWRITE:
-            return "rw";
-        case PAGE_WRITECOPY:
-            return "wc";
-        case PAGE_EXECUTE:
-            return "x";
-        case PAGE_EXECUTE_READ:
-            return "xr";
-        case PAGE_EXECUTE_READWRITE:
-            return "xrw";
-        case PAGE_EXECUTE_WRITECOPY:
-            return "xwc";
-        default:
-            return "?";
-    }
-}
-
-
-/*
- * Return a list of process's memory mappings.
- */
-static PyObject *
-psutil_proc_memory_maps(PyObject *self, PyObject *args) {
-#ifdef _WIN64
-    MEMORY_BASIC_INFORMATION64 basicInfo;
-#else
-    MEMORY_BASIC_INFORMATION basicInfo;
-#endif
-    DWORD pid;
-    HANDLE hProcess = NULL;
-    PVOID baseAddress;
-    PVOID previousAllocationBase;
-    CHAR mappedFileName[MAX_PATH];
-    SYSTEM_INFO system_info;
-    LPVOID maxAddr;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-    hProcess = psutil_handle_from_pid(pid);
-    if (NULL == hProcess)
-        goto error;
-
-    GetSystemInfo(&system_info);
-    maxAddr = system_info.lpMaximumApplicationAddress;
-    baseAddress = NULL;
-    previousAllocationBase = NULL;
-
-    while (VirtualQueryEx(hProcess, baseAddress, &basicInfo,
-                          sizeof(MEMORY_BASIC_INFORMATION)))
-    {
-        py_tuple = NULL;
-        if (baseAddress > maxAddr)
-            break;
-        if (GetMappedFileNameA(hProcess, baseAddress, mappedFileName,
-                               sizeof(mappedFileName)))
-        {
-#ifdef _WIN64
-           py_tuple = Py_BuildValue(
-              "(KssI)",
-              (unsigned long long)baseAddress,
-#else
-           py_tuple = Py_BuildValue(
-              "(kssI)",
-              (unsigned long)baseAddress,
-#endif
-              get_region_protection_string(basicInfo.Protect),
-              mappedFileName,
-              basicInfo.RegionSize);
-
-            if (!py_tuple)
-                goto error;
-            if (PyList_Append(py_retlist, py_tuple))
-                goto error;
-            Py_DECREF(py_tuple);
-        }
-        previousAllocationBase = basicInfo.AllocationBase;
-        baseAddress = (PCHAR)baseAddress + basicInfo.RegionSize;
-    }
-
-    CloseHandle(hProcess);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (hProcess != NULL)
-        CloseHandle(hProcess);
-    return NULL;
-}
-
-
-/*
- * Return a {pid:ppid, ...} dict for all running processes.
- */
-static PyObject *
-psutil_ppid_map(PyObject *self, PyObject *args) {
-    PyObject *py_pid = NULL;
-    PyObject *py_ppid = NULL;
-    PyObject *py_retdict = PyDict_New();
-    HANDLE handle = NULL;
-    PROCESSENTRY32 pe = {0};
-    pe.dwSize = sizeof(PROCESSENTRY32);
-
-    if (py_retdict == NULL)
-        return NULL;
-    handle = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
-    if (handle == INVALID_HANDLE_VALUE) {
-        PyErr_SetFromWindowsErr(0);
-        Py_DECREF(py_retdict);
-        return NULL;
-    }
-
-    if (Process32First(handle, &pe)) {
-        do {
-            py_pid = Py_BuildValue("I", pe.th32ProcessID);
-            if (py_pid == NULL)
-                goto error;
-            py_ppid = Py_BuildValue("I", pe.th32ParentProcessID);
-            if (py_ppid == NULL)
-                goto error;
-            if (PyDict_SetItem(py_retdict, py_pid, py_ppid))
-                goto error;
-            Py_DECREF(py_pid);
-            Py_DECREF(py_ppid);
-        } while (Process32Next(handle, &pe));
-    }
-
-    CloseHandle(handle);
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_pid);
-    Py_XDECREF(py_ppid);
-    Py_DECREF(py_retdict);
-    CloseHandle(handle);
-    return NULL;
-}
-
-
-/*
- * Return NICs addresses.
- */
-
-static PyObject *
-psutil_net_if_addrs(PyObject *self, PyObject *args) {
-    unsigned int i = 0;
-    ULONG family;
-    PCTSTR intRet;
-    char *ptr;
-    char buff[100];
-    DWORD bufflen = 100;
-    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
-    PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
-    PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
-
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_address = NULL;
-    PyObject *py_mac_address = NULL;
-    PyObject *py_nic_name = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    pAddresses = psutil_get_nic_addresses();
-    if (pAddresses == NULL)
-        goto error;
-    pCurrAddresses = pAddresses;
-
-    while (pCurrAddresses) {
-        pUnicast = pCurrAddresses->FirstUnicastAddress;
-
-        py_nic_name = NULL;
-        py_nic_name = PyUnicode_FromWideChar(
-            pCurrAddresses->FriendlyName,
-            wcslen(pCurrAddresses->FriendlyName));
-        if (py_nic_name == NULL)
-            goto error;
-
-        // MAC address
-        if (pCurrAddresses->PhysicalAddressLength != 0) {
-            ptr = buff;
-            *ptr = '\0';
-            for (i = 0; i < (int) pCurrAddresses->PhysicalAddressLength; i++) {
-                if (i == (pCurrAddresses->PhysicalAddressLength - 1)) {
-                    sprintf_s(ptr, _countof(buff), "%.2X\n",
-                            (int)pCurrAddresses->PhysicalAddress[i]);
-                }
-                else {
-                    sprintf_s(ptr, _countof(buff), "%.2X-",
-                            (int)pCurrAddresses->PhysicalAddress[i]);
-                }
-                ptr += 3;
-            }
-            *--ptr = '\0';
-
-#if PY_MAJOR_VERSION >= 3
-            py_mac_address = PyUnicode_FromString(buff);
-#else
-            py_mac_address = PyString_FromString(buff);
-#endif
-            if (py_mac_address == NULL)
-                goto error;
-
-            Py_INCREF(Py_None);
-            Py_INCREF(Py_None);
-            Py_INCREF(Py_None);
-            py_tuple = Py_BuildValue(
-                "(OiOOOO)",
-                py_nic_name,
-                -1,  // this will be converted later to AF_LINK
-                py_mac_address,
-                Py_None,  // netmask (not supported)
-                Py_None,  // broadcast (not supported)
-                Py_None  // ptp (not supported on Windows)
-            );
-            if (! py_tuple)
-                goto error;
-            if (PyList_Append(py_retlist, py_tuple))
-                goto error;
-            Py_DECREF(py_tuple);
-            Py_DECREF(py_mac_address);
-        }
-
-        // find out the IP address associated with the NIC
-        if (pUnicast != NULL) {
-            for (i = 0; pUnicast != NULL; i++) {
-                family = pUnicast->Address.lpSockaddr->sa_family;
-                if (family == AF_INET) {
-                    struct sockaddr_in *sa_in = (struct sockaddr_in *)
-                        pUnicast->Address.lpSockaddr;
-                    intRet = inet_ntop(AF_INET, &(sa_in->sin_addr), buff,
-                                       bufflen);
-                }
-                else if (family == AF_INET6) {
-                    struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)
-                        pUnicast->Address.lpSockaddr;
-                    intRet = inet_ntop(AF_INET6, &(sa_in6->sin6_addr),
-                                       buff, bufflen);
-                }
-                else {
-                    // we should never get here
-                    pUnicast = pUnicast->Next;
-                    continue;
-                }
-
-                if (intRet == NULL) {
-                    PyErr_SetFromWindowsErr(GetLastError());
-                    goto error;
-                }
-#if PY_MAJOR_VERSION >= 3
-                py_address = PyUnicode_FromString(buff);
-#else
-                py_address = PyString_FromString(buff);
-#endif
-                if (py_address == NULL)
-                    goto error;
-
-                Py_INCREF(Py_None);
-                Py_INCREF(Py_None);
-                Py_INCREF(Py_None);
-                py_tuple = Py_BuildValue(
-                    "(OiOOOO)",
-                    py_nic_name,
-                    family,
-                    py_address,
-                    Py_None,  // netmask (not supported)
-                    Py_None,  // broadcast (not supported)
-                    Py_None  // ptp (not supported on Windows)
-                );
-
-                if (! py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-                Py_DECREF(py_address);
-
-                pUnicast = pUnicast->Next;
-            }
-        }
-        Py_DECREF(py_nic_name);
-        pCurrAddresses = pCurrAddresses->Next;
-    }
-
-    free(pAddresses);
-    return py_retlist;
-
-error:
-    if (pAddresses)
-        free(pAddresses);
-    Py_DECREF(py_retlist);
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_address);
-    Py_XDECREF(py_nic_name);
-    return NULL;
-}
-
-
-/*
- * Provides stats about NIC interfaces installed on the system.
- * TODO: get 'duplex' (currently it's hard coded to '2', aka
-         'full duplex')
- */
-static PyObject *
-psutil_net_if_stats(PyObject *self, PyObject *args) {
-    int i;
-    DWORD dwSize = 0;
-    DWORD dwRetVal = 0;
-    MIB_IFTABLE *pIfTable;
-    MIB_IFROW *pIfRow;
-    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
-    PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
-    char descr[MAX_PATH];
-    int ifname_found;
-
-    PyObject *py_nic_name = NULL;
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_ifc_info = NULL;
-    PyObject *py_is_up = NULL;
-
-    if (py_retdict == NULL)
-        return NULL;
-
-    pAddresses = psutil_get_nic_addresses();
-    if (pAddresses == NULL)
-        goto error;
-
-    pIfTable = (MIB_IFTABLE *) malloc(sizeof (MIB_IFTABLE));
-    if (pIfTable == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-    dwSize = sizeof(MIB_IFTABLE);
-    if (GetIfTable(pIfTable, &dwSize, FALSE) == ERROR_INSUFFICIENT_BUFFER) {
-        free(pIfTable);
-        pIfTable = (MIB_IFTABLE *) malloc(dwSize);
-        if (pIfTable == NULL) {
-            PyErr_NoMemory();
-            goto error;
-        }
-    }
-    // Make a second call to GetIfTable to get the actual
-    // data we want.
-    if ((dwRetVal = GetIfTable(pIfTable, &dwSize, FALSE)) != NO_ERROR) {
-        PyErr_SetString(PyExc_RuntimeError, "GetIfTable() failed");
-        goto error;
-    }
-
-    for (i = 0; i < (int) pIfTable->dwNumEntries; i++) {
-        pIfRow = (MIB_IFROW *) & pIfTable->table[i];
-
-        // GetIfTable is not able to give us NIC with "friendly names"
-        // so we determine them via GetAdapterAddresses() which
-        // provides friendly names *and* descriptions and find the
-        // ones that match.
-        ifname_found = 0;
-        pCurrAddresses = pAddresses;
-        while (pCurrAddresses) {
-            sprintf_s(descr, MAX_PATH, "%wS", pCurrAddresses->Description);
-            if (lstrcmp(descr, pIfRow->bDescr) == 0) {
-                py_nic_name = PyUnicode_FromWideChar(
-                    pCurrAddresses->FriendlyName,
-                    wcslen(pCurrAddresses->FriendlyName));
-                if (py_nic_name == NULL)
-                    goto error;
-                ifname_found = 1;
-                break;
-            }
-            pCurrAddresses = pCurrAddresses->Next;
-        }
-        if (ifname_found == 0) {
-            // Name not found means GetAdapterAddresses() doesn't list
-            // this NIC, only GetIfTable, meaning it's not really a NIC
-            // interface so we skip it.
-            continue;
-        }
-
-        // is up?
-        if((pIfRow->dwOperStatus == MIB_IF_OPER_STATUS_CONNECTED ||
-                pIfRow->dwOperStatus == MIB_IF_OPER_STATUS_OPERATIONAL) &&
-                pIfRow->dwAdminStatus == 1 ) {
-            py_is_up = Py_True;
-        }
-        else {
-            py_is_up = Py_False;
-        }
-        Py_INCREF(py_is_up);
-
-        py_ifc_info = Py_BuildValue(
-            "(Oikk)",
-            py_is_up,
-            2,  // there's no way to know duplex so let's assume 'full'
-            pIfRow->dwSpeed / 1000000,  // expressed in bytes, we want Mb
-            pIfRow->dwMtu
-        );
-        if (!py_ifc_info)
-            goto error;
-        if (PyDict_SetItem(py_retdict, py_nic_name, py_ifc_info))
-            goto error;
-        Py_DECREF(py_nic_name);
-        Py_DECREF(py_ifc_info);
-    }
-
-    free(pIfTable);
-    free(pAddresses);
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_is_up);
-    Py_XDECREF(py_ifc_info);
-    Py_XDECREF(py_nic_name);
-    Py_DECREF(py_retdict);
-    if (pIfTable != NULL)
-        free(pIfTable);
-    if (pAddresses != NULL)
-        free(pAddresses);
-    return NULL;
-}
-
-
-/*
- * Return CPU statistics.
- */
-static PyObject *
-psutil_cpu_stats(PyObject *self, PyObject *args) {
-    // NtQuerySystemInformation stuff
-    typedef DWORD (_stdcall * NTQSI_PROC) (int, PVOID, ULONG, PULONG);
-    NTQSI_PROC NtQuerySystemInformation;
-    HINSTANCE hNtDll;
-
-    NTSTATUS status;
-    _SYSTEM_PERFORMANCE_INFORMATION *spi = NULL;
-    _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *sppi = NULL;
-    _SYSTEM_INTERRUPT_INFORMATION *InterruptInformation = NULL;
-    SYSTEM_INFO si;
-    UINT i;
-    ULONG64 dpcs = 0;
-    ULONG interrupts = 0;
-
-    // obtain NtQuerySystemInformation
-    hNtDll = LoadLibrary(TEXT("ntdll.dll"));
-    if (hNtDll == NULL) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-    NtQuerySystemInformation = (NTQSI_PROC)GetProcAddress(
-        hNtDll, "NtQuerySystemInformation");
-    if (NtQuerySystemInformation == NULL) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    // retrives number of processors
-    GetSystemInfo(&si);
-
-    // get syscalls / ctx switches
-    spi = (_SYSTEM_PERFORMANCE_INFORMATION *) \
-           malloc(si.dwNumberOfProcessors * \
-                  sizeof(_SYSTEM_PERFORMANCE_INFORMATION));
-    if (spi == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-    status = NtQuerySystemInformation(
-        SystemPerformanceInformation,
-        spi,
-        si.dwNumberOfProcessors * sizeof(_SYSTEM_PERFORMANCE_INFORMATION),
-        NULL);
-    if (status != 0) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    // get DPCs
-    InterruptInformation = \
-        malloc(sizeof(_SYSTEM_INTERRUPT_INFORMATION) *
-               si.dwNumberOfProcessors);
-    if (InterruptInformation == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-    status = NtQuerySystemInformation(
-        SystemInterruptInformation,
-        InterruptInformation,
-        si.dwNumberOfProcessors * sizeof(SYSTEM_INTERRUPT_INFORMATION),
-        NULL);
-    if (status != 0) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-    for (i = 0; i < si.dwNumberOfProcessors; i++) {
-        dpcs += InterruptInformation[i].DpcCount;
-    }
-
-    // get interrupts
-    sppi = (_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *) \
-        malloc(si.dwNumberOfProcessors * \
-               sizeof(_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION));
-    if (sppi == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    status = NtQuerySystemInformation(
-        SystemProcessorPerformanceInformation,
-        sppi,
-        si.dwNumberOfProcessors * sizeof
-            (_SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION),
-        NULL);
-    if (status != 0) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    for (i = 0; i < si.dwNumberOfProcessors; i++) {
-        interrupts += sppi[i].InterruptCount;
-    }
-
-
-    // done
-    free(spi);
-    free(InterruptInformation);
-    FreeLibrary(hNtDll);
-    return Py_BuildValue(
-        "kkkk",
-        spi->ContextSwitches,
-        interrupts,
-        (unsigned long)dpcs,
-        spi->SystemCalls
-    );
-
-error:
-    if (spi)
-        free(spi);
-    if (InterruptInformation)
-        free(InterruptInformation);
-    if (hNtDll)
-        FreeLibrary(hNtDll);
-    return NULL;
-}
-
-
-// ------------------------ Python init ---------------------------
-
-static PyMethodDef
-PsutilMethods[] = {
 
+static PyMethodDef PsutilMethods[] = {
     // --- per-process functions
-
-    {"proc_cmdline", psutil_proc_cmdline, METH_VARARGS,
-     "Return process cmdline as a list of cmdline arguments"},
-    {"proc_environ", psutil_proc_environ, METH_VARARGS,
-     "Return process environment data"},
-    {"proc_exe", psutil_proc_exe, METH_VARARGS,
-     "Return path of the process executable"},
-    {"proc_name", psutil_proc_name, METH_VARARGS,
-     "Return process name"},
-    {"proc_kill", psutil_proc_kill, METH_VARARGS,
-     "Kill the process identified by the given PID"},
-    {"proc_cpu_times", psutil_proc_cpu_times, METH_VARARGS,
-     "Return tuple of user/kern time for the given PID"},
-    {"proc_create_time", psutil_proc_create_time, METH_VARARGS,
-     "Return a float indicating the process create time expressed in "
-     "seconds since the epoch"},
-    {"proc_memory_info", psutil_proc_memory_info, METH_VARARGS,
-     "Return a tuple of process memory information"},
-    {"proc_memory_info_2", psutil_proc_memory_info_2, METH_VARARGS,
-     "Alternate implementation"},
-    {"proc_memory_uss", psutil_proc_memory_uss, METH_VARARGS,
-     "Return the USS of the process"},
-    {"proc_cwd", psutil_proc_cwd, METH_VARARGS,
-     "Return process current working directory"},
-    {"proc_suspend", psutil_proc_suspend, METH_VARARGS,
-     "Suspend a process"},
-    {"proc_resume", psutil_proc_resume, METH_VARARGS,
-     "Resume a process"},
-    {"proc_open_files", psutil_proc_open_files, METH_VARARGS,
-     "Return files opened by process"},
-    {"proc_username", psutil_proc_username, METH_VARARGS,
-     "Return the username of a process"},
-    {"proc_threads", psutil_proc_threads, METH_VARARGS,
-     "Return process threads information as a list of tuple"},
-    {"proc_wait", psutil_proc_wait, METH_VARARGS,
-     "Wait for process to terminate and return its exit code."},
-    {"proc_priority_get", psutil_proc_priority_get, METH_VARARGS,
-     "Return process priority."},
-    {"proc_priority_set", psutil_proc_priority_set, METH_VARARGS,
-     "Set process priority."},
-#if (_WIN32_WINNT >= 0x0600)  // Windows Vista
-    {"proc_io_priority_get", psutil_proc_io_priority_get, METH_VARARGS,
-     "Return process IO priority."},
-    {"proc_io_priority_set", psutil_proc_io_priority_set, METH_VARARGS,
-     "Set process IO priority."},
-#endif
-    {"proc_cpu_affinity_get", psutil_proc_cpu_affinity_get, METH_VARARGS,
-     "Return process CPU affinity as a bitmask."},
-    {"proc_cpu_affinity_set", psutil_proc_cpu_affinity_set, METH_VARARGS,
-     "Set process CPU affinity."},
-    {"proc_io_counters", psutil_proc_io_counters, METH_VARARGS,
-     "Get process I/O counters."},
-    {"proc_is_suspended", psutil_proc_is_suspended, METH_VARARGS,
-     "Return True if one of the process threads is in a suspended state"},
-    {"proc_num_handles", psutil_proc_num_handles, METH_VARARGS,
-     "Return the number of handles opened by process."},
-    {"proc_memory_maps", psutil_proc_memory_maps, METH_VARARGS,
-     "Return a list of process's memory mappings"},
+    {"proc_cmdline",
+     (PyCFunction)(void (*)(void))psutil_proc_cmdline,
+     METH_VARARGS | METH_KEYWORDS},
+    {"proc_cpu_affinity_get", psutil_proc_cpu_affinity_get, METH_VARARGS},
+    {"proc_cpu_affinity_set", psutil_proc_cpu_affinity_set, METH_VARARGS},
+    {"proc_cwd", psutil_proc_cwd, METH_VARARGS},
+    {"proc_environ", psutil_proc_environ, METH_VARARGS},
+    {"proc_exe", psutil_proc_exe, METH_VARARGS},
+    {"proc_io_counters", psutil_proc_io_counters, METH_VARARGS},
+    {"proc_io_priority_get", psutil_proc_io_priority_get, METH_VARARGS},
+    {"proc_io_priority_set", psutil_proc_io_priority_set, METH_VARARGS},
+    {"proc_kill", psutil_proc_kill, METH_VARARGS},
+    {"proc_memory_info", psutil_proc_memory_info, METH_VARARGS},
+    {"proc_memory_maps", psutil_proc_memory_maps, METH_VARARGS},
+    {"proc_memory_uss", psutil_proc_memory_uss, METH_VARARGS},
+    {"proc_num_handles", psutil_proc_num_handles, METH_VARARGS},
+    {"proc_open_files", psutil_proc_open_files, METH_VARARGS},
+    {"proc_ppid", psutil_proc_ppid, METH_VARARGS},
+    {"proc_priority_get", psutil_proc_priority_get, METH_VARARGS},
+    {"proc_priority_set", psutil_proc_priority_set, METH_VARARGS},
+    {"proc_suspend_or_resume", psutil_proc_suspend_or_resume, METH_VARARGS},
+    {"proc_threads", psutil_proc_threads, METH_VARARGS},
+    {"proc_times", psutil_proc_times, METH_VARARGS},
+    {"proc_username", psutil_proc_username, METH_VARARGS},
+    {"proc_wait", psutil_proc_wait, METH_VARARGS},
 
     // --- alternative pinfo interface
-    {"proc_info", psutil_proc_info, METH_VARARGS,
-     "Various process information"},
+    {"proc_oneshot", psutil_proc_oneshot, METH_VARARGS},
 
     // --- system-related functions
-    {"pids", psutil_pids, METH_VARARGS,
-     "Returns a list of PIDs currently running on the system"},
-    {"ppid_map", psutil_ppid_map, METH_VARARGS,
-     "Return a {pid:ppid, ...} dict for all running processes"},
-    {"pid_exists", psutil_pid_exists, METH_VARARGS,
-     "Determine if the process exists in the current process list."},
-    {"cpu_count_logical", psutil_cpu_count_logical, METH_VARARGS,
-     "Returns the number of logical CPUs on the system"},
-    {"cpu_count_phys", psutil_cpu_count_phys, METH_VARARGS,
-     "Returns the number of physical CPUs on the system"},
-    {"boot_time", psutil_boot_time, METH_VARARGS,
-     "Return the system boot time expressed in seconds since the epoch."},
-    {"virtual_mem", psutil_virtual_mem, METH_VARARGS,
-     "Return the total amount of physical memory, in bytes"},
-    {"cpu_times", psutil_cpu_times, METH_VARARGS,
-     "Return system cpu times as a list"},
-    {"per_cpu_times", psutil_per_cpu_times, METH_VARARGS,
-     "Return system per-cpu times as a list of tuples"},
-    {"disk_usage", psutil_disk_usage, METH_VARARGS,
-     "Return path's disk total and free as a Python tuple."},
-    {"net_io_counters", psutil_net_io_counters, METH_VARARGS,
-     "Return dict of tuples of networks I/O information."},
-    {"disk_io_counters", psutil_disk_io_counters, METH_VARARGS,
-     "Return dict of tuples of disks I/O information."},
-    {"users", psutil_users, METH_VARARGS,
-     "Return a list of currently connected users."},
-    {"disk_partitions", psutil_disk_partitions, METH_VARARGS,
-     "Return disk partitions."},
-    {"net_connections", psutil_net_connections, METH_VARARGS,
-     "Return system-wide connections"},
-    {"net_if_addrs", psutil_net_if_addrs, METH_VARARGS,
-     "Return NICs addresses."},
-    {"net_if_stats", psutil_net_if_stats, METH_VARARGS,
-     "Return NICs stats."},
-    {"cpu_stats", psutil_cpu_stats, METH_VARARGS,
-     "Return NICs stats."},
+    {"boot_time", psutil_boot_time, METH_VARARGS},
+    {"cpu_count_cores", psutil_cpu_count_cores, METH_VARARGS},
+    {"cpu_count_logical", psutil_cpu_count_logical, METH_VARARGS},
+    {"cpu_freq", psutil_cpu_freq, METH_VARARGS},
+    {"cpu_stats", psutil_cpu_stats, METH_VARARGS},
+    {"cpu_times", psutil_cpu_times, METH_VARARGS},
+    {"disk_io_counters", psutil_disk_io_counters, METH_VARARGS},
+    {"disk_partitions", psutil_disk_partitions, METH_VARARGS},
+    {"disk_usage", psutil_disk_usage, METH_VARARGS},
+    {"getloadavg", (PyCFunction)psutil_get_loadavg, METH_VARARGS},
+    {"getpagesize", psutil_getpagesize, METH_VARARGS},
+    {"swap_percent", psutil_swap_percent, METH_NOARGS},
+    {"init_loadavg_counter",
+     (PyCFunction)psutil_init_loadavg_counter,
+     METH_NOARGS},
+    {"heap_info", psutil_heap_info, METH_VARARGS},
+    {"heap_trim", psutil_heap_trim, METH_VARARGS},
+    {"net_connections", psutil_net_connections, METH_VARARGS},
+    {"net_if_addrs", psutil_net_if_addrs, METH_VARARGS},
+    {"net_if_stats", psutil_net_if_stats, METH_VARARGS},
+    {"net_io_counters", psutil_net_io_counters, METH_VARARGS},
+    {"per_cpu_times", psutil_per_cpu_times, METH_VARARGS},
+    {"pid_exists", psutil_pid_exists, METH_VARARGS},
+    {"pids", psutil_pids, METH_VARARGS},
+    {"ppid_map", psutil_ppid_map, METH_VARARGS},
+    {"sensors_battery", psutil_sensors_battery, METH_VARARGS},
+    {"users", psutil_users, METH_VARARGS},
 
     // --- windows services
-    {"winservice_enumerate", psutil_winservice_enumerate, METH_VARARGS,
-     "List all services"},
-    {"winservice_query_config", psutil_winservice_query_config, METH_VARARGS,
-     "Return service config"},
-    {"winservice_query_status", psutil_winservice_query_status, METH_VARARGS,
-     "Return service config"},
-    {"winservice_query_descr", psutil_winservice_query_descr, METH_VARARGS,
-     "Return the description of a service"},
-    {"winservice_start", psutil_winservice_start, METH_VARARGS,
-     "Start a service"},
-    {"winservice_stop", psutil_winservice_stop, METH_VARARGS,
-     "Stop a service"},
-
-    // --- windows API bindings
-    {"win32_QueryDosDevice", psutil_win32_QueryDosDevice, METH_VARARGS,
-     "QueryDosDevice binding"},
-
-    {NULL, NULL, 0, NULL}
-};
-
-
-struct module_state {
-    PyObject *error;
-};
+    {"winservice_enumerate", psutil_winservice_enumerate, METH_VARARGS},
+    {"winservice_query_config", psutil_winservice_query_config, METH_VARARGS},
+    {"winservice_query_descr", psutil_winservice_query_descr, METH_VARARGS},
+    {"winservice_query_status", psutil_winservice_query_status, METH_VARARGS},
+    {"winservice_start", psutil_winservice_start, METH_VARARGS},
+    {"winservice_stop", psutil_winservice_stop, METH_VARARGS},
 
-#if PY_MAJOR_VERSION >= 3
-#define GETSTATE(m) ((struct module_state*)PyModule_GetState(m))
-#else
-#define GETSTATE(m) (&_state)
-static struct module_state _state;
-#endif
+    // --- direct Windows APIs
+    {"GetPerformanceInfo", psutil_GetPerformanceInfo, METH_VARARGS},
+    {"QueryDosDevice", psutil_QueryDosDevice, METH_VARARGS},
 
-#if PY_MAJOR_VERSION >= 3
+    // --- others
+    {"check_pid_range", psutil_check_pid_range, METH_VARARGS},
+    {"set_debug", psutil_set_debug, METH_VARARGS},
 
-static int psutil_windows_traverse(PyObject *m, visitproc visit, void *arg) {
-    Py_VISIT(GETSTATE(m)->error);
-    return 0;
-}
-
-static int psutil_windows_clear(PyObject *m) {
-    Py_CLEAR(GETSTATE(m)->error);
-    return 0;
-}
-
-static struct PyModuleDef moduledef = {
-    PyModuleDef_HEAD_INIT,
-    "psutil_windows",
-    NULL,
-    sizeof(struct module_state),
-    PsutilMethods,
-    NULL,
-    psutil_windows_traverse,
-    psutil_windows_clear,
-    NULL
+    {NULL, NULL, 0, NULL}
 };
 
-#define INITERROR return NULL
-
-PyMODINIT_FUNC PyInit__psutil_windows(void)
 
-#else
-#define INITERROR return
-void init_psutil_windows(void)
-#endif
-{
-    struct module_state *st = NULL;
-#if PY_MAJOR_VERSION >= 3
-    PyObject *module = PyModule_Create(&moduledef);
-#else
-    PyObject *module = Py_InitModule("_psutil_windows", PsutilMethods);
-#endif
+static int module_loaded = 0;
 
-    if (module == NULL) {
-        INITERROR;
-    }
-
-    st = GETSTATE(module);
-    st->error = PyErr_NewException("_psutil_windows.Error", NULL, NULL);
-    if (st->error == NULL) {
-        Py_DECREF(module);
-        INITERROR;
-    }
-
-    PyModule_AddIntConstant(module, "version", PSUTIL_VERSION);
+static int
+psutil_add_constants(PyObject *mod) {
+    // version constant
+    PSUTIL_ADD_INT(mod, "version", PSUTIL_VERSION);
 
     // process status constants
     // http://msdn.microsoft.com/en-us/library/ms683211(v=vs.85).aspx
-    PyModule_AddIntConstant(
-        module, "ABOVE_NORMAL_PRIORITY_CLASS", ABOVE_NORMAL_PRIORITY_CLASS);
-    PyModule_AddIntConstant(
-        module, "BELOW_NORMAL_PRIORITY_CLASS", BELOW_NORMAL_PRIORITY_CLASS);
-    PyModule_AddIntConstant(
-        module, "HIGH_PRIORITY_CLASS", HIGH_PRIORITY_CLASS);
-    PyModule_AddIntConstant(
-        module, "IDLE_PRIORITY_CLASS", IDLE_PRIORITY_CLASS);
-    PyModule_AddIntConstant(
-        module, "NORMAL_PRIORITY_CLASS", NORMAL_PRIORITY_CLASS);
-    PyModule_AddIntConstant(
-        module, "REALTIME_PRIORITY_CLASS", REALTIME_PRIORITY_CLASS);
+    PSUTIL_ADD_INT(
+        mod, "ABOVE_NORMAL_PRIORITY_CLASS", ABOVE_NORMAL_PRIORITY_CLASS
+    );
+    PSUTIL_ADD_INT(
+        mod, "BELOW_NORMAL_PRIORITY_CLASS", BELOW_NORMAL_PRIORITY_CLASS
+    );
+    PSUTIL_ADD_INT(mod, "HIGH_PRIORITY_CLASS", HIGH_PRIORITY_CLASS);
+    PSUTIL_ADD_INT(mod, "IDLE_PRIORITY_CLASS", IDLE_PRIORITY_CLASS);
+    PSUTIL_ADD_INT(mod, "NORMAL_PRIORITY_CLASS", NORMAL_PRIORITY_CLASS);
+    PSUTIL_ADD_INT(mod, "REALTIME_PRIORITY_CLASS", REALTIME_PRIORITY_CLASS);
 
     // connection status constants
     // http://msdn.microsoft.com/en-us/library/cc669305.aspx
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_CLOSED", MIB_TCP_STATE_CLOSED);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_CLOSING", MIB_TCP_STATE_CLOSING);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_CLOSE_WAIT", MIB_TCP_STATE_CLOSE_WAIT);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_LISTEN", MIB_TCP_STATE_LISTEN);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_ESTAB", MIB_TCP_STATE_ESTAB);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_SYN_SENT", MIB_TCP_STATE_SYN_SENT);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_SYN_RCVD", MIB_TCP_STATE_SYN_RCVD);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_FIN_WAIT1", MIB_TCP_STATE_FIN_WAIT1);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_FIN_WAIT2", MIB_TCP_STATE_FIN_WAIT2);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_LAST_ACK", MIB_TCP_STATE_LAST_ACK);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_TIME_WAIT", MIB_TCP_STATE_TIME_WAIT);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_TIME_WAIT", MIB_TCP_STATE_TIME_WAIT);
-    PyModule_AddIntConstant(
-        module, "MIB_TCP_STATE_DELETE_TCB", MIB_TCP_STATE_DELETE_TCB);
-    PyModule_AddIntConstant(
-        module, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE);
-
-    // service status constants
-    /*
-    PyModule_AddIntConstant(
-        module, "SERVICE_CONTINUE_PENDING", SERVICE_CONTINUE_PENDING);
-    PyModule_AddIntConstant(
-        module, "SERVICE_PAUSE_PENDING", SERVICE_PAUSE_PENDING);
-    PyModule_AddIntConstant(
-        module, "SERVICE_PAUSED", SERVICE_PAUSED);
-    PyModule_AddIntConstant(
-        module, "SERVICE_RUNNING", SERVICE_RUNNING);
-    PyModule_AddIntConstant(
-        module, "SERVICE_START_PENDING", SERVICE_START_PENDING);
-    PyModule_AddIntConstant(
-        module, "SERVICE_STOP_PENDING", SERVICE_STOP_PENDING);
-    PyModule_AddIntConstant(
-        module, "SERVICE_STOPPED", SERVICE_STOPPED);
-    */
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_CLOSED", MIB_TCP_STATE_CLOSED);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_CLOSING", MIB_TCP_STATE_CLOSING);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_CLOSE_WAIT", MIB_TCP_STATE_CLOSE_WAIT);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_LISTEN", MIB_TCP_STATE_LISTEN);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_ESTAB", MIB_TCP_STATE_ESTAB);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_SYN_SENT", MIB_TCP_STATE_SYN_SENT);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_SYN_RCVD", MIB_TCP_STATE_SYN_RCVD);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_FIN_WAIT1", MIB_TCP_STATE_FIN_WAIT1);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_FIN_WAIT2", MIB_TCP_STATE_FIN_WAIT2);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_LAST_ACK", MIB_TCP_STATE_LAST_ACK);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_TIME_WAIT", MIB_TCP_STATE_TIME_WAIT);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_TIME_WAIT", MIB_TCP_STATE_TIME_WAIT);
+    PSUTIL_ADD_INT(mod, "MIB_TCP_STATE_DELETE_TCB", MIB_TCP_STATE_DELETE_TCB);
+    PSUTIL_ADD_INT(mod, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE);
 
     // ...for internal use in _psutil_windows.py
-    PyModule_AddIntConstant(
-        module, "INFINITE", INFINITE);
-    PyModule_AddIntConstant(
-        module, "ERROR_ACCESS_DENIED", ERROR_ACCESS_DENIED);
-    PyModule_AddIntConstant(
-        module, "ERROR_INVALID_NAME", ERROR_INVALID_NAME);
-    PyModule_AddIntConstant(
-        module, "ERROR_SERVICE_DOES_NOT_EXIST", ERROR_SERVICE_DOES_NOT_EXIST);
+    PSUTIL_ADD_INT(mod, "INFINITE", INFINITE);
+    PSUTIL_ADD_INT(mod, "ERROR_ACCESS_DENIED", ERROR_ACCESS_DENIED);
+    PSUTIL_ADD_INT(mod, "ERROR_INVALID_NAME", ERROR_INVALID_NAME);
+    PSUTIL_ADD_INT(
+        mod, "ERROR_SERVICE_DOES_NOT_EXIST", ERROR_SERVICE_DOES_NOT_EXIST
+    );
+    PSUTIL_ADD_INT(mod, "ERROR_PRIVILEGE_NOT_HELD", ERROR_PRIVILEGE_NOT_HELD);
 
-    // set SeDebug for the current process
-    psutil_set_se_debug();
+    return 0;
+}
+
+
+static int
+psutil_exec(PyObject *mod) {
+    if (psutil_setup() != 0)
+        return -1;
+
+    // InitializeCriticalSection() (called by psutil_setup_windows) must
+    // run only once per lock, so guard the process-wide setup.
+    if (!module_loaded) {
+        if (psutil_setup_windows() != 0)
+            return -1;
+        if (psutil_set_se_debug() != 0)
+            return -1;
+        module_loaded = 1;
+    }
+    if (psutil_add_exceptions(mod) != 0)
+        return -1;
+    if (psutil_add_constants(mod) != 0)
+        return -1;
+    return 0;
+}
 
-#if PY_MAJOR_VERSION >= 3
-    return module;
-#endif
+PyMODINIT_FUNC
+PyInit__psutil(void) {
+    return psutil_mod_init("_psutil", PsutilMethods, psutil_exec);
 }
diff --git a/psutil/_pswindows.py b/psutil/_pswindows.py
index d8aecebec2..b4cab7ed0a 100644
--- a/psutil/_pswindows.py
+++ b/psutil/_pswindows.py
@@ -4,158 +4,116 @@
 
 """Windows platform implementation."""
 
+from __future__ import annotations
+
 import contextlib
-import errno
+import enum
 import functools
 import os
+import signal
 import sys
-from collections import namedtuple
-
-from . import _common
-from . import _psutil_windows as cext
+import threading
+import time
+
+from . import _ntuples as ntp
+from ._common import ENCODING
+from ._common import AccessDenied
+from ._common import NoSuchProcess
+from ._common import TimeoutExpired
 from ._common import conn_tmap
-from ._common import isfile_strict
+from ._common import conn_to_ntuple
+from ._common import debug
+from ._common import memoize_when_activated
 from ._common import parse_environ_block
-from ._common import sockfam_to_enum
-from ._common import socktype_to_enum
 from ._common import usage_percent
-from ._compat import long
-from ._compat import lru_cache
-from ._compat import PY3
-from ._compat import xrange
-from ._psutil_windows import ABOVE_NORMAL_PRIORITY_CLASS
-from ._psutil_windows import BELOW_NORMAL_PRIORITY_CLASS
-from ._psutil_windows import HIGH_PRIORITY_CLASS
-from ._psutil_windows import IDLE_PRIORITY_CLASS
-from ._psutil_windows import NORMAL_PRIORITY_CLASS
-from ._psutil_windows import REALTIME_PRIORITY_CLASS
-
-if sys.version_info >= (3, 4):
-    import enum
-else:
-    enum = None
+from ._enums import BatteryTime
+from ._enums import ConnectionStatus
+from ._enums import NicDuplex
+from ._enums import ProcessIOPriority
+from ._enums import ProcessPriority
+from ._enums import ProcessStatus
+
+try:
+    from . import _psutil
+except ImportError as err:
+    if (
+        str(err).lower().startswith("dll load failed")
+        and sys.getwindowsversion()[0] < 6
+    ):
+        # We may get here if:
+        # 1) we are on an old Windows version
+        # 2) psutil was installed via pip + wheel
+        # See: https://github.com/giampaolo/psutil/issues/811
+        msg = "this Windows version is too old (< Windows Vista); "
+        msg += "psutil 3.4.2 is the latest version which supports Windows "
+        msg += "2000, XP and 2003 server"
+        raise RuntimeError(msg) from err
+    else:
+        raise
+
 
 # process priority constants, import from __init__.py:
 # http://msdn.microsoft.com/en-us/library/ms686219(v=vs.85).aspx
-__extra__all__ = [
-    "win_service_iter", "win_service_get",
-    "ABOVE_NORMAL_PRIORITY_CLASS", "BELOW_NORMAL_PRIORITY_CLASS",
-    "HIGH_PRIORITY_CLASS", "IDLE_PRIORITY_CLASS",
-    "NORMAL_PRIORITY_CLASS", "REALTIME_PRIORITY_CLASS",
-    "CONN_DELETE_TCB",
-    "AF_LINK",
-]
+__extra__all__ = ["win_service_iter", "win_service_get", "AF_LINK"]
 
 
 # =====================================================================
-# --- constants
+# --- globals
 # =====================================================================
 
+ERROR_PARTIAL_COPY = 299
+PYPY = '__pypy__' in sys.builtin_module_names
 
-CONN_DELETE_TCB = "DELETE_TCB"
-WAIT_TIMEOUT = 0x00000102  # 258 in decimal
-ACCESS_DENIED_SET = frozenset([errno.EPERM, errno.EACCES,
-                               cext.ERROR_ACCESS_DENIED])
-
-if enum is None:
-    AF_LINK = -1
-else:
-    AddressFamily = enum.IntEnum('AddressFamily', {'AF_LINK': -1})
-    AF_LINK = AddressFamily.AF_LINK
+AddressFamily = enum.IntEnum('AddressFamily', {'AF_LINK': -1})
+AF_LINK = AddressFamily.AF_LINK
 
 TCP_STATUSES = {
-    cext.MIB_TCP_STATE_ESTAB: _common.CONN_ESTABLISHED,
-    cext.MIB_TCP_STATE_SYN_SENT: _common.CONN_SYN_SENT,
-    cext.MIB_TCP_STATE_SYN_RCVD: _common.CONN_SYN_RECV,
-    cext.MIB_TCP_STATE_FIN_WAIT1: _common.CONN_FIN_WAIT1,
-    cext.MIB_TCP_STATE_FIN_WAIT2: _common.CONN_FIN_WAIT2,
-    cext.MIB_TCP_STATE_TIME_WAIT: _common.CONN_TIME_WAIT,
-    cext.MIB_TCP_STATE_CLOSED: _common.CONN_CLOSE,
-    cext.MIB_TCP_STATE_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
-    cext.MIB_TCP_STATE_LAST_ACK: _common.CONN_LAST_ACK,
-    cext.MIB_TCP_STATE_LISTEN: _common.CONN_LISTEN,
-    cext.MIB_TCP_STATE_CLOSING: _common.CONN_CLOSING,
-    cext.MIB_TCP_STATE_DELETE_TCB: CONN_DELETE_TCB,
-    cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
+    _psutil.MIB_TCP_STATE_ESTAB: ConnectionStatus.CONN_ESTABLISHED,
+    _psutil.MIB_TCP_STATE_SYN_SENT: ConnectionStatus.CONN_SYN_SENT,
+    _psutil.MIB_TCP_STATE_SYN_RCVD: ConnectionStatus.CONN_SYN_RECV,
+    _psutil.MIB_TCP_STATE_FIN_WAIT1: ConnectionStatus.CONN_FIN_WAIT1,
+    _psutil.MIB_TCP_STATE_FIN_WAIT2: ConnectionStatus.CONN_FIN_WAIT2,
+    _psutil.MIB_TCP_STATE_TIME_WAIT: ConnectionStatus.CONN_TIME_WAIT,
+    _psutil.MIB_TCP_STATE_CLOSED: ConnectionStatus.CONN_CLOSE,
+    _psutil.MIB_TCP_STATE_CLOSE_WAIT: ConnectionStatus.CONN_CLOSE_WAIT,
+    _psutil.MIB_TCP_STATE_LAST_ACK: ConnectionStatus.CONN_LAST_ACK,
+    _psutil.MIB_TCP_STATE_LISTEN: ConnectionStatus.CONN_LISTEN,
+    _psutil.MIB_TCP_STATE_CLOSING: ConnectionStatus.CONN_CLOSING,
+    _psutil.MIB_TCP_STATE_DELETE_TCB: ConnectionStatus.CONN_DELETE_TCB,
+    _psutil.PSUTIL_CONN_NONE: ConnectionStatus.CONN_NONE,
 }
 
-if enum is not None:
-    class Priority(enum.IntEnum):
-        ABOVE_NORMAL_PRIORITY_CLASS = ABOVE_NORMAL_PRIORITY_CLASS
-        BELOW_NORMAL_PRIORITY_CLASS = BELOW_NORMAL_PRIORITY_CLASS
-        HIGH_PRIORITY_CLASS = HIGH_PRIORITY_CLASS
-        IDLE_PRIORITY_CLASS = IDLE_PRIORITY_CLASS
-        NORMAL_PRIORITY_CLASS = NORMAL_PRIORITY_CLASS
-        REALTIME_PRIORITY_CLASS = REALTIME_PRIORITY_CLASS
-
-    globals().update(Priority.__members__)
-
-
-# =====================================================================
-# --- named tuples
-# =====================================================================
-
-
-scputimes = namedtuple('scputimes',
-                       ['user', 'system', 'idle', 'interrupt', 'dpc'])
-svmem = namedtuple('svmem', ['total', 'available', 'percent', 'used', 'free'])
-pmem = namedtuple(
-    'pmem', ['rss', 'vms',
-             'num_page_faults', 'peak_wset', 'wset', 'peak_paged_pool',
-             'paged_pool', 'peak_nonpaged_pool', 'nonpaged_pool',
-             'pagefile', 'peak_pagefile', 'private'])
-pfullmem = namedtuple('pfullmem', pmem._fields + ('uss', ))
-pmmap_grouped = namedtuple('pmmap_grouped', ['path', 'rss'])
-pmmap_ext = namedtuple(
-    'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields))
-ntpinfo = namedtuple(
-    'ntpinfo', ['num_handles', 'ctx_switches', 'user_time', 'kernel_time',
-                'create_time', 'num_threads', 'io_rcount', 'io_wcount',
-                'io_rbytes', 'io_wbytes'])
-
-
-# =====================================================================
-# --- exceptions
-# =====================================================================
-
-
-# these get overwritten on "import psutil" from the __init__.py file
-NoSuchProcess = None
-AccessDenied = None
-TimeoutExpired = None
-
 
 # =====================================================================
 # --- utils
 # =====================================================================
 
 
-@lru_cache(maxsize=512)
-def _win32_QueryDosDevice(s):
-    return cext.win32_QueryDosDevice(s)
-
-
+@functools.lru_cache(maxsize=512)
 def convert_dos_path(s):
-    # convert paths using native DOS format like:
-    # "\Device\HarddiskVolume1\Windows\systemew\file.txt"
-    # into: "C:\Windows\systemew\file.txt"
-    if PY3 and not isinstance(s, str):
-        s = s.decode('utf8')
+    r"""Convert paths using native DOS format like:
+        "\Device\HarddiskVolume1\Windows\systemew\file.txt" or
+        "\??\C:\Windows\systemew\file.txt"
+    into:
+        "C:\Windows\systemew\file.txt".
+    """
+    if s.startswith('\\\\'):
+        return s
     rawdrive = '\\'.join(s.split('\\')[:3])
-    driveletter = _win32_QueryDosDevice(rawdrive)
-    return os.path.join(driveletter, s[len(rawdrive):])
+    if rawdrive in {"\\??\\UNC", "\\Device\\Mup"}:
+        rawdrive = '\\'.join(s.split('\\')[:5])
+        driveletter = '\\\\' + '\\'.join(s.split('\\')[3:5])
+    elif rawdrive.startswith('\\??\\'):
+        driveletter = s.split('\\')[2]
+    else:
+        driveletter = _psutil.QueryDosDevice(rawdrive)
+    remainder = s[len(rawdrive) :]
+    return os.path.join(driveletter, remainder)
 
 
-def py2_strencode(s, encoding=sys.getfilesystemencoding()):
-    if PY3 or isinstance(s, str):
-        return s
-    else:
-        try:
-            return s.encode(encoding)
-        except UnicodeEncodeError:
-            # Filesystem codec failed, return the plain unicode
-            # string (this should never happen).
-            return s
+@functools.lru_cache
+def getpagesize():
+    return _psutil.getpagesize()
 
 
 # =====================================================================
@@ -164,26 +122,50 @@ def py2_strencode(s, encoding=sys.getfilesystemencoding()):
 
 
 def virtual_memory():
-    """System virtual memory as a namedtuple."""
-    mem = cext.virtual_mem()
-    totphys, availphys, totpagef, availpagef, totvirt, freevirt = mem
-    #
-    total = totphys
-    avail = availphys
-    free = availphys
+    """System virtual memory as a named tuple."""
+    info = _psutil.GetPerformanceInfo()
+    pagesize = info["PageSize"]
+    total = info["PhysicalTotal"] * pagesize
+    avail = info["PhysicalAvailable"] * pagesize
+    cached = info["SystemCache"] * pagesize
+    wired = info["KernelNonpaged"] * pagesize
+    free = avail
     used = total - avail
-    percent = usage_percent((total - avail), total, _round=1)
-    return svmem(total, avail, percent, used, free)
+    percent = usage_percent((total - avail), total, round_=1)
+    return ntp.svmem(total, avail, percent, used, free, cached, wired)
 
 
 def swap_memory():
     """Swap system memory as a (total, used, free, sin, sout) tuple."""
-    mem = cext.virtual_mem()
-    total = mem[2]
-    free = mem[3]
-    used = total - free
-    percent = usage_percent(used, total, _round=1)
-    return _common.sswap(total, used, free, percent, 0, 0)
+    info = _psutil.GetPerformanceInfo()
+    pagesize = info["PageSize"]
+    total_phys = info["PhysicalTotal"] * pagesize
+    # CommitLimit == Maximum pages that can be committed into RAM +
+    # page file (swap). In the context of swap, it's the total "system
+    # memory" (physical + virtual), thus subtract the physical part
+    # from it to get the "total swap".
+    total_system = info["CommitLimit"] * pagesize  # physical + swap
+    total = total_system - total_phys
+
+    # commit total is incremented immediately (decrementing free_system)
+    # while the corresponding free physical value is not decremented until
+    # pages are accessed, so we can't use free system memory for swap.
+    # instead, we calculate page file usage based on performance counter
+    if total > 0:
+        percentswap = _psutil.swap_percent()
+        used = int(0.01 * percentswap * total)
+    else:
+        percentswap = 0.0
+        used = 0
+
+    free = total - used
+    percent = round(percentswap, 1)
+    return ntp.sswap(total, used, free, percent, 0, 0)
+
+
+# malloc / heap functions
+heap_info = _psutil.heap_info
+heap_trim = _psutil.heap_trim
 
 
 # =====================================================================
@@ -191,27 +173,29 @@ def swap_memory():
 # =====================================================================
 
 
-disk_io_counters = cext.disk_io_counters
+disk_io_counters = _psutil.disk_io_counters
 
 
 def disk_usage(path):
     """Return disk usage associated with path."""
+    if isinstance(path, bytes):
+        # XXX: do we want to use "strict"? Probably yes, in order
+        # to fail immediately. After all we are accepting input here...
+        path = path.decode(ENCODING, errors="strict")
     try:
-        total, free = cext.disk_usage(path)
-    except WindowsError:
-        if not os.path.exists(path):
-            msg = "No such file or directory: '%s'" % path
-            raise OSError(errno.ENOENT, msg)
-        raise
-    used = total - free
-    percent = usage_percent(used, total, _round=1)
-    return _common.sdiskusage(total, used, free, percent)
+        total, used, free = _psutil.disk_usage(path)
+    except NotADirectoryError:
+        if not os.path.isabs(path):
+            path = os.path.join(os.getcwd(), path)
+        total, used, free = _psutil.disk_usage(os.path.dirname(path))
+    percent = usage_percent(used, total, round_=1)
+    return ntp.sdiskusage(total, used, free, percent)
 
 
 def disk_partitions(all):
     """Return disk partitions."""
-    rawlist = cext.disk_partitions(all)
-    return [_common.sdiskpart(*x) for x in rawlist]
+    rawlist = _psutil.disk_partitions(all)
+    return [ntp.sdiskpart(*x) for x in rawlist]
 
 
 # =====================================================================
@@ -221,40 +205,78 @@ def disk_partitions(all):
 
 def cpu_times():
     """Return system CPU times as a named tuple."""
-    user, system, idle = cext.cpu_times()
+    user, system, idle = _psutil.cpu_times()
     # Internally, GetSystemTimes() is used, and it doesn't return
-    # interrupt and dpc times. cext.per_cpu_times() does, so we
+    # interrupt and dpc times. _psutil.per_cpu_times() does, so we
     # rely on it to get those only.
-    percpu_summed = scputimes(*[sum(n) for n in zip(*cext.per_cpu_times())])
-    return scputimes(user, system, idle,
-                     percpu_summed.interrupt, percpu_summed.dpc)
+    percpu_summed = ntp.scputimes(
+        *[sum(n) for n in zip(*_psutil.per_cpu_times())]
+    )
+    return ntp.scputimes(
+        user, system, idle, percpu_summed.irq, percpu_summed.dpc
+    )
 
 
 def per_cpu_times():
     """Return system per-CPU times as a list of named tuples."""
     ret = []
-    for user, system, idle, interrupt, dpc in cext.per_cpu_times():
-        item = scputimes(user, system, idle, interrupt, dpc)
+    for user, system, idle, irq, dpc in _psutil.per_cpu_times():
+        item = ntp.scputimes(user, system, idle, irq, dpc)
         ret.append(item)
     return ret
 
 
 def cpu_count_logical():
     """Return the number of logical CPUs in the system."""
-    return cext.cpu_count_logical()
+    return _psutil.cpu_count_logical()
 
 
-def cpu_count_physical():
-    """Return the number of physical CPUs in the system."""
-    return cext.cpu_count_phys()
+def cpu_count_cores():
+    """Return the number of CPU cores in the system."""
+    return _psutil.cpu_count_cores()
 
 
 def cpu_stats():
     """Return CPU statistics."""
-    ctx_switches, interrupts, dpcs, syscalls = cext.cpu_stats()
+    ctx_switches, interrupts, _dpcs, syscalls = _psutil.cpu_stats()
     soft_interrupts = 0
-    return _common.scpustats(ctx_switches, interrupts, soft_interrupts,
-                             syscalls)
+    return ntp.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls)
+
+
+def cpu_freq():
+    """Return CPU frequency.
+    On Windows per-cpu frequency is not supported.
+    """
+    curr, max_ = _psutil.cpu_freq()
+    min_ = 0.0
+    return [ntp.scpufreq(float(curr), min_, float(max_))]
+
+
+_loadavg_initialized = False
+_lock = threading.Lock()
+
+
+def _getloadavg_impl():
+    # Drop to 2 decimal points which is what Linux does
+    raw_loads = _psutil.getloadavg()
+    return tuple(round(load, 2) for load in raw_loads)
+
+
+def getloadavg():
+    """Return the number of processes in the system run queue averaged
+    over the last 1, 5, and 15 minutes respectively as a tuple.
+    """
+    global _loadavg_initialized
+
+    if _loadavg_initialized:
+        return _getloadavg_impl()
+
+    with _lock:
+        if not _loadavg_initialized:
+            _psutil.init_loadavg_counter()
+            _loadavg_initialized = True
+
+    return _getloadavg_impl()
 
 
 # =====================================================================
@@ -266,48 +288,70 @@ def net_connections(kind, _pid=-1):
     """Return socket connections.  If pid == -1 return system-wide
     connections (as opposed to connections opened by one process only).
     """
-    if kind not in conn_tmap:
-        raise ValueError("invalid %r kind argument; choose between %s"
-                         % (kind, ', '.join([repr(x) for x in conn_tmap])))
     families, types = conn_tmap[kind]
-    rawlist = cext.net_connections(_pid, families, types)
+    rawlist = _psutil.net_connections(_pid, families, types)
     ret = set()
     for item in rawlist:
         fd, fam, type, laddr, raddr, status, pid = item
-        status = TCP_STATUSES[status]
-        fam = sockfam_to_enum(fam)
-        type = socktype_to_enum(type)
-        if _pid == -1:
-            nt = _common.sconn(fd, fam, type, laddr, raddr, status, pid)
-        else:
-            nt = _common.pconn(fd, fam, type, laddr, raddr, status)
+        nt = conn_to_ntuple(
+            fd,
+            fam,
+            type,
+            laddr,
+            raddr,
+            status,
+            TCP_STATUSES,
+            pid=pid if _pid == -1 else None,
+        )
         ret.add(nt)
     return list(ret)
 
 
 def net_if_stats():
-    ret = cext.net_if_stats()
-    for name, items in ret.items():
-        name = py2_strencode(name)
+    """Get NIC stats (isup, duplex, speed, mtu)."""
+    ret = {}
+    rawdict = _psutil.net_if_stats()
+    for name, items in rawdict.items():
         isup, duplex, speed, mtu = items
-        if hasattr(_common, 'NicDuplex'):
-            duplex = _common.NicDuplex(duplex)
-        ret[name] = _common.snicstats(isup, duplex, speed, mtu)
+        duplex = NicDuplex(duplex)
+        ret[name] = ntp.snicstats(isup, duplex, speed, mtu, '')
     return ret
 
 
 def net_io_counters():
-    ret = cext.net_io_counters()
-    return dict([(py2_strencode(k), v) for k, v in ret.items()])
+    """Return network I/O statistics for every network interface
+    installed on the system as a dict of raw tuples.
+    """
+    return _psutil.net_io_counters()
 
 
 def net_if_addrs():
-    ret = []
-    for items in cext.net_if_addrs():
-        items = list(items)
-        items[0] = py2_strencode(items[0])
-        ret.append(items)
-    return ret
+    """Return the addresses associated to each NIC."""
+    return _psutil.net_if_addrs()
+
+
+# =====================================================================
+# --- sensors
+# =====================================================================
+
+
+def sensors_battery():
+    """Return battery information."""
+    # For constants meaning see:
+    # https://msdn.microsoft.com/en-us/library/windows/desktop/aa373232(v=vs.85).aspx
+    acline_status, flags, percent, secsleft = _psutil.sensors_battery()
+    power_plugged = acline_status == 1
+    no_battery = bool(flags & 128)
+    charging = bool(flags & 8)
+
+    if no_battery:
+        return None
+    if power_plugged or charging:
+        secsleft = BatteryTime.POWER_TIME_UNLIMITED
+    elif secsleft == -1:
+        secsleft = BatteryTime.POWER_TIME_UNKNOWN
+
+    return ntp.sbattery(percent, secsleft, power_plugged)
 
 
 # =====================================================================
@@ -316,18 +360,19 @@ def net_if_addrs():
 
 
 def boot_time():
-    """The system boot time expressed in seconds since the epoch."""
-    return cext.boot_time()
+    """The system boot time expressed in seconds since the epoch. This
+    also includes the time spent during hibernate / suspend.
+    """
+    return _psutil.boot_time()
 
 
 def users():
-    """Return currently connected users as a list of namedtuples."""
+    """Return currently connected users as a list of named tuples."""
     retlist = []
-    rawlist = cext.users()
+    rawlist = _psutil.users()
     for item in rawlist:
         user, hostname, tstamp = item
-        user = py2_strencode(user)
-        nt = _common.suser(user, None, hostname, tstamp)
+        nt = ntp.suser(user, None, hostname, tstamp, None)
         retlist.append(nt)
     return retlist
 
@@ -338,8 +383,8 @@ def users():
 
 
 def win_service_iter():
-    """Return a list of WindowsService instances."""
-    for name, display_name in cext.winservice_enumerate():
+    """Yields a list of WindowsService instances."""
+    for name, display_name in _psutil.winservice_enumerate():
         yield WindowsService(name, display_name)
 
 
@@ -350,45 +395,46 @@ def win_service_get(name):
     return service
 
 
-class WindowsService(object):
+class WindowsService:  # noqa: PLW1641
     """Represents an installed Windows service."""
 
-    def __init__(self, name, display_name):
+    def __init__(self, name: str, display_name: str):
         self._name = name
         self._display_name = display_name
 
     def __str__(self):
-        details = "(name=%r, display_name=%r)" % (
-            self._name, self._display_name)
-        return "%s%s" % (self.__class__.__name__, details)
+        details = f"(name={self._name!r}, display_name={self._display_name!r})"
+        return f"{self.__class__.__name__}{details}"
 
     def __repr__(self):
-        return "<%s at %s>" % (self.__str__(), id(self))
+        return f"<{self.__str__()} at {id(self)}>"
 
-    def __eq__(self, other):
+    def __eq__(self, other: object):
         # Test for equality with another WindosService object based
         # on name.
         if not isinstance(other, WindowsService):
             return NotImplemented
         return self._name == other._name
 
-    def __ne__(self, other):
+    def __ne__(self, other: object):
         return not self == other
 
     def _query_config(self):
         with self._wrap_exceptions():
-            display_name, binpath, username, start_type = \
-                cext.winservice_query_config(self._name)
+            display_name, binpath, username, start_type = (
+                _psutil.winservice_query_config(self._name)
+            )
         # XXX - update _self.display_name?
         return dict(
             display_name=display_name,
             binpath=binpath,
             username=username,
-            start_type=start_type)
+            start_type=start_type,
+        )
 
     def _query_status(self):
         with self._wrap_exceptions():
-            status, pid = cext.winservice_query_status(self._name)
+            status, pid = _psutil.winservice_query_status(self._name)
         if pid == 0:
             pid = None
         return dict(status=status, pid=pid)
@@ -400,48 +446,48 @@ def _wrap_exceptions(self):
         """
         try:
             yield
-        except WindowsError as err:
-            NO_SUCH_SERVICE_SET = (cext.ERROR_INVALID_NAME,
-                                   cext.ERROR_SERVICE_DOES_NOT_EXIST)
-            if err.errno in ACCESS_DENIED_SET:
-                raise AccessDenied(
-                    pid=None, name=self._name,
-                    msg="service %r is not querable (not enough privileges)" %
-                        self._name)
-            elif err.errno in NO_SUCH_SERVICE_SET or \
-                    err.winerror in NO_SUCH_SERVICE_SET:
-                raise NoSuchProcess(
-                    pid=None, name=self._name,
-                    msg="service %r does not exist)" % self._name)
+        except OSError as err:
+            name = self._name
+            if is_permission_err(err):
+                msg = (
+                    f"service {name!r} is not querable (not enough privileges)"
+                )
+                raise AccessDenied(pid=None, name=name, msg=msg) from err
+            elif err.winerror in {
+                _psutil.ERROR_INVALID_NAME,
+                _psutil.ERROR_SERVICE_DOES_NOT_EXIST,
+            }:
+                msg = f"service {name!r} does not exist"
+                raise NoSuchProcess(pid=None, name=name, msg=msg) from err
             else:
                 raise
 
     # config query
 
-    def name(self):
+    def name(self) -> str:
         """The service name. This string is how a service is referenced
         and can be passed to win_service_get() to get a new
         WindowsService instance.
         """
         return self._name
 
-    def display_name(self):
+    def display_name(self) -> str:
         """The service display name. The value is cached when this class
         is instantiated.
         """
         return self._display_name
 
-    def binpath(self):
+    def binpath(self) -> str:
         """The fully qualified path to the service binary/exe file as
         a string, including command line arguments.
         """
         return self._query_config()['binpath']
 
-    def username(self):
+    def username(self) -> str:
         """The name of the user that owns this service."""
         return self._query_config()['username']
 
-    def start_type(self):
+    def start_type(self) -> str:
         """A string which can either be "automatic", "manual" or
         "disabled".
         """
@@ -449,23 +495,23 @@ def start_type(self):
 
     # status query
 
-    def pid(self):
+    def pid(self) -> int | None:
         """The process PID, if any, else None. This can be passed
         to Process class to control the service's process.
         """
         return self._query_status()['pid']
 
-    def status(self):
+    def status(self) -> str:
         """Service status as a string."""
         return self._query_status()['status']
 
-    def description(self):
+    def description(self) -> str:
         """Service long description."""
-        return cext.winservice_query_descr(self.name())
+        return _psutil.winservice_query_descr(self.name())
 
     # utils
 
-    def as_dict(self):
+    def as_dict(self) -> dict[str, str | int | None]:
         """Utility method retrieving all the information above as a
         dictionary.
         """
@@ -477,8 +523,8 @@ def as_dict(self):
         return d
 
     # actions
-    # XXX: the necessary C bindings for start() and stop() are implemented
-    # but for now I prefer not to expose them.
+    # XXX: the necessary C bindings for start() and stop() are
+    # implemented but for now I prefer not to expose them.
     # I may change my mind in the future. Reasons:
     # - they require Administrator privileges
     # - can't implement a timeout for stop() (unless by using a thread,
@@ -496,7 +542,7 @@ def as_dict(self):
 
     # def start(self, timeout=None):
     #     with self._wrap_exceptions():
-    #         cext.winservice_start(self.name())
+    #         _psutil.winservice_start(self.name())
     #         if timeout:
     #             giveup_at = time.time() + timeout
     #             while True:
@@ -513,7 +559,7 @@ def as_dict(self):
     #     # possible, see:
     #     # http://stackoverflow.com/questions/11973228/
     #     with self._wrap_exceptions():
-    #         return cext.winservice_stop(self.name())
+    #         return _psutil.winservice_stop(self.name())
 
 
 # =====================================================================
@@ -521,39 +567,98 @@ def as_dict(self):
 # =====================================================================
 
 
-pids = cext.pids
-pid_exists = cext.pid_exists
-ppid_map = cext.ppid_map  # used internally by Process.children()
+pids = _psutil.pids
+pid_exists = _psutil.pid_exists
+ppid_map = _psutil.ppid_map  # used internally by Process.children()
+
+
+def is_permission_err(exc):
+    """Return True if this is a permission error."""
+    assert isinstance(exc, OSError), exc
+    return isinstance(exc, PermissionError) or exc.winerror in {
+        _psutil.ERROR_ACCESS_DENIED,
+        _psutil.ERROR_PRIVILEGE_NOT_HELD,
+    }
+
+
+def convert_oserror(exc, pid=None, name=None):
+    """Convert OSError into NoSuchProcess or AccessDenied."""
+    assert isinstance(exc, OSError), exc
+    if is_permission_err(exc):
+        return AccessDenied(pid=pid, name=name)
+    if isinstance(exc, ProcessLookupError):
+        return NoSuchProcess(pid=pid, name=name)
+    raise exc
 
 
 def wrap_exceptions(fun):
-    """Decorator which translates bare OSError and WindowsError
-    exceptions into NoSuchProcess and AccessDenied.
-    """
+    """Decorator which converts OSError into NoSuchProcess or AccessDenied."""
+
     @functools.wraps(fun)
     def wrapper(self, *args, **kwargs):
         try:
             return fun(self, *args, **kwargs)
         except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
-                raise AccessDenied(self.pid, self._name)
-            if err.errno == errno.ESRCH:
-                raise NoSuchProcess(self.pid, self._name)
-            raise
+            raise convert_oserror(err, pid=self.pid, name=self._name) from err
+
+    return wrapper
+
+
+def retry_error_partial_copy(fun):
+    """Workaround for https://github.com/giampaolo/psutil/issues/875.
+    See: https://stackoverflow.com/questions/4457745#4457745.
+    """
+
+    @functools.wraps(fun)
+    def wrapper(self, *args, **kwargs):
+        delay = 0.0001
+        times = 33
+        for _ in range(times):  # retries for roughly 1 second
+            try:
+                return fun(self, *args, **kwargs)
+            except OSError as _:
+                err = _
+                if err.winerror == ERROR_PARTIAL_COPY:
+                    time.sleep(delay)
+                    delay = min(delay * 2, 0.04)
+                    continue
+                raise
+        msg = (
+            f"{fun} retried {times} times, converted to AccessDenied as it's "
+            f"still returning {err}"
+        )
+        raise AccessDenied(pid=self.pid, name=self._name, msg=msg)
+
     return wrapper
 
 
-class Process(object):
+class Process:
     """Wrapper class around underlying C implementation."""
 
-    __slots__ = ["pid", "_name", "_ppid"]
+    __slots__ = ["_cache", "_name", "_ppid", "pid"]
 
     def __init__(self, pid):
         self.pid = pid
         self._name = None
         self._ppid = None
 
-    @wrap_exceptions
+    # --- oneshot() stuff
+
+    def oneshot_enter(self):
+        self._oneshot.cache_activate(self)
+        self.exe.cache_activate(self)
+
+    def oneshot_exit(self):
+        self._oneshot.cache_deactivate(self)
+        self.exe.cache_deactivate(self)
+
+    @memoize_when_activated
+    def _oneshot(self):
+        """Return multiple information about this process as a
+        raw dict.
+        """
+        return _psutil.proc_oneshot(self.pid)
+
     def name(self):
         """Return process name, which on Windows is always the final
         part of the executable.
@@ -562,83 +667,149 @@ def name(self):
         # and process-hacker.
         if self.pid == 0:
             return "System Idle Process"
-        elif self.pid == 4:
+        if self.pid == 4:
             return "System"
-        else:
-            try:
-                # Note: this will fail with AD for most PIDs owned
-                # by another user but it's faster.
-                return py2_strencode(os.path.basename(self.exe()))
-            except AccessDenied:
-                return py2_strencode(cext.proc_name(self.pid))
+        return os.path.basename(self.exe())
 
     @wrap_exceptions
+    @memoize_when_activated
     def exe(self):
-        # Note: os.path.exists(path) may return False even if the file
-        # is there, see:
-        # http://stackoverflow.com/questions/3112546/os-path-exists-lies
-
-        # see https://github.com/giampaolo/psutil/issues/414
-        # see https://github.com/giampaolo/psutil/issues/528
-        if self.pid in (0, 4):
-            raise AccessDenied(self.pid, self._name)
-        return py2_strencode(convert_dos_path(cext.proc_exe(self.pid)))
+        if PYPY:
+            try:
+                exe = _psutil.proc_exe(self.pid)
+            except OSError as err:
+                # 24 = ERROR_TOO_MANY_OPEN_FILES. Not sure why this happens
+                # (perhaps PyPy's JIT delaying garbage collection of files?).
+                if err.errno == 24:
+                    debug(f"{err!r} translated into AccessDenied")
+                    raise AccessDenied(self.pid, self._name) from err
+                raise
+        else:
+            exe = _psutil.proc_exe(self.pid)
+        if exe.startswith('\\'):
+            return convert_dos_path(exe)
+        return exe  # May be "Registry", "MemCompression", ...
 
     @wrap_exceptions
+    @retry_error_partial_copy
     def cmdline(self):
-        ret = cext.proc_cmdline(self.pid)
-        if PY3:
-            return ret
-        else:
-            return [py2_strencode(s) for s in ret]
+        # PEB method detects cmdline changes but requires more
+        # privileges: https://github.com/giampaolo/psutil/pull/1398
+        try:
+            return _psutil.proc_cmdline(self.pid, use_peb=True)
+        except OSError as err:
+            if is_permission_err(err):
+                return _psutil.proc_cmdline(self.pid, use_peb=False)
+            else:
+                raise
 
     @wrap_exceptions
+    @retry_error_partial_copy
     def environ(self):
-        return parse_environ_block(cext.proc_environ(self.pid))
+        s = _psutil.proc_environ(self.pid)
+        return parse_environ_block(s)
 
+    @wrap_exceptions
     def ppid(self):
         try:
-            return ppid_map()[self.pid]
-        except KeyError:
-            raise NoSuchProcess(self.pid, self._name)
+            return _psutil.proc_ppid(self.pid)
+        except OSError as err:
+            if is_permission_err(err):
+                debug("attempting ppid() fallback (slower)")
+                try:
+                    return ppid_map()[self.pid]
+                except KeyError:
+                    raise NoSuchProcess(self.pid, self._name) from None
+            raise
 
     def _get_raw_meminfo(self):
         try:
-            return cext.proc_memory_info(self.pid)
+            return _psutil.proc_memory_info(self.pid)
         except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
+            if is_permission_err(err):
                 # TODO: the C ext can probably be refactored in order
-                # to get this from cext.proc_info()
-                return cext.proc_memory_info_2(self.pid)
+                # to get this from _psutil.proc_oneshot()
+                debug("attempting memory_info() fallback (slower)")
+                info = self._oneshot()
+                return {
+                    "PageFaultCount": info["PageFaultCount"],
+                    "PeakWorkingSetSize": info["PeakWorkingSetSize"],
+                    "WorkingSetSize": info["WorkingSetSize"],
+                    "QuotaPeakPagedPoolUsage": info["QuotaPeakPagedPoolUsage"],
+                    "QuotaPagedPoolUsage": info["QuotaPagedPoolUsage"],
+                    "QuotaPeakNonPagedPoolUsage": info[
+                        "QuotaPeakNonPagedPoolUsage"
+                    ],
+                    "QuotaNonPagedPoolUsage": info["QuotaNonPagedPoolUsage"],
+                    "PagefileUsage": info["PagefileUsage"],
+                    "PeakPagefileUsage": info["PeakPagefileUsage"],
+                    "PrivateUsage": info["PrivatePageCount"],  # adjust name
+                }
             raise
 
     @wrap_exceptions
     def memory_info(self):
-        # on Windows RSS == WorkingSetSize and VSM == PagefileUsage.
         # Underlying C function returns fields of PROCESS_MEMORY_COUNTERS
         # struct.
-        t = self._get_raw_meminfo()
-        rss = t[2]  # wset
-        vms = t[7]  # pagefile
-        return pmem(*(rss, vms, ) + t)
+        d = self._get_raw_meminfo()
+        return ntp.pmem(
+            rss=d["WorkingSetSize"],
+            vms=d["PrivateUsage"],
+            peak_rss=d["PeakWorkingSetSize"],
+            peak_vms=d["PeakPagefileUsage"],
+            _deprecated={
+                # old aliases
+                "wset": d["WorkingSetSize"],  # 'rss'
+                "peak_wset": d["PeakWorkingSetSize"],  # 'peak_rss'
+                "pagefile": d["PrivateUsage"],  # 'vms'
+                "private": d["PrivateUsage"],  # 'vms'
+                "peak_pagefile": d["PeakPagefileUsage"],  # 'vms'
+                # fields which were moved to memory_extras()
+                "paged_pool": d["QuotaPagedPoolUsage"],
+                "nonpaged_pool": d["QuotaNonPagedPoolUsage"],
+                "peak_paged_pool": d["QuotaPeakPagedPoolUsage"],
+                "peak_nonpaged_pool": d["QuotaPeakNonPagedPoolUsage"],
+                # moved to page_faults()
+                "num_page_faults": d["PageFaultCount"],
+            },
+        )
+
+    @wrap_exceptions
+    def memory_extras(self):
+        d = self._oneshot()
+        raw = self._get_raw_meminfo()
+        return ntp.pmem_extras(
+            virtual=d["VirtualSize"],
+            peak_virtual=d["PeakVirtualSize"],
+            paged_pool=raw["QuotaPagedPoolUsage"],
+            nonpaged_pool=raw["QuotaNonPagedPoolUsage"],
+            peak_paged_pool=raw["QuotaPeakPagedPoolUsage"],
+            peak_nonpaged_pool=raw["QuotaPeakNonPagedPoolUsage"],
+        )
+
+    @wrap_exceptions
+    def memory_footprint(self):
+        uss = _psutil.proc_memory_uss(self.pid)
+        uss *= getpagesize()
+        return ntp.pfootprint(uss)
 
     @wrap_exceptions
-    def memory_full_info(self):
-        basic_mem = self.memory_info()
-        uss = cext.proc_memory_uss(self.pid)
-        return pfullmem(*basic_mem + (uss, ))
+    def page_faults(self):
+        # PageFaultCount is the total (soft + hard), while
+        # HardFaultCount tracks hard (major) faults only. Minor faults
+        # are derived by subtracting the two.
+        info = self._oneshot()
+        major = info["HardFaultCount"]
+        minor = info["PageFaultCount"] - major
+        return ntp.ppagefaults(minor, major)
 
     def memory_maps(self):
         try:
-            raw = cext.proc_memory_maps(self.pid)
+            raw = _psutil.proc_memory_maps(self.pid)
         except OSError as err:
             # XXX - can't use wrap_exceptions decorator as we're
             # returning a generator; probably needs refactoring.
-            if err.errno in ACCESS_DENIED_SET:
-                raise AccessDenied(self.pid, self._name)
-            if err.errno == errno.ESRCH:
-                raise NoSuchProcess(self.pid, self._name)
-            raise
+            raise convert_oserror(err, self.pid, self._name) from err
         else:
             for addr, perm, path, rss in raw:
                 path = convert_dos_path(path)
@@ -647,170 +818,218 @@ def memory_maps(self):
 
     @wrap_exceptions
     def kill(self):
-        return cext.proc_kill(self.pid)
+        return _psutil.proc_kill(self.pid)
 
     @wrap_exceptions
     def send_signal(self, sig):
-        os.kill(self.pid, sig)
+        if sig == signal.SIGTERM:
+            _psutil.proc_kill(self.pid)
+        elif sig in {signal.CTRL_C_EVENT, signal.CTRL_BREAK_EVENT}:
+            os.kill(self.pid, sig)
+        else:
+            msg = (
+                "only SIGTERM, CTRL_C_EVENT and CTRL_BREAK_EVENT signals "
+                "are supported on Windows"
+            )
+            raise ValueError(msg)
 
     @wrap_exceptions
     def wait(self, timeout=None):
         if timeout is None:
-            cext_timeout = cext.INFINITE
+            cext_timeout = _psutil.INFINITE
         else:
-            # WaitForSingleObject() expects time in milliseconds
+            # WaitForSingleObject() expects time in milliseconds.
             cext_timeout = int(timeout * 1000)
-        ret = cext.proc_wait(self.pid, cext_timeout)
-        if ret == WAIT_TIMEOUT:
-            raise TimeoutExpired(timeout, self.pid, self._name)
-        return ret
+
+        timer = getattr(time, 'monotonic', time.time)
+        stop_at = timer() + timeout if timeout is not None else None
+
+        try:
+            # Exit code is supposed to come from GetExitCodeProcess().
+            # May also be None if OpenProcess() failed with
+            # ERROR_INVALID_PARAMETER, meaning PID is already gone.
+            exit_code = _psutil.proc_wait(self.pid, cext_timeout)
+        except _psutil.TimeoutExpired as err:
+            # WaitForSingleObject() returned WAIT_TIMEOUT. Just raise.
+            raise TimeoutExpired(timeout, self.pid, self._name) from err
+        except _psutil.TimeoutAbandoned:
+            # WaitForSingleObject() returned WAIT_ABANDONED, see:
+            # https://github.com/giampaolo/psutil/issues/1224
+            # We'll just rely on the internal polling and return None
+            # when the PID disappears. Subprocess module does the same
+            # (return None):
+            # https://github.com/python/cpython/blob/be50a7b627d0/Lib/subprocess.py#L1193-L1194
+            exit_code = None
+
+        # At this point WaitForSingleObject() returned WAIT_OBJECT_0,
+        # meaning the process is gone. Stupidly there are cases where
+        # its PID may still stick around so we do a further internal
+        # polling.
+        delay = 0.0001
+        while True:
+            if not pid_exists(self.pid):
+                return exit_code
+            if stop_at and timer() >= stop_at:
+                raise TimeoutExpired(timeout, pid=self.pid, name=self._name)
+            time.sleep(delay)
+            delay = min(delay * 2, 0.04)  # incremental delay
 
     @wrap_exceptions
     def username(self):
-        if self.pid in (0, 4):
+        if self.pid in {0, 4}:
             return 'NT AUTHORITY\\SYSTEM'
-        return cext.proc_username(self.pid)
+        domain, user = _psutil.proc_username(self.pid)
+        return f"{domain}\\{user}"
 
     @wrap_exceptions
-    def create_time(self):
-        # special case for kernel process PIDs; return system boot time
-        if self.pid in (0, 4):
-            return boot_time()
+    def create_time(self, fast_only=False):
+        # Note: proc_times() not put under oneshot() 'cause create_time()
+        # is already cached by the main Process class.
         try:
-            return cext.proc_create_time(self.pid)
+            _user, _system, created = _psutil.proc_times(self.pid)
+            return created
         except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
-                return ntpinfo(*cext.proc_info(self.pid)).create_time
+            if is_permission_err(err):
+                if fast_only:
+                    raise
+                debug("attempting create_time() fallback (slower)")
+                return self._oneshot()["create_time"]
             raise
 
     @wrap_exceptions
     def num_threads(self):
-        return ntpinfo(*cext.proc_info(self.pid)).num_threads
+        return self._oneshot()["num_threads"]
 
     @wrap_exceptions
     def threads(self):
-        rawlist = cext.proc_threads(self.pid)
+        rawlist = _psutil.proc_threads(self.pid)
         retlist = []
         for thread_id, utime, stime in rawlist:
-            ntuple = _common.pthread(thread_id, utime, stime)
+            ntuple = ntp.pthread(thread_id, utime, stime)
             retlist.append(ntuple)
         return retlist
 
     @wrap_exceptions
     def cpu_times(self):
         try:
-            user, system = cext.proc_cpu_times(self.pid)
+            user, system, _created = _psutil.proc_times(self.pid)
         except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
-                nt = ntpinfo(*cext.proc_info(self.pid))
-                user, system = (nt.user_time, nt.kernel_time)
-            else:
+            if not is_permission_err(err):
                 raise
+            debug("attempting cpu_times() fallback (slower)")
+            info = self._oneshot()
+            user = info["user_time"]
+            system = info["kernel_time"]
         # Children user/system times are not retrievable (set to 0).
-        return _common.pcputimes(user, system, 0, 0)
+        return ntp.pcputimes(user, system, 0.0, 0.0)
 
     @wrap_exceptions
     def suspend(self):
-        return cext.proc_suspend(self.pid)
+        _psutil.proc_suspend_or_resume(self.pid, True)
 
     @wrap_exceptions
     def resume(self):
-        return cext.proc_resume(self.pid)
+        _psutil.proc_suspend_or_resume(self.pid, False)
 
     @wrap_exceptions
+    @retry_error_partial_copy
     def cwd(self):
-        if self.pid in (0, 4):
+        if self.pid in {0, 4}:
             raise AccessDenied(self.pid, self._name)
         # return a normalized pathname since the native C function appends
         # "\\" at the and of the path
-        path = cext.proc_cwd(self.pid)
-        return py2_strencode(os.path.normpath(path))
+        path = _psutil.proc_cwd(self.pid)
+        return os.path.normpath(path)
 
     @wrap_exceptions
     def open_files(self):
-        if self.pid in (0, 4):
+        if self.pid in {0, 4}:
             return []
-        ret = set()
         # Filenames come in in native format like:
         # "\Device\HarddiskVolume1\Windows\systemew\file.txt"
         # Convert the first part in the corresponding drive letter
-        # (e.g. "C:\") by using Windows's QueryDosDevice()
-        raw_file_names = cext.proc_open_files(self.pid)
-        for _file in raw_file_names:
-            _file = convert_dos_path(_file)
-            if isfile_strict(_file):
-                if not PY3:
-                    _file = py2_strencode(_file)
-                ntuple = _common.popenfile(_file, -1)
-                ret.add(ntuple)
+        # (e.g. "C:\") by using Windows's QueryDosDevice(). Directories
+        # are already filtered out by the C extension.
+        raw_file_names = _psutil.proc_open_files(self.pid)
+        ret = {
+            ntp.popenfile(convert_dos_path(file), -1)
+            for file in raw_file_names
+        }
         return list(ret)
 
     @wrap_exceptions
-    def connections(self, kind='inet'):
+    def net_connections(self, kind='inet'):
         return net_connections(kind, _pid=self.pid)
 
     @wrap_exceptions
     def nice_get(self):
-        value = cext.proc_priority_get(self.pid)
-        if enum is not None:
-            value = Priority(value)
+        value = _psutil.proc_priority_get(self.pid)
+        value = ProcessPriority(value)
         return value
 
     @wrap_exceptions
     def nice_set(self, value):
-        return cext.proc_priority_set(self.pid, value)
-
-    # available on Windows >= Vista
-    if hasattr(cext, "proc_io_priority_get"):
-        @wrap_exceptions
-        def ionice_get(self):
-            return cext.proc_io_priority_get(self.pid)
-
-        @wrap_exceptions
-        def ionice_set(self, value, _):
-            if _:
-                raise TypeError("set_proc_ionice() on Windows takes only "
-                                "1 argument (2 given)")
-            if value not in (2, 1, 0):
-                raise ValueError("value must be 2 (normal), 1 (low) or 0 "
-                                 "(very low); got %r" % value)
-            return cext.proc_io_priority_set(self.pid, value)
+        return _psutil.proc_priority_set(self.pid, value)
+
+    @wrap_exceptions
+    def ionice_get(self):
+        ret = _psutil.proc_io_priority_get(self.pid)
+        ret = ProcessIOPriority(ret)
+        return ret
+
+    @wrap_exceptions
+    def ionice_set(self, ioclass, value):
+        if value:
+            msg = "value argument not accepted on Windows"
+            raise TypeError(msg)
+        if ioclass not in tuple(ProcessIOPriority):
+            msg = f"{ioclass} is not a valid priority"
+            raise ValueError(msg)
+        _psutil.proc_io_priority_set(self.pid, ioclass)
 
     @wrap_exceptions
     def io_counters(self):
         try:
-            ret = cext.proc_io_counters(self.pid)
+            ret = _psutil.proc_io_counters(self.pid)
         except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
-                nt = ntpinfo(*cext.proc_info(self.pid))
-                ret = (nt.io_rcount, nt.io_wcount, nt.io_rbytes, nt.io_wbytes)
-            else:
+            if not is_permission_err(err):
                 raise
-        return _common.pio(*ret)
+            debug("attempting io_counters() fallback (slower)")
+            info = self._oneshot()
+            ret = (
+                info["io_rcount"],
+                info["io_wcount"],
+                info["io_rbytes"],
+                info["io_wbytes"],
+                info["io_count_others"],
+                info["io_bytes_others"],
+            )
+        return ntp.pio(*ret)
 
     @wrap_exceptions
     def status(self):
-        suspended = cext.proc_is_suspended(self.pid)
-        if suspended:
-            return _common.STATUS_STOPPED
+        if self._oneshot()["is_suspended"]:
+            return ProcessStatus.STATUS_STOPPED
         else:
-            return _common.STATUS_RUNNING
+            return ProcessStatus.STATUS_RUNNING
 
     @wrap_exceptions
     def cpu_affinity_get(self):
         def from_bitmask(x):
-            return [i for i in xrange(64) if (1 << i) & x]
-        bitmask = cext.proc_cpu_affinity_get(self.pid)
+            return [i for i in range(64) if (1 << i) & x]
+
+        bitmask = _psutil.proc_cpu_affinity_get(self.pid)
         return from_bitmask(bitmask)
 
     @wrap_exceptions
     def cpu_affinity_set(self, value):
-        def to_bitmask(l):
-            if not l:
-                raise ValueError("invalid argument %r" % l)
+        def to_bitmask(ls):
+            if not ls:
+                msg = f"invalid argument {ls!r}"
+                raise ValueError(msg)
             out = 0
-            for b in l:
-                out |= 2 ** b
+            for b in ls:
+                out |= 2**b
             return out
 
         # SetProcessAffinityMask() states that ERROR_INVALID_PARAMETER
@@ -819,26 +1038,27 @@ def to_bitmask(l):
         allcpus = list(range(len(per_cpu_times())))
         for cpu in value:
             if cpu not in allcpus:
-                if not isinstance(cpu, (int, long)):
-                    raise TypeError(
-                        "invalid CPU %r; an integer is required" % cpu)
-                else:
-                    raise ValueError("invalid CPU %r" % cpu)
+                if not isinstance(cpu, int):
+                    msg = f"invalid CPU {cpu!r}; an integer is required"
+                    raise TypeError(msg)
+                msg = f"invalid CPU {cpu!r}"
+                raise ValueError(msg)
 
         bitmask = to_bitmask(value)
-        cext.proc_cpu_affinity_set(self.pid, bitmask)
+        _psutil.proc_cpu_affinity_set(self.pid, bitmask)
 
     @wrap_exceptions
     def num_handles(self):
         try:
-            return cext.proc_num_handles(self.pid)
+            return _psutil.proc_num_handles(self.pid)
         except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
-                return ntpinfo(*cext.proc_info(self.pid)).num_handles
+            if is_permission_err(err):
+                debug("attempting num_handles() fallback (slower)")
+                return self._oneshot()["num_handles"]
             raise
 
     @wrap_exceptions
     def num_ctx_switches(self):
-        ctx_switches = ntpinfo(*cext.proc_info(self.pid)).ctx_switches
+        ctx_switches = self._oneshot()["ctx_switches"]
         # only voluntary ctx switches are supported
-        return _common.pctxsw(ctx_switches, 0)
+        return ntp.pctxsw(ctx_switches, 0)
diff --git a/psutil/arch/aix/cpu.c b/psutil/arch/aix/cpu.c
new file mode 100644
index 0000000000..80ce49a5c0
--- /dev/null
+++ b/psutil/arch/aix/cpu.c
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <unistd.h>
+#include <libperfstat.h>
+
+#include "../../arch/all/init.h"
+#include "init.h"
+
+
+PyObject *
+psutil_per_cpu_times(PyObject *self, PyObject *args) {
+    int ncpu, rc, i;
+    long ticks;
+    perfstat_cpu_t *cpu = NULL;
+    perfstat_id_t id;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    // get the number of ticks per second
+    ticks = sysconf(_SC_CLK_TCK);
+    if (ticks < 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    // get the number of cpus in ncpu
+    ncpu = perfstat_cpu(NULL, NULL, sizeof(perfstat_cpu_t), 0);
+    if (ncpu <= 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    // allocate enough memory to hold the ncpu structures
+    cpu = (perfstat_cpu_t *)malloc(ncpu * sizeof(perfstat_cpu_t));
+    if (cpu == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    strcpy(id.name, "");
+    rc = perfstat_cpu(&id, cpu, sizeof(perfstat_cpu_t), ncpu);
+
+    if (rc <= 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (i = 0; i < ncpu; i++) {
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(dddd)",
+                (double)cpu[i].user / ticks,
+                (double)cpu[i].sys / ticks,
+                (double)cpu[i].idle / ticks,
+                (double)cpu[i].wait / ticks
+            ))
+        {
+            goto error;
+        }
+    }
+    free(cpu);
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    if (cpu != NULL)
+        free(cpu);
+    return NULL;
+}
+
+
+PyObject *
+psutil_cpu_stats(PyObject *self, PyObject *args) {
+    int ncpu, rc, i;
+    // perfstat_cpu_total_t doesn't have invol/vol cswitch, only pswitch
+    // which is apparently something else. We have to sum over all cpus
+    perfstat_cpu_t *cpu = NULL;
+    perfstat_id_t id;
+    u_longlong_t cswitches = 0;
+    u_longlong_t devintrs = 0;
+    u_longlong_t softintrs = 0;
+    u_longlong_t syscall = 0;
+
+    // get the number of cpus in ncpu
+    ncpu = perfstat_cpu(NULL, NULL, sizeof(perfstat_cpu_t), 0);
+    if (ncpu <= 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    // allocate enough memory to hold the ncpu structures
+    cpu = (perfstat_cpu_t *)malloc(ncpu * sizeof(perfstat_cpu_t));
+    if (cpu == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    strcpy(id.name, "");
+    rc = perfstat_cpu(&id, cpu, sizeof(perfstat_cpu_t), ncpu);
+
+    if (rc <= 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (i = 0; i < ncpu; i++) {
+        cswitches += cpu[i].invol_cswitch + cpu[i].vol_cswitch;
+        devintrs += cpu[i].devintrs;
+        softintrs += cpu[i].softintrs;
+        syscall += cpu[i].syscall;
+    }
+
+    free(cpu);
+
+    return Py_BuildValue("KKKK", cswitches, devintrs, softintrs, syscall);
+
+error:
+    if (cpu != NULL)
+        free(cpu);
+    return NULL;
+}
diff --git a/psutil/arch/aix/disk.c b/psutil/arch/aix/disk.c
new file mode 100644
index 0000000000..986b9d5bfd
--- /dev/null
+++ b/psutil/arch/aix/disk.c
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <mntent.h>
+#include <libperfstat.h>
+
+#include "../../arch/all/init.h"
+#include "init.h"
+
+
+PyObject *
+psutil_disk_partitions(PyObject *self, PyObject *args) {
+    FILE *file = NULL;
+    struct mntent *mt = NULL;
+    PyObject *py_dev = NULL;
+    PyObject *py_mountp = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    Py_BEGIN_ALLOW_THREADS
+    file = setmntent(MNTTAB, "rb");
+    Py_END_ALLOW_THREADS
+    if (file == NULL) {
+        psutil_oserror();
+        goto error;
+    }
+
+    // NOTE: getmntent() is MT-Unsafe (it returns a pointer to a static
+    // buffer), so we can't release the GIL around it.
+    while ((mt = getmntent(file)) != NULL) {
+        py_dev = PyUnicode_DecodeFSDefault(mt->mnt_fsname);
+        if (!py_dev)
+            goto error;
+        py_mountp = PyUnicode_DecodeFSDefault(mt->mnt_dir);
+        if (!py_mountp)
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(OOss)",
+                py_dev,  // device
+                py_mountp,  // mount point
+                mt->mnt_type,  // fs type
+                mt->mnt_opts  // options
+            ))
+        {
+            goto error;
+        }
+        Py_CLEAR(py_dev);
+        Py_CLEAR(py_mountp);
+    }
+    endmntent(file);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_dev);
+    Py_XDECREF(py_mountp);
+    Py_DECREF(py_retlist);
+    if (file != NULL)
+        endmntent(file);
+    return NULL;
+}
+
+
+PyObject *
+psutil_disk_io_counters(PyObject *self, PyObject *args) {
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_disk_info = NULL;
+    perfstat_disk_t *diskt = NULL;
+    perfstat_id_t id;
+    int i, rc, disk_count;
+
+    if (py_retdict == NULL)
+        return NULL;
+
+    // Get the count of disks
+    disk_count = perfstat_disk(NULL, NULL, sizeof(perfstat_disk_t), 0);
+    if (disk_count <= 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    // Allocate enough memory
+    diskt = (perfstat_disk_t *)calloc(disk_count, sizeof(perfstat_disk_t));
+    if (diskt == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    strcpy(id.name, FIRST_DISK);
+    rc = perfstat_disk(&id, diskt, sizeof(perfstat_disk_t), disk_count);
+    if (rc <= 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (i = 0; i < disk_count; i++) {
+        py_disk_info = Py_BuildValue(
+            "KKKKKK",
+            diskt[i].__rxfers,
+            diskt[i].xfers - diskt[i].__rxfers,
+            diskt[i].rblks * diskt[i].bsize,
+            diskt[i].wblks * diskt[i].bsize,
+            diskt[i].rserv / 1000 / 1000,  // from nano to milli secs
+            diskt[i].wserv / 1000 / 1000  // from nano to milli secs
+        );
+        if (py_disk_info == NULL)
+            goto error;
+        if (PyDict_SetItemString(py_retdict, diskt[i].name, py_disk_info))
+            goto error;
+        Py_DECREF(py_disk_info);
+    }
+    free(diskt);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_disk_info);
+    Py_DECREF(py_retdict);
+    if (diskt != NULL)
+        free(diskt);
+    return NULL;
+}
diff --git a/psutil/arch/aix/ifaddrs.c b/psutil/arch/aix/ifaddrs.c
new file mode 100644
index 0000000000..1a1a565f7f
--- /dev/null
+++ b/psutil/arch/aix/ifaddrs.c
@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Based on code from:
+// https://lists.samba.org/archive/samba-technical/2009-February/063079.html
+
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include "ifaddrs.h"
+#include "../../arch/all/init.h"
+
+#define MAX(x, y) ((x) > (y) ? (x) : (y))
+#define SIZE(p) MAX((p).sa_len, sizeof(p))
+
+
+static struct sockaddr *
+sa_dup(struct sockaddr *sa1) {
+    struct sockaddr *sa2;
+    size_t sz = sa1->sa_len;
+    sa2 = (struct sockaddr *)calloc(1, sz);
+    if (sa2 == NULL)
+        return NULL;
+    memcpy(sa2, sa1, sz);
+    return sa2;
+}
+
+
+void
+freeifaddrs(struct ifaddrs *ifp) {
+    if (NULL == ifp)
+        return;
+    free(ifp->ifa_name);
+    free(ifp->ifa_addr);
+    free(ifp->ifa_netmask);
+    free(ifp->ifa_dstaddr);
+    freeifaddrs(ifp->ifa_next);
+    free(ifp);
+}
+
+
+int
+getifaddrs(struct ifaddrs **ifap) {
+    int sd, ifsize;
+    char *ccp, *ecp;
+    struct ifconf ifc;
+    struct ifreq *ifr;
+    struct ifaddrs *cifa = NULL;  // current
+    struct ifaddrs *pifa = NULL;  // previous
+    const size_t IFREQSZ = sizeof(struct ifreq);
+    int fam;
+
+    *ifap = NULL;
+
+    sd = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sd == -1)
+        goto error;
+
+    // find how much memory to allocate for the SIOCGIFCONF call
+    if (ioctl(sd, SIOCGSIZIFCONF, (caddr_t)&ifsize) < 0)
+        goto error;
+
+    ifc.ifc_req = (struct ifreq *)calloc(1, ifsize);
+    if (ifc.ifc_req == NULL)
+        goto error;
+    ifc.ifc_len = ifsize;
+
+    if (ioctl(sd, SIOCGIFCONF, &ifc) < 0)
+        goto error;
+
+    ccp = (char *)ifc.ifc_req;
+    ecp = ccp + ifsize;
+
+    while (ccp < ecp) {
+        ifr = (struct ifreq *)ccp;
+        ifsize = sizeof(ifr->ifr_name) + SIZE(ifr->ifr_addr);
+        fam = ifr->ifr_addr.sa_family;
+
+        if (fam == AF_INET || fam == AF_INET6) {
+            cifa = (struct ifaddrs *)calloc(1, sizeof(struct ifaddrs));
+            if (cifa == NULL)
+                goto error;
+            cifa->ifa_next = NULL;
+
+            if (pifa == NULL)
+                *ifap = cifa;  // first one
+            else
+                pifa->ifa_next = cifa;
+
+            cifa->ifa_name = strdup(ifr->ifr_name);
+            if (cifa->ifa_name == NULL)
+                goto error;
+            cifa->ifa_flags = 0;
+            cifa->ifa_dstaddr = NULL;
+
+            cifa->ifa_addr = sa_dup(&ifr->ifr_addr);
+            if (cifa->ifa_addr == NULL)
+                goto error;
+
+            if (fam == AF_INET) {
+                if (ioctl(sd, SIOCGIFNETMASK, ifr, IFREQSZ) < 0)
+                    goto error;
+                cifa->ifa_netmask = sa_dup(&ifr->ifr_addr);
+                if (cifa->ifa_netmask == NULL)
+                    goto error;
+            }
+
+            if (0 == ioctl(sd, SIOCGIFFLAGS, ifr))  // optional
+                cifa->ifa_flags = ifr->ifr_flags;
+
+            if (fam == AF_INET) {
+                if (ioctl(sd, SIOCGIFDSTADDR, ifr, IFREQSZ) < 0) {
+                    if (0 == ioctl(sd, SIOCGIFBRDADDR, ifr, IFREQSZ)) {
+                        cifa->ifa_dstaddr = sa_dup(&ifr->ifr_addr);
+                        if (cifa->ifa_dstaddr == NULL)
+                            goto error;
+                    }
+                }
+                else {
+                    cifa->ifa_dstaddr = sa_dup(&ifr->ifr_addr);
+                    if (cifa->ifa_dstaddr == NULL)
+                        goto error;
+                }
+            }
+            pifa = cifa;
+        }
+
+        ccp += ifsize;
+    }
+    free(ifc.ifc_req);
+    close(sd);
+    return 0;
+error:
+    if (ifc.ifc_req != NULL)
+        free(ifc.ifc_req);
+    if (sd != -1)
+        close(sd);
+    freeifaddrs(*ifap);
+    return (-1);
+}
diff --git a/psutil/arch/aix/ifaddrs.h b/psutil/arch/aix/ifaddrs.h
new file mode 100644
index 0000000000..fe4126762b
--- /dev/null
+++ b/psutil/arch/aix/ifaddrs.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/*! Based on code from
+    https://lists.samba.org/archive/samba-technical/2009-February/063079.html
+!*/
+
+
+#ifndef GENERIC_AIX_IFADDRS_H
+#define GENERIC_AIX_IFADDRS_H
+
+#include <sys/socket.h>
+#include <net/if.h>
+
+#undef ifa_dstaddr
+#undef ifa_broadaddr
+#define ifa_broadaddr ifa_dstaddr
+
+struct ifaddrs {
+    struct ifaddrs *ifa_next;
+    char *ifa_name;
+    unsigned int ifa_flags;
+    struct sockaddr *ifa_addr;
+    struct sockaddr *ifa_netmask;
+    struct sockaddr *ifa_dstaddr;
+};
+
+extern int getifaddrs(struct ifaddrs **);
+extern void freeifaddrs(struct ifaddrs *);
+#endif
diff --git a/psutil/arch/aix/init.h b/psutil/arch/aix/init.h
new file mode 100644
index 0000000000..4b16942e7f
--- /dev/null
+++ b/psutil/arch/aix/init.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/core.h>
+
+#define PROCINFO_INCR (256)
+#define PROCSIZE (sizeof(struct procentry64))
+#define FDSINFOSIZE (sizeof(struct fdsinfo64))
+#define KMEM "/dev/kmem"
+
+typedef u_longlong_t KA_T;
+
+struct procentry64 *psutil_read_process_table(int *num);
+
+PyObject *psutil_boot_time(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_stats(PyObject *self, PyObject *args);
+PyObject *psutil_disk_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_disk_partitions(PyObject *self, PyObject *args);
+PyObject *psutil_net_connections(PyObject *self, PyObject *args);
+PyObject *psutil_net_if_stats(PyObject *self, PyObject *args);
+PyObject *psutil_net_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_per_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_proc_args(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cred(PyObject *self, PyObject *args);
+PyObject *psutil_proc_environ(PyObject *self, PyObject *args);
+PyObject *psutil_proc_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_proc_name(PyObject *self, PyObject *args);
+PyObject *psutil_proc_num_ctx_switches(PyObject *self, PyObject *args);
+PyObject *psutil_proc_oneshot(PyObject *self, PyObject *args);
+PyObject *psutil_proc_threads(PyObject *self, PyObject *args);
+PyObject *psutil_swap_mem(PyObject *self, PyObject *args);
+PyObject *psutil_virtual_mem(PyObject *self, PyObject *args);
diff --git a/psutil/arch/aix/mem.c b/psutil/arch/aix/mem.c
new file mode 100644
index 0000000000..c097fc2729
--- /dev/null
+++ b/psutil/arch/aix/mem.c
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <libperfstat.h>
+
+#include "../../arch/all/init.h"
+#include "init.h"
+
+
+PyObject *
+psutil_virtual_mem(PyObject *self, PyObject *args) {
+    int rc;
+    long pagesize = psutil_getpagesize();
+    perfstat_memory_total_t memory;
+
+    rc = perfstat_memory_total(
+        NULL, &memory, sizeof(perfstat_memory_total_t), 1
+    );
+    if (rc <= 0) {
+        psutil_oserror();
+        return NULL;
+    }
+
+    return Py_BuildValue(
+        "KKKKK",
+        (unsigned long long)memory.real_total * pagesize,
+        (unsigned long long)memory.real_avail * pagesize,
+        (unsigned long long)memory.real_free * pagesize,
+        (unsigned long long)memory.real_pinned * pagesize,
+        (unsigned long long)memory.real_inuse * pagesize
+    );
+}
+
+
+PyObject *
+psutil_swap_mem(PyObject *self, PyObject *args) {
+    int rc;
+    long pagesize = psutil_getpagesize();
+    perfstat_memory_total_t memory;
+
+    rc = perfstat_memory_total(
+        NULL, &memory, sizeof(perfstat_memory_total_t), 1
+    );
+    if (rc <= 0) {
+        psutil_oserror();
+        return NULL;
+    }
+
+    return Py_BuildValue(
+        "KKKK",
+        (unsigned long long)memory.pgsp_total * pagesize,
+        (unsigned long long)memory.pgsp_free * pagesize,
+        (unsigned long long)memory.pgins * pagesize,
+        (unsigned long long)memory.pgouts * pagesize
+    );
+}
diff --git a/psutil/arch/aix/net.c b/psutil/arch/aix/net.c
new file mode 100644
index 0000000000..8bfe3005a4
--- /dev/null
+++ b/psutil/arch/aix/net.c
@@ -0,0 +1,145 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <net/if.h>
+#include <unistd.h>
+#include <libperfstat.h>
+
+#include "../../arch/all/init.h"
+#include "init.h"
+
+
+#if defined(CURR_VERSION_NETINTERFACE) && CURR_VERSION_NETINTERFACE >= 3
+PyObject *
+psutil_net_io_counters(PyObject *self, PyObject *args) {
+    perfstat_netinterface_t *statp = NULL;
+    int tot, i;
+    perfstat_id_t first;
+
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_ifc_info = NULL;
+
+    if (py_retdict == NULL)
+        return NULL;
+
+    // check how many perfstat_netinterface_t structures are available
+    tot = perfstat_netinterface(
+        NULL, NULL, sizeof(perfstat_netinterface_t), 0
+    );
+    if (tot == 0) {
+        // no network interfaces - return empty dict
+        return py_retdict;
+    }
+    if (tot < 0) {
+        psutil_oserror();
+        goto error;
+    }
+    statp = (perfstat_netinterface_t *)malloc(
+        tot * sizeof(perfstat_netinterface_t)
+    );
+    if (statp == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+    strcpy(first.name, FIRST_NETINTERFACE);
+    tot = perfstat_netinterface(
+        &first, statp, sizeof(perfstat_netinterface_t), tot
+    );
+    if (tot < 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (i = 0; i < tot; i++) {
+        py_ifc_info = Py_BuildValue(
+            "(KKKKKKKK)",
+            statp[i].obytes,  // bytes sent
+            statp[i].ibytes,  // bytes received
+            statp[i].opackets,  // packets sent
+            statp[i].ipackets,  // packets received
+            statp[i].ierrors,  // input errors
+            statp[i].oerrors,  // output errors
+            statp[i].if_iqdrops,  // dropped on input
+            statp[i].xmitdrops  // not transmitted
+        );
+        if (!py_ifc_info)
+            goto error;
+        if (PyDict_SetItemString(py_retdict, statp[i].name, py_ifc_info))
+            goto error;
+        Py_DECREF(py_ifc_info);
+    }
+
+    free(statp);
+    return py_retdict;
+
+error:
+    if (statp != NULL)
+        free(statp);
+    Py_XDECREF(py_ifc_info);
+    Py_DECREF(py_retdict);
+    return NULL;
+}
+#endif  // CURR_VERSION_NETINTERFACE
+
+
+PyObject *
+psutil_net_if_stats(PyObject *self, PyObject *args) {
+    char *nic_name;
+    int sock = 0;
+    int ret;
+    int mtu;
+    struct ifreq ifr;
+    PyObject *py_is_up = NULL;
+    PyObject *py_retlist = NULL;
+
+    if (!PyArg_ParseTuple(args, "s", &nic_name))
+        return NULL;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock == -1)
+        goto error;
+
+    str_copy(ifr.ifr_name, sizeof(ifr.ifr_name), nic_name);
+
+    // is up?
+    Py_BEGIN_ALLOW_THREADS
+    ret = ioctl(sock, SIOCGIFFLAGS, &ifr);
+    Py_END_ALLOW_THREADS
+    if (ret == -1)
+        goto error;
+    if ((ifr.ifr_flags & IFF_UP) != 0)
+        py_is_up = Py_True;
+    else
+        py_is_up = Py_False;
+    Py_INCREF(py_is_up);
+
+    // MTU
+    Py_BEGIN_ALLOW_THREADS
+    ret = ioctl(sock, SIOCGIFMTU, &ifr);
+    Py_END_ALLOW_THREADS
+    if (ret == -1)
+        goto error;
+    mtu = ifr.ifr_mtu;
+
+    close(sock);
+    py_retlist = Py_BuildValue("[Oi]", py_is_up, mtu);
+    if (!py_retlist)
+        goto error;
+    Py_DECREF(py_is_up);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_is_up);
+    if (sock != 0)
+        close(sock);
+    psutil_oserror();
+    return NULL;
+}
diff --git a/psutil/arch/aix/net_kernel_structs.h b/psutil/arch/aix/net_kernel_structs.h
new file mode 100644
index 0000000000..7382280274
--- /dev/null
+++ b/psutil/arch/aix/net_kernel_structs.h
@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/* The kernel is always 64 bit but Python is usually compiled as a 32 bit
+ * process. We're reading the kernel memory to get the network connections,
+ * so we need the structs we read to be defined with 64 bit "pointers".
+ * Here are the partial definitions of the structs we use, taken from the
+ * header files, with data type sizes converted to their 64 bit counterparts,
+ * and unused data truncated. */
+
+#ifdef __64BIT__
+// In case we're in a 64 bit process after all
+#include <sys/socketvar.h>
+#include <sys/protosw.h>
+#include <sys/unpcb.h>
+#include <sys/mbuf_base.h>
+#include <sys/mbuf_macro.h>
+#include <netinet/ip_var.h>
+#include <netinet/tcp.h>
+#include <netinet/tcpip.h>
+#include <netinet/tcp_timer.h>
+#include <netinet/tcp_var.h>
+#define file64 file
+#define socket64 socket
+#define protosw64 protosw
+#define inpcb64 inpcb
+#define tcpcb64 tcpcb
+#define unpcb64 unpcb
+#define mbuf64 mbuf
+#else  // __64BIT__
+struct file64 {
+    int f_flag;
+    int f_count;
+    int f_options;
+    int f_type;
+    u_longlong_t f_data;
+};
+
+struct socket64 {
+    short so_type;  // generic type, see socket.h
+    short so_options;  // from socket call, see socket.h
+    ushort so_linger;  // time to linger while closing
+    short so_state;  // internal state flags SS_*, below
+    u_longlong_t so_pcb;  // protocol control block
+    u_longlong_t so_proto;  // protocol handle
+};
+
+struct protosw64 {
+    short pr_type;  // socket type used for
+    u_longlong_t pr_domain;  // domain protocol a member of
+    short pr_protocol;  // protocol number
+    short pr_flags;  // see below
+};
+
+struct inpcb64 {
+    u_longlong_t inp_next, inp_prev;
+    // pointers to other pcb's
+    u_longlong_t
+        inp_head;  // pointer back to chain of inpcb's for this protocol
+    u_int32_t inp_iflowinfo;  // input flow label
+    u_short inp_fport;  // foreign port
+    u_int16_t inp_fatype;  // foreign address type
+    union in_addr_6 inp_faddr_6;  // foreign host table entry
+    u_int32_t inp_oflowinfo;  // output flow label
+    u_short inp_lport;  // local port
+    u_int16_t inp_latype;  // local address type
+    union in_addr_6 inp_laddr_6;  // local host table entry
+    u_longlong_t inp_socket;  // back pointer to socket
+    u_longlong_t inp_ppcb;  // pointer to per-protocol pcb
+    u_longlong_t space_rt;
+    struct sockaddr_in6 spare_dst;
+    u_longlong_t inp_ifa;  // interface address to use
+    int inp_flags;  // generic IP/datagram flags
+};
+
+struct tcpcb64 {
+    u_longlong_t seg__next;
+    u_longlong_t seg__prev;
+    short t_state;  // state of this connection
+};
+
+struct unpcb64 {
+    u_longlong_t unp_socket;  // pointer back to socket
+    u_longlong_t unp_vnode;  // if associated with file
+    ino_t unp_vno;  // fake vnode number
+    u_longlong_t unp_conn;  // control block of connected socket
+    u_longlong_t unp_refs;  // referencing socket linked list
+    u_longlong_t unp_nextref;  // link in unp_refs list
+    u_longlong_t unp_addr;  // bound address of socket
+};
+
+struct m_hdr64 {
+    u_longlong_t mh_next;  // next buffer in chain
+    u_longlong_t mh_nextpkt;  // next chain in queue/record
+    long mh_len;  // amount of data in this mbuf
+    u_longlong_t mh_data;  // location of data
+};
+
+struct mbuf64 {
+    struct m_hdr64 m_hdr;
+};
+
+#define m_len m_hdr.mh_len
+
+#endif  // __64BIT__
diff --git a/psutil/arch/aix/proc.c b/psutil/arch/aix/proc.c
new file mode 100644
index 0000000000..ca48aca4cc
--- /dev/null
+++ b/psutil/arch/aix/proc.c
@@ -0,0 +1,457 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <fcntl.h>
+#include <procinfo.h>
+#include <stdlib.h>
+#include <sys/limits.h>
+#include <sys/proc.h>
+#include <sys/procfs.h>
+#include <libperfstat.h>
+#include <unistd.h>
+
+#include "../../arch/all/init.h"
+#include "init.h"
+
+
+#define TV2DOUBLE(t) (((t).tv_nsec * 0.000000001) + (t).tv_sec)
+
+// Read a file content and fills a C structure with it.
+int
+psutil_file_to_struct(char *path, void *fstruct, size_t size) {
+    int fd;
+    size_t nbytes;
+    fd = open(path, O_RDONLY);
+    if (fd == -1) {
+        PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
+        return 0;
+    }
+    nbytes = read(fd, fstruct, size);
+    if (nbytes <= 0) {
+        close(fd);
+        psutil_oserror();
+        return 0;
+    }
+    if (nbytes != size) {
+        close(fd);
+        psutil_runtime_error("psutil_file_to_struct() size mismatch");
+        return 0;
+    }
+    close(fd);
+    return nbytes;
+}
+
+
+struct procentry64 *
+psutil_read_process_table(int *num) {
+    size_t msz;
+    pid32_t pid = 0;
+    struct procentry64 *processes = (struct procentry64 *)NULL;
+    struct procentry64 *p;
+    int Np = 0;  // number of processes allocated in 'processes'
+    int np = 0;  // number of processes read into 'processes'
+    int i;  // number of processes read in current iteration
+
+    msz = (size_t)(PROCSIZE * PROCINFO_INCR);
+    processes = (struct procentry64 *)malloc(msz);
+    if (!processes) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    Np = PROCINFO_INCR;
+    p = processes;
+    for (;;) {
+        Py_BEGIN_ALLOW_THREADS
+        i = getprocs64(
+            p, PROCSIZE, (struct fdsinfo64 *)NULL, 0, &pid, PROCINFO_INCR
+        );
+        Py_END_ALLOW_THREADS
+        if (i != PROCINFO_INCR)
+            break;
+        np += PROCINFO_INCR;
+        if (np >= Np) {
+            msz = (size_t)(PROCSIZE * (Np + PROCINFO_INCR));
+            processes = (struct procentry64 *)realloc((char *)processes, msz);
+            if (!processes) {
+                PyErr_NoMemory();
+                return NULL;
+            }
+            Np += PROCINFO_INCR;
+        }
+        p = (struct procentry64 *)((char *)processes + (np * PROCSIZE));
+    }
+
+    // add the number of processes read in the last iteration
+    if (i > 0)
+        np += i;
+
+    *num = np;
+    return processes;
+}
+
+
+// Return process ppid, rss, vms, ctime, nice, nthreads, status and tty
+// as a Python tuple.
+PyObject *
+psutil_proc_oneshot(PyObject *self, PyObject *args) {
+    int pid;
+    char path[100];
+    psinfo_t info;
+    pstatus_t status;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+
+    str_format(path, sizeof(path), "%s/%i/psinfo", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+
+    if (info.pr_nlwp == 0 && info.pr_lwp.pr_lwpid == 0) {
+        // From the /proc docs: "If the process is a zombie, the pr_nlwp
+        // and pr_lwp.pr_lwpid flags are zero."
+        status.pr_stat = SZOMB;
+    }
+    else if (info.pr_flag & SEXIT) {
+        // "exiting" processes don't have /proc/<pid>/status
+        // There are other "exiting" processes that 'ps' shows as "active"
+        status.pr_stat = SACTIVE;
+    }
+    else {
+        str_format(path, sizeof(path), "%s/%i/status", procfs_path, pid);
+        if (!psutil_file_to_struct(path, (void *)&status, sizeof(status)))
+            return NULL;
+    }
+
+    return Py_BuildValue(
+        "KKKdiiiK",
+        (unsigned long long)info.pr_ppid,  // parent pid
+        (unsigned long long)info.pr_rssize,  // rss
+        (unsigned long long)info.pr_size,  // vms
+        TV2DOUBLE(info.pr_start),  // create time
+        (int)info.pr_lwp.pr_nice,  // nice
+        (int)info.pr_nlwp,  // no. of threads
+        (int)status.pr_stat,  // status code
+        (unsigned long long)info.pr_ttydev  // tty nr
+    );
+}
+
+
+PyObject *
+psutil_proc_name(PyObject *self, PyObject *args) {
+    int pid;
+    char path[100];
+    psinfo_t info;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+    str_format(path, sizeof(path), "%s/%i/psinfo", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+
+    return PyUnicode_DecodeFSDefaultAndSize(info.pr_fname, PRFNSZ);
+}
+
+
+// Return process command line arguments as a Python list
+PyObject *
+psutil_proc_args(PyObject *self, PyObject *args) {
+    int pid;
+    PyObject *py_retlist = PyList_New(0);
+    struct procsinfo procbuf;
+    long arg_max;
+    char *argbuf = NULL;
+    char *curarg = NULL;
+    int ret;
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, "i", &pid))
+        goto error;
+    arg_max = sysconf(_SC_ARG_MAX);
+    argbuf = malloc(arg_max);
+    if (argbuf == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    procbuf.pi_pid = pid;
+    ret = getargs(&procbuf, sizeof(procbuf), argbuf, ARG_MAX);
+    if (ret == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    curarg = argbuf;
+    // getargs will always append an extra NULL to end the arg list,
+    // even if the buffer is not big enough (even though it is supposed
+    // to be) so the following 'while' is safe
+    while (*curarg != '\0') {
+        if (!pylist_append_obj(py_retlist, PyUnicode_DecodeFSDefault(curarg)))
+            goto error;
+        curarg = strchr(curarg, '\0') + 1;
+    }
+
+    free(argbuf);
+
+    return py_retlist;
+
+error:
+    if (argbuf != NULL)
+        free(argbuf);
+    Py_XDECREF(py_retlist);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_environ(PyObject *self, PyObject *args) {
+    int pid;
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_key = NULL;
+    PyObject *py_val = NULL;
+    struct procsinfo procbuf;
+    long env_max;
+    char *envbuf = NULL;
+    char *curvar = NULL;
+    char *separator = NULL;
+    int ret;
+
+    if (py_retdict == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, "i", &pid))
+        goto error;
+    env_max = sysconf(_SC_ARG_MAX);
+    envbuf = malloc(env_max);
+    if (envbuf == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    procbuf.pi_pid = pid;
+    ret = getevars(&procbuf, sizeof(procbuf), envbuf, ARG_MAX);
+    if (ret == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    curvar = envbuf;
+    // getevars will always append an extra NULL to end the arg list,
+    // even if the buffer is not big enough (even though it is supposed
+    // to be) so the following 'while' is safe
+    while (*curvar != '\0') {
+        separator = strchr(curvar, '=');
+        if (separator != NULL) {
+            py_key = PyUnicode_DecodeFSDefaultAndSize(
+                curvar, (Py_ssize_t)(separator - curvar)
+            );
+            if (!py_key)
+                goto error;
+            py_val = PyUnicode_DecodeFSDefault(separator + 1);
+            if (!py_val)
+                goto error;
+            if (PyDict_SetItem(py_retdict, py_key, py_val))
+                goto error;
+            Py_CLEAR(py_key);
+            Py_CLEAR(py_val);
+        }
+        curvar = strchr(curvar, '\0') + 1;
+    }
+
+    free(envbuf);
+
+    return py_retdict;
+
+error:
+    if (envbuf != NULL)
+        free(envbuf);
+    Py_XDECREF(py_retdict);
+    Py_XDECREF(py_key);
+    Py_XDECREF(py_val);
+    return NULL;
+}
+
+
+#ifdef CURR_VERSION_THREAD
+PyObject *
+psutil_proc_threads(PyObject *self, PyObject *args) {
+    long pid;
+    PyObject *py_retlist = PyList_New(0);
+    perfstat_thread_t *threadt = NULL;
+    perfstat_id_t id;
+    int i, rc, thread_count;
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, "l", &pid))
+        goto error;
+
+    // Get the count of threads
+    thread_count = perfstat_thread(NULL, NULL, sizeof(perfstat_thread_t), 0);
+    if (thread_count <= 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    // Allocate enough memory
+    threadt = (perfstat_thread_t *)calloc(
+        thread_count, sizeof(perfstat_thread_t)
+    );
+    if (threadt == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    strcpy(id.name, "");
+    rc = perfstat_thread(
+        &id, threadt, sizeof(perfstat_thread_t), thread_count
+    );
+    if (rc <= 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (i = 0; i < thread_count; i++) {
+        if (threadt[i].pid != pid)
+            continue;
+
+        if (!pylist_append_fmt(
+                py_retlist,
+                "Idd",
+                threadt[i].tid,
+                threadt[i].ucpu_time,
+                threadt[i].scpu_time
+            ))
+        {
+            goto error;
+        }
+    }
+    free(threadt);
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    if (threadt != NULL)
+        free(threadt);
+    return NULL;
+}
+#endif  // CURR_VERSION_THREAD
+
+
+#ifdef CURR_VERSION_PROCESS
+PyObject *
+psutil_proc_io_counters(PyObject *self, PyObject *args) {
+    long pid;
+    int rc;
+    perfstat_process_t procinfo;
+    perfstat_id_t id;
+    if (!PyArg_ParseTuple(args, "l", &pid))
+        return NULL;
+
+    snprintf(id.name, sizeof(id.name), "%ld", pid);
+    rc = perfstat_process(&id, &procinfo, sizeof(perfstat_process_t), 1);
+    if (rc <= 0) {
+        psutil_oserror();
+        return NULL;
+    }
+
+    return Py_BuildValue(
+        "(KKKK)",
+        procinfo.inOps,  // XXX always 0
+        procinfo.outOps,
+        procinfo.inBytes,  // XXX always 0
+        procinfo.outBytes
+    );
+}
+#endif  // CURR_VERSION_PROCESS
+
+
+PyObject *
+psutil_proc_cpu_times(PyObject *self, PyObject *args) {
+    int pid;
+    char path[100];
+    pstatus_t info;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+    str_format(path, sizeof(path), "%s/%i/status", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+    // results are more precise than os.times()
+    return Py_BuildValue(
+        "dddd",
+        TV2DOUBLE(info.pr_utime),
+        TV2DOUBLE(info.pr_stime),
+        TV2DOUBLE(info.pr_cutime),
+        TV2DOUBLE(info.pr_cstime)
+    );
+}
+
+
+// Return process uids/gids as a Python tuple.
+PyObject *
+psutil_proc_cred(PyObject *self, PyObject *args) {
+    int pid;
+    char path[100];
+    prcred_t info;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+    str_format(path, sizeof(path), "%s/%i/cred", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+    return Py_BuildValue(
+        "iiiiii",
+        info.pr_ruid,
+        info.pr_euid,
+        info.pr_suid,
+        info.pr_rgid,
+        info.pr_egid,
+        info.pr_sgid
+    );
+}
+
+
+PyObject *
+psutil_proc_num_ctx_switches(PyObject *self, PyObject *args) {
+    PyObject *py_tuple = NULL;
+    pid32_t requested_pid;
+    pid32_t pid = 0;
+    int np = 0;
+    struct procentry64 *processes = (struct procentry64 *)NULL;
+    struct procentry64 *p;
+
+    if (!PyArg_ParseTuple(args, "i", &requested_pid))
+        return NULL;
+
+    processes = psutil_read_process_table(&np);
+    if (!processes)
+        return NULL;
+
+    // Loop through processes
+    for (p = processes; np > 0; np--, p++) {
+        pid = p->pi_pid;
+        if (requested_pid != pid)
+            continue;
+        py_tuple = Py_BuildValue(
+            "LL",
+            (long long)p->pi_ru.ru_nvcsw,  // voluntary
+            (long long)p->pi_ru.ru_nivcsw  // involuntary
+        );
+        free(processes);
+        return py_tuple;
+    }
+
+    // finished iteration without finding requested pid
+    free(processes);
+    return psutil_oserror_nsp("psutil_read_process_table (no PID found)");
+}
diff --git a/psutil/arch/aix/socks.c b/psutil/arch/aix/socks.c
new file mode 100644
index 0000000000..27a30b25fd
--- /dev/null
+++ b/psutil/arch/aix/socks.c
@@ -0,0 +1,345 @@
+/*
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Based on code from lsof:
+// http://www.ibm.com/developerworks/aix/library/au-lsof.html
+// - dialects/aix/dproc.c:gather_proc_info
+// - lib/prfp.c:process_file
+// - dialects/aix/dsock.c:process_socket
+// - dialects/aix/dproc.c:get_kernel_access
+
+#include <Python.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#define _KERNEL
+#include <sys/file.h>
+#undef _KERNEL
+#include <sys/types.h>
+#include <sys/core.h>
+#include <sys/domain.h>
+#include <sys/un.h>
+#include <netinet/in_pcb.h>
+#include <arpa/inet.h>
+
+#include "../../arch/all/init.h"
+#include "net_kernel_structs.h"
+#include "init.h"
+
+
+// Read from kernel memory.
+static int
+psutil_kread(
+    int Kd,  // kernel memory file descriptor
+    KA_T addr,  // kernel memory address
+    char *buf,  // buffer to receive data
+    size_t len  // length to read
+) {
+    int br;
+    off64_t off;
+
+    Py_BEGIN_ALLOW_THREADS
+    off = lseek64(Kd, (off64_t)addr, L_SET);
+    Py_END_ALLOW_THREADS
+    if (off == (off64_t)-1) {
+        psutil_oserror();
+        return 1;
+    }
+    Py_BEGIN_ALLOW_THREADS
+    br = read(Kd, buf, len);
+    Py_END_ALLOW_THREADS
+    if (br == -1) {
+        psutil_oserror();
+        return 1;
+    }
+    if (br != len) {
+        psutil_runtime_error("size mismatch when reading kernel memory fd");
+        return 1;
+    }
+    return 0;
+}
+
+
+#define NO_SOCKET (PyObject *)(-1)
+
+static int
+read_unp_addr(int Kd, KA_T unp_addr, char *buf, size_t buflen) {
+    struct sockaddr_un *ua = (struct sockaddr_un *)NULL;
+    struct sockaddr_un un;
+    struct mbuf64 mb;
+    int uo;
+
+    if (psutil_kread(Kd, unp_addr, (char *)&mb, sizeof(mb))) {
+        return 1;
+    }
+
+    uo = (int)(mb.m_hdr.mh_data - unp_addr);
+    if ((uo + sizeof(struct sockaddr)) <= sizeof(mb))
+        ua = (struct sockaddr_un *)((char *)&mb + uo);
+    else {
+        if (psutil_kread(Kd, (KA_T)mb.m_hdr.mh_data, (char *)&un, sizeof(un)))
+        {
+            return 1;
+        }
+        ua = &un;
+    }
+    if (ua && ua->sun_path[0]) {
+        if (mb.m_len > sizeof(struct sockaddr_un))
+            mb.m_len = sizeof(struct sockaddr_un);
+        *((char *)ua + mb.m_len - 1) = '\0';
+        snprintf(buf, buflen, "%s", ua->sun_path);
+    }
+    return 0;
+}
+
+static PyObject *
+process_file(int Kd, pid32_t pid, int fd, KA_T fp) {
+    struct file64 f;
+    struct socket64 s;
+    struct protosw64 p;
+    struct domain d;
+    struct inpcb64 inp;
+    int fam;
+    struct tcpcb64 t;
+    int state = PSUTIL_CONN_NONE;
+    unsigned char *laddr = (unsigned char *)NULL;
+    unsigned char *raddr = (unsigned char *)NULL;
+    int rport, lport;
+    char laddr_str[INET6_ADDRSTRLEN];
+    char raddr_str[INET6_ADDRSTRLEN];
+    struct unpcb64 unp;
+    char unix_laddr_str[PATH_MAX] = {0};
+    char unix_raddr_str[PATH_MAX] = {0};
+
+    // Read file structure
+    if (psutil_kread(Kd, fp, (char *)&f, sizeof(f))) {
+        return NULL;
+    }
+    if (!f.f_count || f.f_type != DTYPE_SOCKET) {
+        return NO_SOCKET;
+    }
+
+    if (psutil_kread(Kd, (KA_T)f.f_data, (char *)&s, sizeof(s))) {
+        return NULL;
+    }
+
+    if (!s.so_type) {
+        return NO_SOCKET;
+    }
+
+    if (!s.so_proto) {
+        psutil_runtime_error("invalid socket protocol handle");
+        return NULL;
+    }
+    if (psutil_kread(Kd, (KA_T)s.so_proto, (char *)&p, sizeof(p))) {
+        return NULL;
+    }
+
+    if (!p.pr_domain) {
+        psutil_runtime_error("invalid socket protocol domain");
+        return NULL;
+    }
+    if (psutil_kread(Kd, (KA_T)p.pr_domain, (char *)&d, sizeof(d))) {
+        return NULL;
+    }
+
+    fam = d.dom_family;
+    if (fam == AF_INET || fam == AF_INET6) {
+        // Read protocol control block
+        if (!s.so_pcb) {
+            psutil_runtime_error("invalid socket PCB");
+            return NULL;
+        }
+        if (psutil_kread(Kd, (KA_T)s.so_pcb, (char *)&inp, sizeof(inp))) {
+            return NULL;
+        }
+
+        if (p.pr_protocol == IPPROTO_TCP) {
+            // If this is a TCP socket, read its control block
+            if (inp.inp_ppcb
+                && !psutil_kread(
+                    Kd, (KA_T)inp.inp_ppcb, (char *)&t, sizeof(t)
+                ))
+                state = t.t_state;
+        }
+
+        if (fam == AF_INET6) {
+            laddr = (unsigned char *)&inp.inp_laddr6;
+            if (!IN6_IS_ADDR_UNSPECIFIED(&inp.inp_faddr6)) {
+                raddr = (unsigned char *)&inp.inp_faddr6;
+                rport = (int)ntohs(inp.inp_fport);
+            }
+        }
+        if (fam == AF_INET) {
+            laddr = (unsigned char *)&inp.inp_laddr;
+            if (inp.inp_faddr.s_addr != INADDR_ANY || inp.inp_fport != 0) {
+                raddr = (unsigned char *)&inp.inp_faddr;
+                rport = (int)ntohs(inp.inp_fport);
+            }
+        }
+        lport = (int)ntohs(inp.inp_lport);
+
+        inet_ntop(fam, laddr, laddr_str, sizeof(laddr_str));
+
+        if (raddr != NULL) {
+            inet_ntop(fam, raddr, raddr_str, sizeof(raddr_str));
+            return Py_BuildValue(
+                "(iii(si)(si)ii)",
+                fd,
+                fam,
+                s.so_type,
+                laddr_str,
+                lport,
+                raddr_str,
+                rport,
+                state,
+                pid
+            );
+        }
+        else {
+            return Py_BuildValue(
+                "(iii(si)()ii)",
+                fd,
+                fam,
+                s.so_type,
+                laddr_str,
+                lport,
+                state,
+                pid
+            );
+        }
+    }
+
+
+    if (fam == AF_UNIX) {
+        if (psutil_kread(Kd, (KA_T)s.so_pcb, (char *)&unp, sizeof(unp))) {
+            return NULL;
+        }
+        if ((KA_T)f.f_data != (KA_T)unp.unp_socket) {
+            psutil_runtime_error("unp_socket mismatch");
+            return NULL;
+        }
+
+        if (unp.unp_addr) {
+            if (read_unp_addr(
+                    Kd, unp.unp_addr, unix_laddr_str, sizeof(unix_laddr_str)
+                ))
+            {
+                return NULL;
+            }
+        }
+
+        if (unp.unp_conn) {
+            if (psutil_kread(
+                    Kd, (KA_T)unp.unp_conn, (char *)&unp, sizeof(unp)
+                ))
+            {
+                return NULL;
+            }
+            if (read_unp_addr(
+                    Kd, unp.unp_addr, unix_raddr_str, sizeof(unix_raddr_str)
+                ))
+            {
+                return NULL;
+            }
+        }
+
+        return Py_BuildValue(
+            "(iiissii)",
+            fd,
+            d.dom_family,
+            s.so_type,
+            unix_laddr_str,
+            unix_raddr_str,
+            PSUTIL_CONN_NONE,
+            pid
+        );
+    }
+    return NO_SOCKET;
+}
+
+PyObject *
+psutil_net_connections(PyObject *self, PyObject *args) {
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_tuple = NULL;
+    KA_T fp;
+    int Kd = -1;
+    int i, np;
+    struct procentry64 *p;
+    struct fdsinfo64 *fds = (struct fdsinfo64 *)NULL;
+    pid32_t requested_pid;
+    pid32_t pid;
+    struct procentry64 *processes = (struct procentry64 *)NULL;
+    // the process table
+
+    if (py_retlist == NULL)
+        goto error;
+    if (!PyArg_ParseTuple(args, "i", &requested_pid))
+        goto error;
+
+    Kd = open(KMEM, O_RDONLY, 0);
+    if (Kd < 0) {
+        PyErr_SetFromErrnoWithFilename(PyExc_OSError, KMEM);
+        goto error;
+    }
+
+    processes = psutil_read_process_table(&np);
+    if (!processes)
+        goto error;
+
+    // Loop through processes
+    for (p = processes; np > 0; np--, p++) {
+        pid = p->pi_pid;
+        if (requested_pid != -1 && requested_pid != pid)
+            continue;
+        if (p->pi_state == 0 || p->pi_state == SZOMB)
+            continue;
+
+        if (!fds) {
+            fds = (struct fdsinfo64 *)malloc((size_t)FDSINFOSIZE);
+            if (!fds) {
+                PyErr_NoMemory();
+                goto error;
+            }
+        }
+        if (getprocs64(
+                (struct procentry64 *)NULL, PROCSIZE, fds, FDSINFOSIZE, &pid, 1
+            )
+            != 1)
+            continue;
+
+        // loop over file descriptors
+        for (i = 0; i < p->pi_maxofile; i++) {
+            fp = (KA_T)fds->pi_ufd[i].fp;
+            if (fp) {
+                py_tuple = process_file(Kd, p->pi_pid, i, fp);
+                if (py_tuple == NULL)
+                    goto error;
+                if (py_tuple != NO_SOCKET) {
+                    if (PyList_Append(py_retlist, py_tuple))
+                        goto error;
+                    Py_DECREF(py_tuple);
+                }
+            }
+        }
+    }
+    close(Kd);
+    free(processes);
+    if (fds != NULL)
+        free(fds);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_tuple);
+    Py_DECREF(py_retlist);
+    if (Kd > 0)
+        close(Kd);
+    if (processes != NULL)
+        free(processes);
+    if (fds != NULL)
+        free(fds);
+    return NULL;
+}
diff --git a/psutil/arch/aix/sys.c b/psutil/arch/aix/sys.c
new file mode 100644
index 0000000000..b34499b8ef
--- /dev/null
+++ b/psutil/arch/aix/sys.c
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'
+ * Copyright (c) 2017, Arnon Yaari
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <utmpx.h>
+
+#include "../../arch/all/init.h"
+#include "init.h"
+
+
+PyObject *
+psutil_boot_time(PyObject *self, PyObject *args) {
+    float boot_time = 0.0;
+    struct utmpx *ut;
+
+    UTXENT_MUTEX_LOCK();
+    setutxent();
+    while (NULL != (ut = getutxent())) {
+        if (ut->ut_type == BOOT_TIME) {
+            boot_time = (float)ut->ut_tv.tv_sec;
+            break;
+        }
+    }
+    endutxent();
+    UTXENT_MUTEX_UNLOCK();
+    if (boot_time == 0.0) {
+        // could not find BOOT_TIME in getutxent loop
+        psutil_runtime_error("can't determine boot time");
+        return NULL;
+    }
+    return Py_BuildValue("f", boot_time);
+}
diff --git a/psutil/arch/all/errors.c b/psutil/arch/all/errors.c
new file mode 100644
index 0000000000..29c75f25aa
--- /dev/null
+++ b/psutil/arch/all/errors.c
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#if defined(PSUTIL_WINDOWS)
+#include <windows.h>
+#endif
+
+#include "init.h"
+
+#define MSG_SIZE 512
+
+
+// Set OSError() based on errno (UNIX) or GetLastError() (Windows).
+PyObject *
+psutil_oserror(void) {
+#ifdef PSUTIL_WINDOWS
+    PyErr_SetFromWindowsErr(GetLastError());
+#else
+    PyErr_SetFromErrno(PyExc_OSError);
+#endif
+    return NULL;
+}
+
+
+// Same as above, but adds the syscall to the exception message. On
+// Windows this is achieved by setting the `filename` attribute of the
+// OSError object.
+PyObject *
+psutil_oserror_wsyscall(const char *syscall) {
+    char msg[MSG_SIZE];
+
+#ifdef PSUTIL_WINDOWS
+    DWORD err = GetLastError();
+    str_format(msg, sizeof(msg), "(originated from %s)", syscall);
+    PyErr_SetFromWindowsErrWithFilename(err, msg);
+#else
+    PyObject *exc;
+    int saved_errno = errno;
+    str_format(
+        msg,
+        sizeof(msg),
+        "%s (originated from %s)",
+        strerror(saved_errno),
+        syscall
+    );
+    exc = PyObject_CallFunction(PyExc_OSError, "(is)", saved_errno, msg);
+    if (exc != NULL) {
+        PyErr_SetObject(PyExc_OSError, exc);
+        Py_DECREF(exc);
+    }
+#endif
+    return NULL;
+}
+
+
+// Set OSError(errno=ESRCH) ("No such process").
+PyObject *
+psutil_oserror_nsp(const char *syscall) {
+    PyObject *exc;
+    char msg[MSG_SIZE];
+
+    str_format(
+        msg, sizeof(msg), "force no such process (originated from %s)", syscall
+    );
+    exc = PyObject_CallFunction(PyExc_OSError, "(is)", ESRCH, msg);
+    if (exc != NULL) {
+        PyErr_SetObject(PyExc_OSError, exc);
+        Py_DECREF(exc);
+    }
+    return NULL;
+}
+
+
+// Set OSError(errno=EACCES) ("Permission denied").
+PyObject *
+psutil_oserror_ad(const char *syscall) {
+    PyObject *exc;
+    char msg[MSG_SIZE];
+
+    str_format(
+        msg,
+        sizeof(msg),
+        "force permission denied (originated from %s)",
+        syscall
+    );
+    exc = PyObject_CallFunction(PyExc_OSError, "(is)", EACCES, msg);
+    if (exc != NULL) {
+        PyErr_SetObject(PyExc_OSError, exc);
+        Py_DECREF(exc);
+    }
+    return NULL;
+}
+
+
+// Print a debug message to stderr if PSUTIL_DEBUG mode is enabled.
+// Don't call this directly, use the psutil_debug() macro.
+void
+_psutil_debug_impl(const char *file, int lineno, const char *fmt, ...) {
+    va_list args;
+
+    if (!PSUTIL_DEBUG)
+        return;
+    fprintf(stderr, "psutil-debug [%s:%d]> ", file, lineno);
+    va_start(args, fmt);
+    vfprintf(stderr, fmt, args);
+    va_end(args);
+    fprintf(stderr, "\n");
+}
+
+
+// Emit a RuntimeWarning, also printed as a debug message. It never
+// raises: with -W error the exception is discarded. Use it for events
+// which are never supposed to happen, and imply a psutil bug. Don't
+// call this directly, use the psutil_warn() macro.
+// Plain [v]snprintf() and no str_*() helpers in here: their failure
+// path calls psutil_warn(), which would recurse back into us.
+void
+_psutil_warn_impl(const char *file, int lineno, const char *fmt, ...) {
+    char msg[MSG_SIZE];
+    char full[MSG_SIZE + 512];
+    const char *warning;
+    va_list args;
+    int ret;
+    PyGILState_STATE gstate;
+
+    va_start(args, fmt);
+    ret = vsnprintf(msg, sizeof(msg), fmt, args);
+    va_end(args);
+    msg[sizeof(msg) - 1] = '\0';
+    // If vsnprintf() failed msg is garbage.
+    warning = (ret < 0) ? "psutil_warn: bad format" : msg;
+
+    _psutil_debug_impl(file, lineno, "%s", warning);
+
+    ret = snprintf(
+        full, sizeof(full), "%s (originated from %s:%d)", warning, file, lineno
+    );
+    full[sizeof(full) - 1] = '\0';
+    if (ret >= 0)
+        warning = full;
+
+    if (PSUTIL_TESTING) {
+        fprintf(stderr, "CRITICAL: %s\n", warning);
+        fflush(stderr);
+        exit(EXIT_FAILURE);  // terminate execution
+    }
+
+    // Grab the GIL: unlike psutil_debug() this is safe to call also
+    // inside Py_BEGIN/END_ALLOW_THREADS blocks. Caveat: the
+    // PyGILState_* API doesn't support sub-interpreters.
+    gstate = PyGILState_Ensure();
+    if (PyErr_WarnEx(PyExc_RuntimeWarning, warning, 1) != 0)
+        PyErr_Clear();
+    PyGILState_Release(gstate);
+}
+
+
+// Set RuntimeError with formatted `msg` and optional arguments.
+PyObject *
+psutil_runtime_error(const char *msg, ...) {
+    va_list args;
+
+    va_start(args, msg);
+    PyErr_FormatV(PyExc_RuntimeError, msg, args);
+    va_end(args);
+    return NULL;
+}
+
+
+// Use it when invalid args are passed to a C function.
+int
+psutil_badargs(const char *funcname) {
+    PyErr_Format(
+        PyExc_RuntimeError, "%s() invalid args passed to function", funcname
+    );
+    return -1;
+}
diff --git a/psutil/arch/all/init.c b/psutil/arch/all/init.c
new file mode 100644
index 0000000000..a908a2e63b
--- /dev/null
+++ b/psutil/arch/all/init.c
@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Global names shared by all platforms.
+
+#include <Python.h>
+
+#include "init.h"
+
+int PSUTIL_DEBUG = 0;
+int PSUTIL_TESTING = 0;
+int PSUTIL_CONN_NONE = 128;
+
+#ifdef Py_GIL_DISABLED
+PyMutex utxent_lock = {0};
+#endif
+
+
+// Enable or disable PSUTIL_DEBUG messages.
+PyObject *
+psutil_set_debug(PyObject *self, PyObject *args) {
+    int value;
+
+    if (!PyArg_ParseTuple(args, "p", &value))
+        return NULL;
+    PSUTIL_DEBUG = value;
+    Py_RETURN_NONE;
+}
+
+
+// Called on module import on all platforms.
+int
+psutil_setup(void) {
+    if (getenv("PSUTIL_DEBUG") != NULL)
+        PSUTIL_DEBUG = 1;
+    if (getenv("PSUTIL_TESTING") != NULL)
+        PSUTIL_TESTING = 1;
+    return 0;
+}
+
+
+// Create a custom exception once (cached in *dst) and add it to the
+// module. PyModule_AddObject() steals a ref on success only, so INCREF
+// first and drop it again on failure.
+static int
+_psutil_add_exception(
+    PyObject *mod, const char *name, const char *qualname, PyObject **dst
+) {
+    if (*dst == NULL) {
+        *dst = PyErr_NewException(qualname, NULL, NULL);
+        if (*dst == NULL)
+            return -1;
+    }
+    Py_INCREF(*dst);
+    if (PyModule_AddObject(mod, name, *dst)) {
+        Py_DECREF(*dst);
+        return -1;
+    }
+    return 0;
+}
+
+
+// Add exceptions to the C extension module.
+int
+psutil_add_exceptions(PyObject *mod) {
+#ifdef PSUTIL_WINDOWS
+    if (_psutil_add_exception(
+            mod, "TimeoutExpired", "_psutil.TimeoutExpired", &TimeoutExpired
+        ))
+        return -1;
+    if (_psutil_add_exception(
+            mod,
+            "TimeoutAbandoned",
+            "_psutil.TimeoutAbandoned",
+            &TimeoutAbandoned
+        ))
+        return -1;
+#elif defined(PSUTIL_POSIX)
+    if (_psutil_add_exception(
+            mod,
+            "ZombieProcessError",
+            "_psutil.ZombieProcessError",
+            &ZombieProcessError
+        ))
+        return -1;
+#endif
+    return 0;
+}
+
+
+// Initialize the Python C extension module.
+PyObject *
+psutil_mod_init(
+    const char *name, PyMethodDef *methods, int (*exec)(PyObject *)
+) {
+    static PyModuleDef_Slot slots[] = {
+        {Py_mod_exec, NULL},  // platform exec, filled below
+#ifdef Py_mod_gil
+        {Py_mod_gil, Py_MOD_GIL_NOT_USED},
+#endif
+        {0, NULL}
+    };
+    static struct PyModuleDef def = {
+        .m_base = PyModuleDef_HEAD_INIT,
+        .m_size = 0,
+        .m_slots = slots,
+    };
+
+    slots[0].value = (void *)exec;
+    def.m_name = name;
+    def.m_methods = methods;
+    return PyModuleDef_Init(&def);
+}
diff --git a/psutil/arch/all/init.h b/psutil/arch/all/init.h
new file mode 100644
index 0000000000..b5d0d4ddb9
--- /dev/null
+++ b/psutil/arch/all/init.h
@@ -0,0 +1,168 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Global names shared by all platforms.
+
+#include <Python.h>
+
+// We do this so that all .c files have to include only one header
+// (ourselves, init.h).
+
+// clang-format off
+#if defined(PSUTIL_POSIX)
+    #include "../../arch/posix/init.h"
+#endif
+#if defined(PSUTIL_BSD)
+    #include "../../arch/bsd/init.h"
+#endif
+
+#if defined(PSUTIL_LINUX)
+    #include "../../arch/linux/init.h"
+#elif defined(PSUTIL_WINDOWS)
+    #include "../../arch/windows/init.h"
+#elif defined(PSUTIL_OSX)
+    #include "../../arch/osx/init.h"
+#elif defined(PSUTIL_FREEBSD)
+    #include "../../arch/freebsd/init.h"
+#elif defined(PSUTIL_OPENBSD)
+    #include "../../arch/openbsd/init.h"
+#elif defined(PSUTIL_NETBSD)
+    #include "../../arch/netbsd/init.h"
+#elif defined(PSUTIL_SUNOS)
+    #include "../../arch/sunos/init.h"
+#endif
+
+// print debug messages when set to 1
+extern int PSUTIL_DEBUG;
+// a signaler for connections without an actual status
+extern int PSUTIL_CONN_NONE;
+extern int PSUTIL_TESTING;
+
+#ifdef Py_GIL_DISABLED
+    extern PyMutex utxent_lock;
+    #define UTXENT_MUTEX_LOCK() PyMutex_Lock(&utxent_lock)
+    #define UTXENT_MUTEX_UNLOCK() PyMutex_Unlock(&utxent_lock)
+#else
+    #define UTXENT_MUTEX_LOCK()
+    #define UTXENT_MUTEX_UNLOCK()
+#endif
+// clang-format on
+
+// Add an int constant to the module; return -1 on failure.
+#define PSUTIL_ADD_INT(mod, name, value)                     \
+    do {                                                     \
+        if (PyModule_AddIntConstant((mod), (name), (value))) \
+            return -1;                                       \
+    } while (0)
+
+
+// ====================================================================
+// --- Backward compatibility with missing Python.h APIs
+// ====================================================================
+
+// --- _Py_PARSE_PID
+
+// clang-format off
+// SIZEOF_INT|LONG is missing on Linux + PyPy (only?).
+// In this case we guess it from setup.py. It's not 100% bullet proof,
+// If wrong we'll probably get compiler warnings.
+// FWIW on all UNIX platforms I've seen pid_t is defined as an int.
+// _getpid() on Windows also returns an int.
+#if !defined(SIZEOF_INT)
+    #define SIZEOF_INT 4
+#endif
+#if !defined(SIZEOF_LONG)
+    #define SIZEOF_LONG 8
+#endif
+#if !defined(SIZEOF_PID_T)
+    #define SIZEOF_PID_T PSUTIL_SIZEOF_PID_T  // set as a macro in setup.py
+#endif
+
+// _Py_PARSE_PID was added in Python 3, but since it's private we make
+// sure it's always present.
+#ifndef _Py_PARSE_PID
+    #if SIZEOF_PID_T == SIZEOF_INT
+        #define _Py_PARSE_PID "i"
+    #elif SIZEOF_PID_T == SIZEOF_LONG
+        #define _Py_PARSE_PID "l"
+    #elif defined(SIZEOF_LONG_LONG) && SIZEOF_PID_T == SIZEOF_LONG_LONG
+        #define _Py_PARSE_PID "L"
+    #else
+        #error "_Py_PARSE_PID: sizeof(pid_t) is not int, long or long long"
+    #endif
+#endif
+
+// PyPy on Windows
+#ifndef PyLong_FromPid
+    #if ((SIZEOF_PID_T == SIZEOF_INT) || (SIZEOF_PID_T == SIZEOF_LONG))
+        #define PyLong_FromPid PyLong_FromLong
+    #elif defined(SIZEOF_LONG_LONG) && SIZEOF_PID_T == SIZEOF_LONG_LONG
+        #define PyLong_FromPid PyLong_FromLongLong
+    #else
+        #error "PyLong_FromPid: sizeof(pid_t) is not int, long or long long"
+    #endif
+#endif
+// clang-format on
+
+// ====================================================================
+// --- Internal utils
+// ====================================================================
+
+void _psutil_debug_impl(const char *file, int line, const char *fmt, ...);
+// The check avoids evaluating the args when debug mode is off.
+#define psutil_debug(...)                                        \
+    do {                                                         \
+        if (PSUTIL_DEBUG)                                        \
+            _psutil_debug_impl(__FILE__, __LINE__, __VA_ARGS__); \
+    } while (0)
+
+void _psutil_warn_impl(const char *file, int line, const char *fmt, ...);
+#define psutil_warn(...) _psutil_warn_impl(__FILE__, __LINE__, __VA_ARGS__)
+
+PyObject *psutil_oserror(void);
+PyObject *psutil_oserror_ad(const char *msg);
+PyObject *psutil_oserror_nsp(const char *msg);
+PyObject *psutil_oserror_wsyscall(const char *syscall);
+PyObject *psutil_runtime_error(const char *msg, ...);
+
+int str_append(char *dst, size_t dst_size, const char *src);
+int str_copy(char *dst, size_t dst_size, const char *src);
+int str_format(char *buf, size_t size, const char *fmt, ...);
+
+// The (af_filter, type_filter) args that the Python layer passes to
+// net_connections().
+typedef struct {
+    int v4;
+    int v6;
+    int unix_;  // can't be "unix": gcc predefines it as a macro
+    int tcp;
+    int udp;
+} psutil_conn_filters;
+
+int psutil_parse_conn_filters(
+    PyObject *py_af_filter, PyObject *py_type_filter, psutil_conn_filters *out
+);
+int pydict_add(PyObject *dict, const char *key, const char *fmt, ...);
+int pylist_append_fmt(PyObject *list, const char *fmt, ...);
+int pylist_append_obj(PyObject *list, PyObject *obj);
+
+int psutil_badargs(const char *funcname);
+int psutil_setup(void);
+int psutil_add_exceptions(PyObject *mod);
+PyObject *psutil_mod_init(
+    const char *name, PyMethodDef *methods, int (*exec)(PyObject *)
+);
+double psutil_usage_percent(double used, double total, int round_);
+
+// ====================================================================
+// --- Exposed to Python
+// ====================================================================
+
+#if defined(PSUTIL_WINDOWS) || defined(PSUTIL_BSD) || defined(PSUTIL_OSX)
+PyObject *psutil_pids(PyObject *self, PyObject *args);
+#endif
+PyObject *psutil_set_debug(PyObject *self, PyObject *args);
+PyObject *psutil_check_pid_range(PyObject *self, PyObject *args);
diff --git a/psutil/arch/all/pids.c b/psutil/arch/all/pids.c
new file mode 100644
index 0000000000..4248e9df92
--- /dev/null
+++ b/psutil/arch/all/pids.c
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+
+#include "init.h"
+
+
+// Raise OverflowError if Python int value overflowed when converting
+// to pid_t. Raise ValueError if Python int value is negative.
+// Otherwise, return None.
+PyObject *
+psutil_check_pid_range(PyObject *self, PyObject *args) {
+#ifdef PSUTIL_WINDOWS
+    // Not DWORD: it's unsigned, which would make the < 0 check below
+    // always false. _Py_PARSE_PID is "i" on Windows anyway.
+    int pid;
+#else
+    pid_t pid;
+#endif
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if (pid < 0) {
+        PyErr_SetString(PyExc_ValueError, "pid must be a positive integer");
+        return NULL;
+    }
+    Py_RETURN_NONE;
+}
+
+
+#if defined(PSUTIL_WINDOWS) || defined(PSUTIL_BSD) || defined(PSUTIL_OSX)
+PyObject *
+psutil_pids(PyObject *self, PyObject *args) {
+#ifdef PSUTIL_WINDOWS
+    DWORD *pids_array = NULL;
+#else
+    pid_t *pids_array = NULL;
+#endif
+    int pids_count = 0;
+    int i;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (!py_retlist)
+        return NULL;
+
+    if (_psutil_pids(&pids_array, &pids_count) != 0)
+        goto error;
+
+    if (pids_count == 0) {
+        psutil_runtime_error("no PIDs found");
+        goto error;
+    }
+
+    for (i = 0; i < pids_count; i++) {
+        if (!pylist_append_obj(py_retlist, PyLong_FromPid(pids_array[i])))
+            goto error;
+    }
+
+    free(pids_array);
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    free(pids_array);
+    return NULL;
+}
+#endif
diff --git a/psutil/arch/all/str.c b/psutil/arch/all/str.c
new file mode 100644
index 0000000000..07f94af742
--- /dev/null
+++ b/psutil/arch/all/str.c
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// String utilities.
+
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "init.h"
+
+
+static int
+str_error(const char *fmt, ...) {
+    char msg[256];
+    va_list args;
+    int ret;
+
+    va_start(args, fmt);
+    ret = vsnprintf(msg, sizeof(msg), fmt, args);
+    va_end(args);
+    // If vsnprintf() failed msg is garbage.
+    if (ret < 0)
+        str_copy(msg, sizeof(msg), "str_error: bad format");
+
+    // Warn because we never check str_*() return value.
+    psutil_warn("%s", msg);
+    return -1;
+}
+
+
+// Safely formats a string into a buffer. Writes a printf-style
+// formatted string into `buf` of size `size`, always null-terminating
+// if size > 0. Returns the number of characters written (excluding the
+// null terminator) on success, or -1 if the buffer is too small or an
+// error occurs.
+int
+str_format(char *buf, size_t size, const char *fmt, ...) {
+    va_list args;
+    int ret;
+
+    if (!buf || !fmt || size == 0)
+        return str_error("str_format: invalid arg");
+
+    va_start(args, fmt);
+#if defined(PSUTIL_WINDOWS)
+    ret = _vsnprintf_s(buf, size, _TRUNCATE, fmt, args);
+#else
+    ret = vsnprintf(buf, size, fmt, args);
+#endif
+    va_end(args);
+
+    if (ret < 0 || (size_t)ret >= size) {
+        buf[size - 1] = '\0';
+        return str_error("str_format: failed or truncated, fmt '%s'", fmt);
+    }
+    return ret;
+}
+
+
+// Safely copy `src` to `dst`, always null-terminating. Replaces unsafe
+// strcpy/strncpy. Returns 0 on success, -1 on truncation, in which
+// case dst holds as much of src as fits.
+// memmove() and not memcpy(): memcpy links memcpy@GLIBC_2.14 on
+// x86_64 Linux, raising the min glibc our Linux wheels require.
+int
+str_copy(char *dst, size_t dst_size, const char *src) {
+    size_t src_len;
+
+    if (!dst || !src || dst_size == 0)
+        return str_error("str_copy: invalid arg");
+
+    src_len = strlen(src);
+    if (src_len >= dst_size) {
+        memmove(dst, src, dst_size - 1);
+        dst[dst_size - 1] = '\0';
+        return str_error("str_copy: truncated");
+    }
+    memmove(dst, src, src_len + 1);
+    return 0;
+}
+
+
+// Safely append `src` to `dst`, always null-terminating. Returns 0 on
+// success, -1 on truncation, in which case dst holds as much of src
+// as fits.
+int
+str_append(char *dst, size_t dst_size, const char *src) {
+    size_t dst_len, src_len, avail;
+
+    if (!dst || !src || dst_size == 0)
+        return str_error("str_append: invalid arg");
+
+    dst_len = strnlen(dst, dst_size);
+    if (dst_len >= dst_size)
+        return str_error("str_append: dst is not null-terminated");
+
+    src_len = strlen(src);
+    avail = dst_size - dst_len - 1;
+    if (src_len > avail) {
+        memmove(dst + dst_len, src, avail);
+        dst[dst_size - 1] = '\0';
+        return str_error("str_append: truncated");
+    }
+    memmove(dst + dst_len, src, src_len + 1);
+    return 0;
+}
diff --git a/psutil/arch/all/utils.c b/psutil/arch/all/utils.c
new file mode 100644
index 0000000000..e18f89a656
--- /dev/null
+++ b/psutil/arch/all/utils.c
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Fixes clash between winsock2.h and windows.h
+#if defined(PSUTIL_WINDOWS)
+#define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <Python.h>
+#include <stdarg.h>
+#include <math.h>
+#if defined(PSUTIL_WINDOWS)
+#include <winsock2.h>
+#else
+#include <sys/socket.h>
+#endif
+
+#include "init.h"
+
+
+// Build a Python object from a format string, append it to a list,
+// then decref it. Eliminates the need for a temporary variable, a NULL
+// check, and a Py_DECREF / Py_XDECREF at the error label. Returns 1 on
+// success, 0 on failure with a Python exception set.
+int
+pylist_append_fmt(PyObject *list, const char *fmt, ...) {
+    int ret = 0;  // 0 = failure
+    PyObject *obj = NULL;
+    va_list ap;
+
+    va_start(ap, fmt);
+    obj = Py_VaBuildValue(fmt, ap);
+    va_end(ap);
+
+    if (!obj)
+        return 0;
+    if (PyList_Append(list, obj) < 0)
+        goto done;
+    ret = 1;  // success
+
+done:
+    Py_DECREF(obj);
+    return ret;
+}
+
+
+// Append a pre-built Python object to a list, then decref it. Same as
+// pylist_append_fmt() but takes an already-built object instead of a
+// format string. Returns 1 on success, 0 on failure with a Python
+// exception set.
+int
+pylist_append_obj(PyObject *list, PyObject *obj) {
+    if (!obj)
+        return 0;
+    if (PyList_Append(list, obj) < 0) {
+        Py_DECREF(obj);
+        return 0;
+    }
+    Py_DECREF(obj);
+    return 1;
+}
+
+
+// Build a Python object from a format string, set it as a key in a
+// dict, then decref it. Same idea as pylist_append_fmt() but for
+// dicts. Returns 1 on success, 0 on failure with a Python exception
+// set.
+int
+pydict_add(PyObject *dict, const char *key, const char *fmt, ...) {
+    int ret = 0;  // 0 = failure
+    PyObject *obj = NULL;
+    va_list ap;
+
+    va_start(ap, fmt);
+    obj = Py_VaBuildValue(fmt, ap);
+    va_end(ap);
+
+    if (!obj)
+        return 0;
+    if (PyDict_SetItemString(dict, key, obj) < 0)
+        goto done;
+    ret = 1;  // success
+
+done:
+    Py_DECREF(obj);
+    return ret;
+}
+
+
+// Return 1 if `value` is in `py_seq`, 0 if it's not, -1 on error with
+// a Python exception set.
+static int
+int_in_seq(int value, PyObject *py_seq) {
+    int inseq;
+    PyObject *py_value;
+
+    py_value = PyLong_FromLong((long)value);
+    if (py_value == NULL)
+        return -1;
+    inseq = PySequence_Contains(py_seq, py_value);  // return -1 on failure
+    Py_DECREF(py_value);
+    return inseq;
+}
+
+
+// Parse the (af_filter, type_filter) args that the Python layer passes
+// to net_connections(). Return 0 on success, -1 on error with a Python
+// exception set.
+int
+psutil_parse_conn_filters(
+    PyObject *py_af_filter, PyObject *py_type_filter, psutil_conn_filters *out
+) {
+    if (!PySequence_Check(py_af_filter) || !PySequence_Check(py_type_filter)) {
+        PyErr_SetString(PyExc_TypeError, "arg 2 or 3 is not a sequence");
+        return -1;
+    }
+    if ((out->v4 = int_in_seq(AF_INET, py_af_filter)) == -1)
+        return -1;
+    if ((out->v6 = int_in_seq(AF_INET6, py_af_filter)) == -1)
+        return -1;
+    if ((out->unix_ = int_in_seq(AF_UNIX, py_af_filter)) == -1)
+        return -1;
+    if ((out->tcp = int_in_seq(SOCK_STREAM, py_type_filter)) == -1)
+        return -1;
+    if ((out->udp = int_in_seq(SOCK_DGRAM, py_type_filter)) == -1)
+        return -1;
+    return 0;
+}
+
+
+double
+psutil_usage_percent(double used, double total, int round_) {
+    double ret;
+
+    if (total == 0.0)
+        return 0.0;
+    ret = (used / total) * 100.0;
+    if (round_ >= 0)
+        ret = round(ret * pow(10, round_)) / pow(10, round_);
+    return ret;
+}
diff --git a/psutil/arch/bsd/cpu.c b/psutil/arch/bsd/cpu.c
new file mode 100644
index 0000000000..7925c709c1
--- /dev/null
+++ b/psutil/arch/bsd/cpu.c
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysctl.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <sys/sched.h>  // CP_* on OpenBSD
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_cpu_count_logical(PyObject *self, PyObject *args) {
+    int mib[2];
+    int ncpu;
+    size_t len;
+
+    mib[0] = CTL_HW;
+    mib[1] = HW_NCPU;
+    len = sizeof(ncpu);
+
+    if (sysctl(mib, 2, &ncpu, &len, NULL, 0) == -1)
+        Py_RETURN_NONE;  // mimic os.cpu_count()
+    else
+        return Py_BuildValue("i", ncpu);
+}
+
+
+#if defined(PSUTIL_FREEBSD) || defined(PSUTIL_NETBSD)
+PyObject *
+psutil_cpu_times(PyObject *self, PyObject *args) {
+#ifdef PSUTIL_NETBSD
+    u_int64_t cpu_time[CPUSTATES];
+#else
+    long cpu_time[CPUSTATES];
+#endif
+
+    if (psutil_sysctlbyname("kern.cp_time", &cpu_time, sizeof(cpu_time)) != 0)
+        return NULL;
+    return Py_BuildValue(
+        "(ddddd)",
+        (double)cpu_time[CP_USER] / CLOCKS_PER_SEC,
+        (double)cpu_time[CP_NICE] / CLOCKS_PER_SEC,
+        (double)cpu_time[CP_SYS] / CLOCKS_PER_SEC,
+        (double)cpu_time[CP_IDLE] / CLOCKS_PER_SEC,
+        (double)cpu_time[CP_INTR] / CLOCKS_PER_SEC
+    );
+}
+#endif
diff --git a/psutil/arch/bsd/disk.c b/psutil/arch/bsd/disk.c
new file mode 100644
index 0000000000..1d7efc9d6b
--- /dev/null
+++ b/psutil/arch/bsd/disk.c
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#if PSUTIL_NETBSD  // getvfsstat()
+#include <sys/types.h>
+#include <sys/statvfs.h>
+#else  // getfsstat()
+#include <sys/param.h>
+#include <sys/ucred.h>
+#include <sys/mount.h>
+#endif
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_disk_partitions(PyObject *self, PyObject *args) {
+    int num;
+    int i;
+    long len;
+    uint64_t flags;
+    char opts[200];
+#ifdef PSUTIL_NETBSD
+    struct statvfs *fs = NULL;
+#else
+    struct statfs *fs = NULL;
+#endif
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_dev = NULL;
+    PyObject *py_mountp = NULL;
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    // get the number of mount points
+    Py_BEGIN_ALLOW_THREADS
+#ifdef PSUTIL_NETBSD
+    num = getvfsstat(NULL, 0, MNT_NOWAIT);
+#else
+    num = getfsstat(NULL, 0, MNT_NOWAIT);
+#endif
+    Py_END_ALLOW_THREADS
+    if (num == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    len = sizeof(*fs) * num;
+    fs = malloc(len);
+    if (fs == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+#ifdef PSUTIL_NETBSD
+    num = getvfsstat(fs, len, MNT_NOWAIT);
+#else
+    num = getfsstat(fs, len, MNT_NOWAIT);
+#endif
+    Py_END_ALLOW_THREADS
+    if (num == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (i = 0; i < num; i++) {
+        opts[0] = 0;
+#ifdef PSUTIL_NETBSD
+        flags = fs[i].f_flag;
+#else
+        flags = fs[i].f_flags;
+#endif
+
+        // see sys/mount.h
+        if (flags & MNT_RDONLY)
+            str_append(opts, sizeof(opts), "ro");
+        else
+            str_append(opts, sizeof(opts), "rw");
+        if (flags & MNT_SYNCHRONOUS)
+            str_append(opts, sizeof(opts), ",sync");
+        if (flags & MNT_NOEXEC)
+            str_append(opts, sizeof(opts), ",noexec");
+        if (flags & MNT_NOSUID)
+            str_append(opts, sizeof(opts), ",nosuid");
+        if (flags & MNT_ASYNC)
+            str_append(opts, sizeof(opts), ",async");
+        if (flags & MNT_NOATIME)
+            str_append(opts, sizeof(opts), ",noatime");
+        if (flags & MNT_SOFTDEP)
+            str_append(opts, sizeof(opts), ",softdep");
+#ifdef PSUTIL_FREEBSD
+        if (flags & MNT_UNION)
+            str_append(opts, sizeof(opts), ",union");
+        if (flags & MNT_SUIDDIR)
+            str_append(opts, sizeof(opts), ",suiddir");
+        if (flags & MNT_NOSYMFOLLOW)
+            str_append(opts, sizeof(opts), ",nosymfollow");
+#ifdef MNT_GJOURNAL
+        if (flags & MNT_GJOURNAL)
+            str_append(opts, sizeof(opts), ",gjournal");
+#endif
+        if (flags & MNT_MULTILABEL)
+            str_append(opts, sizeof(opts), ",multilabel");
+        if (flags & MNT_ACLS)
+            str_append(opts, sizeof(opts), ",acls");
+        if (flags & MNT_NOCLUSTERR)
+            str_append(opts, sizeof(opts), ",noclusterr");
+        if (flags & MNT_NOCLUSTERW)
+            str_append(opts, sizeof(opts), ",noclusterw");
+#ifdef MNT_NFS4ACLS
+        if (flags & MNT_NFS4ACLS)
+            str_append(opts, sizeof(opts), ",nfs4acls");
+#endif
+#elif PSUTIL_NETBSD
+        if (flags & MNT_NODEV)
+            str_append(opts, sizeof(opts), ",nodev");
+        if (flags & MNT_UNION)
+            str_append(opts, sizeof(opts), ",union");
+        if (flags & MNT_NOCOREDUMP)
+            str_append(opts, sizeof(opts), ",nocoredump");
+#ifdef MNT_RELATIME
+        if (flags & MNT_RELATIME)
+            str_append(opts, sizeof(opts), ",relatime");
+#endif
+        if (flags & MNT_IGNORE)
+            str_append(opts, sizeof(opts), ",ignore");
+#ifdef MNT_DISCARD
+        if (flags & MNT_DISCARD)
+            str_append(opts, sizeof(opts), ",discard");
+#endif
+#ifdef MNT_EXTATTR
+        if (flags & MNT_EXTATTR)
+            str_append(opts, sizeof(opts), ",extattr");
+#endif
+        if (flags & MNT_LOG)
+            str_append(opts, sizeof(opts), ",log");
+        if (flags & MNT_SYMPERM)
+            str_append(opts, sizeof(opts), ",symperm");
+        if (flags & MNT_NODEVMTIME)
+            str_append(opts, sizeof(opts), ",nodevmtime");
+#endif
+        py_dev = PyUnicode_DecodeFSDefault(fs[i].f_mntfromname);
+        if (!py_dev)
+            goto error;
+        py_mountp = PyUnicode_DecodeFSDefault(fs[i].f_mntonname);
+        if (!py_mountp)
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(OOss)",
+                py_dev,  // device
+                py_mountp,  // mount point
+                fs[i].f_fstypename,  // fs type
+                opts  // options
+            ))
+        {
+            goto error;
+        }
+        Py_CLEAR(py_dev);
+        Py_CLEAR(py_mountp);
+    }
+
+    free(fs);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_dev);
+    Py_XDECREF(py_mountp);
+    Py_DECREF(py_retlist);
+    if (fs != NULL)
+        free(fs);
+    return NULL;
+}
diff --git a/psutil/arch/bsd/freebsd.c b/psutil/arch/bsd/freebsd.c
deleted file mode 100644
index d335a7adee..0000000000
--- a/psutil/arch/bsd/freebsd.c
+++ /dev/null
@@ -1,1029 +0,0 @@
-/*
- * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Helper functions related to fetching process information.
- * Used by _psutil_bsd module methods.
- */
-
-#include <Python.h>
-#include <assert.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/sysctl.h>
-#include <sys/param.h>
-#include <sys/user.h>
-#include <sys/proc.h>
-#include <signal.h>
-#include <fcntl.h>
-#include <sys/vmmeter.h>  // needed for vmtotal struct
-#include <devstat.h>  // for swap mem
-#include <libutil.h>  // process open files, shared libs (kinfo_getvmmap), cwd
-#include <sys/cpuset.h>
-
-#include "freebsd.h"
-#include "../../_psutil_common.h"
-
-
-#define PSUTIL_TV2DOUBLE(t)    ((t).tv_sec + (t).tv_usec / 1000000.0)
-#define PSUTIL_BT2MSEC(bt) (bt.sec * 1000 + (((uint64_t) 1000000000 * (uint32_t) \
-        (bt.frac >> 32) ) >> 32 ) / 1000000)
-#ifndef _PATH_DEVNULL
-#define _PATH_DEVNULL "/dev/null"
-#endif
-
-
-// ============================================================================
-// Utility functions
-// ============================================================================
-
-
-int
-psutil_kinfo_proc(const pid_t pid, struct kinfo_proc *proc) {
-    // Fills a kinfo_proc struct based on process pid.
-    int mib[4];
-    size_t size;
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC;
-    mib[2] = KERN_PROC_PID;
-    mib[3] = pid;
-
-    size = sizeof(struct kinfo_proc);
-    if (sysctl((int *)mib, 4, proc, &size, NULL, 0) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return -1;
-    }
-
-    // sysctl stores 0 in the size if we can't find the process information.
-    if (size == 0) {
-        NoSuchProcess();
-        return -1;
-    }
-    return 0;
-}
-
-
-int
-psutil_raise_ad_or_nsp(long pid) {
-    // Set exception to AccessDenied if pid exists else NoSuchProcess.
-    int ret;
-    ret = psutil_pid_exists(pid);
-    if (ret == 0)
-        NoSuchProcess();
-    else if (ret == 1)
-        AccessDenied();
-    return ret;
-}
-
-
-// remove spaces from string
-static void psutil_remove_spaces(char *str) {
-    char *p1 = str;
-    char *p2 = str;
-    do
-        while (*p2 == ' ')
-            p2++;
-    while ((*p1++ = *p2++));
-}
-
-
-// ============================================================================
-// APIS
-// ============================================================================
-
-int
-psutil_get_proc_list(struct kinfo_proc **procList, size_t *procCount) {
-    // Returns a list of all BSD processes on the system.  This routine
-    // allocates the list and puts it in *procList and a count of the
-    // number of entries in *procCount.  You are responsible for freeing
-    // this list (use "free" from System framework).
-    // On success, the function returns 0.
-    // On error, the function returns a BSD errno value.
-    int err;
-    struct kinfo_proc *result;
-    int done;
-    static const int name[] = { CTL_KERN, KERN_PROC, KERN_PROC_PROC, 0 };
-    // Declaring name as const requires us to cast it when passing it to
-    // sysctl because the prototype doesn't include the const modifier.
-    size_t              length;
-
-    assert( procList != NULL);
-    assert(*procList == NULL);
-    assert(procCount != NULL);
-
-    *procCount = 0;
-
-    /*
-     * We start by calling sysctl with result == NULL and length == 0.
-     * That will succeed, and set length to the appropriate length.
-     * We then allocate a buffer of that size and call sysctl again
-     * with that buffer.  If that succeeds, we're done.  If that fails
-     * with ENOMEM, we have to throw away our buffer and loop.  Note
-     * that the loop causes use to call sysctl with NULL again; this
-     * is necessary because the ENOMEM failure case sets length to
-     * the amount of data returned, not the amount of data that
-     * could have been returned.
-     */
-    result = NULL;
-    done = 0;
-    do {
-        assert(result == NULL);
-        // Call sysctl with a NULL buffer.
-        length = 0;
-        err = sysctl((int *)name, (sizeof(name) / sizeof(*name)) - 1,
-                     NULL, &length, NULL, 0);
-        if (err == -1)
-            err = errno;
-
-        // Allocate an appropriately sized buffer based on the results
-        // from the previous call.
-        if (err == 0) {
-            result = malloc(length);
-            if (result == NULL)
-                err = ENOMEM;
-        }
-
-        // Call sysctl again with the new buffer.  If we get an ENOMEM
-        // error, toss away our buffer and start again.
-        if (err == 0) {
-            err = sysctl((int *) name, (sizeof(name) / sizeof(*name)) - 1,
-                         result, &length, NULL, 0);
-            if (err == -1)
-                err = errno;
-            if (err == 0) {
-                done = 1;
-            }
-            else if (err == ENOMEM) {
-                assert(result != NULL);
-                free(result);
-                result = NULL;
-                err = 0;
-            }
-        }
-    } while (err == 0 && ! done);
-
-    // Clean up and establish post conditions.
-    if (err != 0 && result != NULL) {
-        free(result);
-        result = NULL;
-    }
-
-    *procList = result;
-    *procCount = length / sizeof(struct kinfo_proc);
-
-    assert((err == 0) == (*procList != NULL));
-    return err;
-}
-
-
-/*
- * XXX no longer used; it probably makese sense to remove it.
- * Borrowed from psi Python System Information project
- *
- * Get command arguments and environment variables.
- *
- * Based on code from ps.
- *
- * Returns:
- *      0 for success;
- *      -1 for failure (Exception raised);
- *      1 for insufficient privileges.
- */
-static char
-*psutil_get_cmd_args(long pid, size_t *argsize) {
-    int mib[4], argmax;
-    size_t size = sizeof(argmax);
-    char *procargs = NULL;
-
-    // Get the maximum process arguments size.
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_ARGMAX;
-
-    size = sizeof(argmax);
-    if (sysctl(mib, 2, &argmax, &size, NULL, 0) == -1)
-        return NULL;
-
-    // Allocate space for the arguments.
-    procargs = (char *)malloc(argmax);
-    if (procargs == NULL) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-
-    /*
-     * Make a sysctl() call to get the raw argument space of the process.
-     */
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC;
-    mib[2] = KERN_PROC_ARGS;
-    mib[3] = pid;
-
-    size = argmax;
-    if (sysctl(mib, 4, procargs, &size, NULL, 0) == -1) {
-        free(procargs);
-        return NULL;       // Insufficient privileges
-    }
-
-    // return string and set the length of arguments
-    *argsize = size;
-    return procargs;
-}
-
-
-// returns the command line as a python list object
-PyObject *
-psutil_get_cmdline(long pid) {
-    char *argstr = NULL;
-    int pos = 0;
-    size_t argsize = 0;
-    PyObject *py_retlist = Py_BuildValue("[]");
-    PyObject *py_arg = NULL;
-
-    if (pid < 0)
-        return py_retlist;
-    argstr = psutil_get_cmd_args(pid, &argsize);
-    if (argstr == NULL)
-        goto error;
-
-    // args are returned as a flattened string with \0 separators between
-    // arguments add each string to the list then step forward to the next
-    // separator
-    if (argsize > 0) {
-        while (pos < argsize) {
-#if PY_MAJOR_VERSION >= 3
-            py_arg = PyUnicode_DecodeFSDefault(&argstr[pos]);
-#else
-            py_arg = Py_BuildValue("s", &argstr[pos]);
-#endif
-            if (!py_arg)
-                goto error;
-            if (PyList_Append(py_retlist, py_arg))
-                goto error;
-            Py_DECREF(py_arg);
-            pos = pos + strlen(&argstr[pos]) + 1;
-        }
-    }
-
-    free(argstr);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_arg);
-    Py_DECREF(py_retlist);
-    if (argstr != NULL)
-        free(argstr);
-    return NULL;
-}
-
-
-/*
- * Return 1 if PID exists in the current process list, else 0, -1
- * on error.
- * TODO: this should live in _psutil_posix.c but for some reason if I
- * move it there I get a "include undefined symbol" error.
- */
-int
-psutil_pid_exists(long pid) {
-    int ret;
-    if (pid < 0)
-        return 0;
-    ret = kill(pid , 0);
-    if (ret == 0)
-        return 1;
-    else {
-        if (ret == ESRCH)
-            return 0;
-        else if (ret == EPERM)
-            return 1;
-        else {
-            PyErr_SetFromErrno(PyExc_OSError);
-            return -1;
-        }
-    }
-}
-
-
-
-/*
- * Return process pathname executable.
- * Thanks to Robert N. M. Watson:
- * http://fxr.googlebit.com/source/usr.bin/procstat/procstat_bin.c?v=8-CURRENT
- */
-PyObject *
-psutil_proc_exe(PyObject *self, PyObject *args) {
-    long pid;
-    char pathname[PATH_MAX];
-    int error;
-    int mib[4];
-    int ret;
-    size_t size;
-    const char *encoding_errs;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC;
-    mib[2] = KERN_PROC_PATHNAME;
-    mib[3] = pid;
-
-    size = sizeof(pathname);
-    error = sysctl(mib, 4, pathname, &size, NULL, 0);
-    if (error == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-    if (size == 0 || strlen(pathname) == 0) {
-        ret = psutil_pid_exists(pid);
-        if (ret == -1)
-            return NULL;
-        else if (ret == 0)
-            return NoSuchProcess();
-        else
-            strcpy(pathname, "");
-    }
-
-#if PY_MAJOR_VERSION >= 3
-    return PyUnicode_DecodeFSDefault(pathname);
-#else
-    return Py_BuildValue("s", pathname);
-#endif
-
-}
-
-
-PyObject *
-psutil_proc_num_threads(PyObject *self, PyObject *args) {
-    // Return number of threads used by process as a Python integer.
-    long pid;
-    struct kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("l", (long)kp.ki_numthreads);
-}
-
-
-PyObject *
-psutil_proc_threads(PyObject *self, PyObject *args) {
-    // Retrieves all threads used by process returning a list of tuples
-    // including thread id, user time and system time.
-    // Thanks to Robert N. M. Watson:
-    // http://fxr.googlebit.com/source/usr.bin/procstat/
-    //     procstat_threads.c?v=8-CURRENT
-    long pid;
-    int mib[4];
-    struct kinfo_proc *kip = NULL;
-    struct kinfo_proc *kipp = NULL;
-    int error;
-    unsigned int i;
-    size_t size;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-
-    // we need to re-query for thread information, so don't use *kipp
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC;
-    mib[2] = KERN_PROC_PID | KERN_PROC_INC_THREAD;
-    mib[3] = pid;
-
-    size = 0;
-    error = sysctl(mib, 4, NULL, &size, NULL, 0);
-    if (error == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-    if (size == 0) {
-        NoSuchProcess();
-        goto error;
-    }
-
-    kip = malloc(size);
-    if (kip == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    error = sysctl(mib, 4, kip, &size, NULL, 0);
-    if (error == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-    if (size == 0) {
-        NoSuchProcess();
-        goto error;
-    }
-
-    for (i = 0; i < size / sizeof(*kipp); i++) {
-        kipp = &kip[i];
-        py_tuple = Py_BuildValue("Idd",
-                                 kipp->ki_tid,
-                                 PSUTIL_TV2DOUBLE(kipp->ki_rusage.ru_utime),
-                                 PSUTIL_TV2DOUBLE(kipp->ki_rusage.ru_stime));
-        if (py_tuple == NULL)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-    free(kip);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (kip != NULL)
-        free(kip);
-    return NULL;
-}
-
-
-PyObject *
-psutil_cpu_count_phys(PyObject *self, PyObject *args) {
-    // Return an XML string from which we'll determine the number of
-    // physical CPU cores in the system.
-    void *topology = NULL;
-    size_t size = 0;
-    PyObject *py_str;
-
-    if (sysctlbyname("kern.sched.topology_spec", NULL, &size, NULL, 0))
-        goto error;
-
-    topology = malloc(size);
-    if (!topology) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-
-    if (sysctlbyname("kern.sched.topology_spec", topology, &size, NULL, 0))
-        goto error;
-
-    py_str = Py_BuildValue("s", topology);
-    free(topology);
-    return py_str;
-
-error:
-    if (topology != NULL)
-        free(topology);
-    Py_RETURN_NONE;
-}
-
-
-/*
- * Return virtual memory usage statistics.
- */
-PyObject *
-psutil_virtual_mem(PyObject *self, PyObject *args) {
-    unsigned long  total;
-    unsigned int   active, inactive, wired, cached, free;
-    size_t         size = sizeof(total);
-    struct vmtotal vm;
-    int            mib[] = {CTL_VM, VM_METER};
-    long           pagesize = getpagesize();
-#if __FreeBSD_version > 702101
-    long buffers;
-#else
-    int buffers;
-#endif
-    size_t buffers_size = sizeof(buffers);
-
-    if (sysctlbyname("hw.physmem", &total, &size, NULL, 0))
-        goto error;
-    if (sysctlbyname("vm.stats.vm.v_active_count", &active, &size, NULL, 0))
-        goto error;
-    if (sysctlbyname("vm.stats.vm.v_inactive_count",
-                     &inactive, &size, NULL, 0))
-        goto error;
-    if (sysctlbyname("vm.stats.vm.v_wire_count", &wired, &size, NULL, 0))
-        goto error;
-    if (sysctlbyname("vm.stats.vm.v_cache_count", &cached, &size, NULL, 0))
-        goto error;
-    if (sysctlbyname("vm.stats.vm.v_free_count", &free, &size, NULL, 0))
-        goto error;
-    if (sysctlbyname("vfs.bufspace", &buffers, &buffers_size, NULL, 0))
-        goto error;
-
-    size = sizeof(vm);
-    if (sysctl(mib, 2, &vm, &size, NULL, 0) != 0)
-        goto error;
-
-    return Py_BuildValue("KKKKKKKK",
-        (unsigned long long) total,
-        (unsigned long long) free     * pagesize,
-        (unsigned long long) active   * pagesize,
-        (unsigned long long) inactive * pagesize,
-        (unsigned long long) wired    * pagesize,
-        (unsigned long long) cached   * pagesize,
-        (unsigned long long) buffers,
-        (unsigned long long) (vm.t_vmshr + vm.t_rmshr) * pagesize  // shared
-    );
-
-error:
-    PyErr_SetFromErrno(PyExc_OSError);
-    return NULL;
-}
-
-
-PyObject *
-psutil_swap_mem(PyObject *self, PyObject *args) {
-    // Return swap memory stats (see 'swapinfo' cmdline tool)
-    kvm_t *kd;
-    struct kvm_swap kvmsw[1];
-    unsigned int swapin, swapout, nodein, nodeout;
-    size_t size = sizeof(unsigned int);
-
-    kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open failed");
-    if (kd == NULL) {
-        PyErr_SetString(PyExc_RuntimeError, "kvm_open failed");
-        return NULL;
-    }
-
-    if (kvm_getswapinfo(kd, kvmsw, 1, 0) < 0) {
-        kvm_close(kd);
-        PyErr_SetString(PyExc_RuntimeError, "kvm_getswapinfo failed");
-        return NULL;
-    }
-
-    kvm_close(kd);
-
-    if (sysctlbyname("vm.stats.vm.v_swapin", &swapin, &size, NULL, 0) == -1)
-        goto sbn_error;
-    if (sysctlbyname("vm.stats.vm.v_swapout", &swapout, &size, NULL, 0) == -1)
-        goto sbn_error;
-    if (sysctlbyname("vm.stats.vm.v_vnodein", &nodein, &size, NULL, 0) == -1)
-        goto sbn_error;
-    if (sysctlbyname("vm.stats.vm.v_vnodeout", &nodeout, &size, NULL, 0) == -1)
-        goto sbn_error;
-
-    return Py_BuildValue("(iiiII)",
-                         kvmsw[0].ksw_total,                     // total
-                         kvmsw[0].ksw_used,                      // used
-                         kvmsw[0].ksw_total - kvmsw[0].ksw_used, // free
-                         swapin + swapout,                       // swap in
-                         nodein + nodeout);                      // swap out
-
-sbn_error:
-    PyErr_SetFromErrno(PyExc_OSError);
-    return NULL;
-}
-
-
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 800000
-PyObject *
-psutil_proc_cwd(PyObject *self, PyObject *args) {
-    long pid;
-    struct kinfo_file *freep = NULL;
-    struct kinfo_file *kif;
-    struct kinfo_proc kipp;
-    const char *encoding_errs;
-    PyObject *py_path = NULL;
-
-    int i, cnt;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-    if (psutil_kinfo_proc(pid, &kipp) == -1)
-        goto error;
-
-    freep = kinfo_getfile(pid, &cnt);
-    if (freep == NULL) {
-        psutil_raise_ad_or_nsp(pid);
-        goto error;
-    }
-
-    for (i = 0; i < cnt; i++) {
-        kif = &freep[i];
-        if (kif->kf_fd == KF_FD_TYPE_CWD) {
-#if PY_MAJOR_VERSION >= 3
-            py_path = PyUnicode_DecodeFSDefault(kif->kf_path);
-#else
-            py_path = Py_BuildValue("s", kif->kf_path);
-#endif
-            if (!py_path)
-                goto error;
-            break;
-        }
-    }
-    /*
-     * For lower pids it seems we can't retrieve any information
-     * (lsof can't do that it either).  Since this happens even
-     * as root we return an empty string instead of AccessDenied.
-     */
-    if (py_path == NULL)
-        py_path = Py_BuildValue("s", "");
-    free(freep);
-    return py_path;
-
-error:
-    Py_XDECREF(py_path);
-    if (freep != NULL)
-        free(freep);
-    return NULL;
-}
-#endif
-
-
-#if defined(__FreeBSD_version) && __FreeBSD_version >= 800000
-PyObject *
-psutil_proc_num_fds(PyObject *self, PyObject *args) {
-    long pid;
-    int cnt;
-
-    struct kinfo_file *freep;
-    struct kinfo_proc kipp;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kipp) == -1)
-        return NULL;
-
-    freep = kinfo_getfile(pid, &cnt);
-    if (freep == NULL) {
-        psutil_raise_ad_or_nsp(pid);
-        return NULL;
-    }
-    free(freep);
-
-    return Py_BuildValue("i", cnt);
-}
-#endif
-
-
-PyObject *
-psutil_per_cpu_times(PyObject *self, PyObject *args) {
-    static int maxcpus;
-    int mib[2];
-    int ncpu;
-    size_t len;
-    size_t size;
-    int i;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_cputime = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    // retrieve maxcpus value
-    size = sizeof(maxcpus);
-    if (sysctlbyname("kern.smp.maxcpus", &maxcpus, &size, NULL, 0) < 0) {
-        Py_DECREF(py_retlist);
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-    long cpu_time[maxcpus][CPUSTATES];
-
-    // retrieve the number of cpus
-    mib[0] = CTL_HW;
-    mib[1] = HW_NCPU;
-    len = sizeof(ncpu);
-    if (sysctl(mib, 2, &ncpu, &len, NULL, 0) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    // per-cpu info
-    size = sizeof(cpu_time);
-    if (sysctlbyname("kern.cp_times", &cpu_time, &size, NULL, 0) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    for (i = 0; i < ncpu; i++) {
-        py_cputime = Py_BuildValue(
-            "(ddddd)",
-            (double)cpu_time[i][CP_USER] / CLOCKS_PER_SEC,
-            (double)cpu_time[i][CP_NICE] / CLOCKS_PER_SEC,
-            (double)cpu_time[i][CP_SYS] / CLOCKS_PER_SEC,
-            (double)cpu_time[i][CP_IDLE] / CLOCKS_PER_SEC,
-            (double)cpu_time[i][CP_INTR] / CLOCKS_PER_SEC);
-        if (!py_cputime)
-            goto error;
-        if (PyList_Append(py_retlist, py_cputime))
-            goto error;
-        Py_DECREF(py_cputime);
-    }
-
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_cputime);
-    Py_DECREF(py_retlist);
-    return NULL;
-}
-
-
-PyObject *
-psutil_disk_io_counters(PyObject *self, PyObject *args) {
-    int i;
-    struct statinfo stats;
-
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_disk_info = NULL;
-
-    if (py_retdict == NULL)
-        return NULL;
-    if (devstat_checkversion(NULL) < 0) {
-        PyErr_Format(PyExc_RuntimeError, "devstat_checkversion() failed");
-        goto error;
-    }
-
-    stats.dinfo = (struct devinfo *)malloc(sizeof(struct devinfo));
-    if (stats.dinfo == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-    bzero(stats.dinfo, sizeof(struct devinfo));
-
-    if (devstat_getdevs(NULL, &stats) == -1) {
-        PyErr_Format(PyExc_RuntimeError, "devstat_getdevs() failed");
-        goto error;
-    }
-
-    for (i = 0; i < stats.dinfo->numdevs; i++) {
-        py_disk_info = NULL;
-        struct devstat current;
-        char disk_name[128];
-        current = stats.dinfo->devices[i];
-        snprintf(disk_name, sizeof(disk_name), "%s%d",
-                 current.device_name,
-                 current.unit_number);
-
-        py_disk_info = Py_BuildValue(
-            "(KKKKLLL)",
-            current.operations[DEVSTAT_READ],   // no reads
-            current.operations[DEVSTAT_WRITE],  // no writes
-            current.bytes[DEVSTAT_READ],        // bytes read
-            current.bytes[DEVSTAT_WRITE],       // bytes written
-            (long long) PSUTIL_BT2MSEC(current.duration[DEVSTAT_READ]),  // r time
-            (long long) PSUTIL_BT2MSEC(current.duration[DEVSTAT_WRITE]),  // w time
-            (long long) PSUTIL_BT2MSEC(current.busy_time)  // busy time
-        );      // finished transactions
-        if (!py_disk_info)
-            goto error;
-        if (PyDict_SetItemString(py_retdict, disk_name, py_disk_info))
-            goto error;
-        Py_DECREF(py_disk_info);
-    }
-
-    if (stats.dinfo->mem_ptr)
-        free(stats.dinfo->mem_ptr);
-    free(stats.dinfo);
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_disk_info);
-    Py_DECREF(py_retdict);
-    if (stats.dinfo != NULL)
-        free(stats.dinfo);
-    return NULL;
-}
-
-
-PyObject *
-psutil_proc_memory_maps(PyObject *self, PyObject *args) {
-    // Return a list of tuples for every process memory maps.
-    //'procstat' cmdline utility has been used as an example.
-    long pid;
-    int ptrwidth;
-    int i, cnt;
-    char addr[1000];
-    char perms[4];
-    const char *path;
-    struct kinfo_proc kp;
-    struct kinfo_vmentry *freep = NULL;
-    struct kinfo_vmentry *kve;
-    ptrwidth = 2 * sizeof(void *);
-    PyObject *py_tuple = NULL;
-    PyObject *py_retlist = PyList_New(0);
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        goto error;
-
-    freep = kinfo_getvmmap(pid, &cnt);
-    if (freep == NULL) {
-        psutil_raise_ad_or_nsp(pid);
-        goto error;
-    }
-    for (i = 0; i < cnt; i++) {
-        py_tuple = NULL;
-        kve = &freep[i];
-        addr[0] = '\0';
-        perms[0] = '\0';
-        sprintf(addr, "%#*jx-%#*jx", ptrwidth, (uintmax_t)kve->kve_start,
-                ptrwidth, (uintmax_t)kve->kve_end);
-        psutil_remove_spaces(addr);
-        strlcat(perms, kve->kve_protection & KVME_PROT_READ ? "r" : "-",
-                sizeof(perms));
-        strlcat(perms, kve->kve_protection & KVME_PROT_WRITE ? "w" : "-",
-                sizeof(perms));
-        strlcat(perms, kve->kve_protection & KVME_PROT_EXEC ? "x" : "-",
-                sizeof(perms));
-
-        if (strlen(kve->kve_path) == 0) {
-            switch (kve->kve_type) {
-                case KVME_TYPE_NONE:
-                    path = "[none]";
-                    break;
-                case KVME_TYPE_DEFAULT:
-                    path = "[default]";
-                    break;
-                case KVME_TYPE_VNODE:
-                    path = "[vnode]";
-                    break;
-                case KVME_TYPE_SWAP:
-                    path = "[swap]";
-                    break;
-                case KVME_TYPE_DEVICE:
-                    path = "[device]";
-                    break;
-                case KVME_TYPE_PHYS:
-                    path = "[phys]";
-                    break;
-                case KVME_TYPE_DEAD:
-                    path = "[dead]";
-                    break;
-                case KVME_TYPE_SG:
-                    path = "[sg]";
-                    break;
-                case KVME_TYPE_UNKNOWN:
-                    path = "[unknown]";
-                    break;
-                default:
-                    path = "[?]";
-                    break;
-            }
-        }
-        else {
-            path = kve->kve_path;
-        }
-
-        py_tuple = Py_BuildValue("sssiiii",
-            addr,                       // "start-end" address
-            perms,                      // "rwx" permissions
-            path,                       // path
-            kve->kve_resident,          // rss
-            kve->kve_private_resident,  // private
-            kve->kve_ref_count,         // ref count
-            kve->kve_shadow_count);     // shadow count
-        if (!py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-    free(freep);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (freep != NULL)
-        free(freep);
-    return NULL;
-}
-
-
-PyObject*
-psutil_proc_cpu_affinity_get(PyObject* self, PyObject* args) {
-    // Get process CPU affinity.
-    // Reference:
-    // http://sources.freebsd.org/RELENG_9/src/usr.bin/cpuset/cpuset.c
-    long pid;
-    int ret;
-    int i;
-    cpuset_t mask;
-    PyObject* py_retlist;
-    PyObject* py_cpu_num;
-
-    if (!PyArg_ParseTuple(args, "i", &pid))
-        return NULL;
-    ret = cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, pid,
-                             sizeof(mask), &mask);
-    if (ret != 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    py_retlist = PyList_New(0);
-    if (py_retlist == NULL)
-        return NULL;
-
-    for (i = 0; i < CPU_SETSIZE; i++) {
-        if (CPU_ISSET(i, &mask)) {
-            py_cpu_num = Py_BuildValue("i", i);
-            if (py_cpu_num == NULL)
-                goto error;
-            if (PyList_Append(py_retlist, py_cpu_num))
-                goto error;
-        }
-    }
-
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_cpu_num);
-    Py_DECREF(py_retlist);
-    return NULL;
-}
-
-
-PyObject *
-psutil_proc_cpu_affinity_set(PyObject *self, PyObject *args) {
-    // Set process CPU affinity.
-    // Reference:
-    // http://sources.freebsd.org/RELENG_9/src/usr.bin/cpuset/cpuset.c
-    long pid;
-    int i;
-    int seq_len;
-    int ret;
-    cpuset_t cpu_set;
-    PyObject *py_cpu_set;
-    PyObject *py_cpu_seq = NULL;
-
-    if (!PyArg_ParseTuple(args, "lO", &pid, &py_cpu_set))
-        return NULL;
-
-    py_cpu_seq = PySequence_Fast(py_cpu_set, "expected a sequence or integer");
-    if (!py_cpu_seq)
-        return NULL;
-    seq_len = PySequence_Fast_GET_SIZE(py_cpu_seq);
-
-    // calculate the mask
-    CPU_ZERO(&cpu_set);
-    for (i = 0; i < seq_len; i++) {
-        PyObject *item = PySequence_Fast_GET_ITEM(py_cpu_seq, i);
-#if PY_MAJOR_VERSION >= 3
-        long value = PyLong_AsLong(item);
-#else
-        long value = PyInt_AsLong(item);
-#endif
-        if (value == -1 && PyErr_Occurred())
-            goto error;
-        CPU_SET(value, &cpu_set);
-    }
-
-    // set affinity
-    ret = cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, pid,
-                             sizeof(cpu_set), &cpu_set);
-    if (ret != 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    Py_DECREF(py_cpu_seq);
-    Py_RETURN_NONE;
-
-error:
-    if (py_cpu_seq != NULL)
-        Py_DECREF(py_cpu_seq);
-    return NULL;
-}
-
-
-PyObject *
-psutil_cpu_stats(PyObject *self, PyObject *args) {
-    unsigned int v_soft;
-    unsigned int v_intr;
-    unsigned int v_syscall;
-    unsigned int v_trap;
-    unsigned int v_swtch;
-    size_t size = sizeof(v_soft);
-
-    if (sysctlbyname("vm.stats.sys.v_soft", &v_soft, &size, NULL, 0))
-        goto error;
-    if (sysctlbyname("vm.stats.sys.v_intr", &v_intr, &size, NULL, 0))
-        goto error;
-    if (sysctlbyname("vm.stats.sys.v_syscall", &v_syscall, &size, NULL, 0))
-        goto error;
-    if (sysctlbyname("vm.stats.sys.v_trap", &v_trap, &size, NULL, 0))
-        goto error;
-    if (sysctlbyname("vm.stats.sys.v_swtch", &v_swtch, &size, NULL, 0))
-        goto error;
-
-    return Py_BuildValue(
-        "IIIII",
-        v_swtch,  // ctx switches
-        v_intr,  // interrupts
-        v_soft,  // software interrupts
-        v_syscall,  // syscalls
-        v_trap  // traps
-    );
-
-error:
-    PyErr_SetFromErrno(PyExc_OSError);
-    return NULL;
-}
diff --git a/psutil/arch/bsd/freebsd.h b/psutil/arch/bsd/freebsd.h
deleted file mode 100644
index a539445da4..0000000000
--- a/psutil/arch/bsd/freebsd.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include <Python.h>
-
-typedef struct kinfo_proc kinfo_proc;
-
-static char *psutil_get_cmd_args(long pid, size_t *argsize);
-int psutil_get_proc_list(struct kinfo_proc **procList, size_t *procCount);
-int psutil_kinfo_proc(const pid_t pid, struct kinfo_proc *proc);
-int psutil_pid_exists(long pid);
-
-//
-PyObject* psutil_cpu_count_phys(PyObject* self, PyObject* args);
-PyObject* psutil_disk_io_counters(PyObject* self, PyObject* args);
-PyObject* psutil_get_cmdline(long pid);
-PyObject* psutil_per_cpu_times(PyObject* self, PyObject* args);
-PyObject* psutil_proc_cpu_affinity_get(PyObject* self, PyObject* args);
-PyObject* psutil_proc_cpu_affinity_set(PyObject* self, PyObject* args);
-PyObject* psutil_proc_cwd(PyObject* self, PyObject* args);
-PyObject* psutil_proc_exe(PyObject* self, PyObject* args);
-PyObject* psutil_proc_memory_maps(PyObject* self, PyObject* args);
-PyObject* psutil_proc_num_fds(PyObject* self, PyObject* args);
-PyObject* psutil_proc_num_threads(PyObject* self, PyObject* args);
-PyObject* psutil_proc_threads(PyObject* self, PyObject* args);
-PyObject* psutil_swap_mem(PyObject* self, PyObject* args);
-PyObject* psutil_virtual_mem(PyObject* self, PyObject* args);
-PyObject* psutil_cpu_stats(PyObject* self, PyObject* args);
diff --git a/psutil/arch/bsd/freebsd_socks.c b/psutil/arch/bsd/freebsd_socks.c
deleted file mode 100644
index 8fe93db0b5..0000000000
--- a/psutil/arch/bsd/freebsd_socks.c
+++ /dev/null
@@ -1,631 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola'.
- * All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include <Python.h>
-#include <sys/user.h>
-#include <sys/file.h>
-#include <sys/socketvar.h>    // for struct xsocket
-#include <sys/un.h>
-#include <sys/unpcb.h>
-#include <sys/types.h>
-#include <sys/sysctl.h>
-#include <netinet/in.h>   // for xinpcb struct
-#include <netinet/in_systm.h>
-#include <netinet/ip.h>
-#include <netinet/in_pcb.h>
-#include <netinet/tcp.h>
-#include <netinet/tcp_timer.h>
-#include <netinet/tcp_var.h>   // for struct xtcpcb
-#include <netinet/tcp_fsm.h>   // for TCP connection states
-#include <arpa/inet.h>         // for inet_ntop()
-#include <net/if_media.h>
-#include <libutil.h>
-
-#include "freebsd.h"
-#include "freebsd_socks.h"
-
-
-#define HASHSIZE 1009
-// a signaler for connections without an actual status
-static int PSUTIL_CONN_NONE = 128;
-static struct xfile *psutil_xfiles;
-static int psutil_nxfiles;
-
-
-// The tcplist fetching and walking is borrowed from netstat/inet.c.
-static char *
-psutil_fetch_tcplist(void) {
-    char *buf;
-    size_t len;
-
-    for (;;) {
-        if (sysctlbyname("net.inet.tcp.pcblist", NULL, &len, NULL, 0) < 0) {
-            PyErr_SetFromErrno(PyExc_OSError);
-            return NULL;
-        }
-        buf = malloc(len);
-        if (buf == NULL) {
-            PyErr_NoMemory();
-            return NULL;
-        }
-        if (sysctlbyname("net.inet.tcp.pcblist", buf, &len, NULL, 0) < 0) {
-            free(buf);
-            PyErr_SetFromErrno(PyExc_OSError);
-            return NULL;
-        }
-        return buf;
-    }
-}
-
-
-static int
-psutil_sockaddr_port(int family, struct sockaddr_storage *ss) {
-    struct sockaddr_in6 *sin6;
-    struct sockaddr_in *sin;
-
-    if (family == AF_INET) {
-        sin = (struct sockaddr_in *)ss;
-        return (sin->sin_port);
-    }
-    else {
-        sin6 = (struct sockaddr_in6 *)ss;
-        return (sin6->sin6_port);
-    }
-}
-
-
-static void *
-psutil_sockaddr_addr(int family, struct sockaddr_storage *ss) {
-    struct sockaddr_in6 *sin6;
-    struct sockaddr_in *sin;
-
-    if (family == AF_INET) {
-        sin = (struct sockaddr_in *)ss;
-        return (&sin->sin_addr);
-    }
-    else {
-        sin6 = (struct sockaddr_in6 *)ss;
-        return (&sin6->sin6_addr);
-    }
-}
-
-
-static socklen_t
-psutil_sockaddr_addrlen(int family) {
-    if (family == AF_INET)
-        return (sizeof(struct in_addr));
-    else
-        return (sizeof(struct in6_addr));
-}
-
-
-static int
-psutil_sockaddr_matches(int family, int port, void *pcb_addr,
-                        struct sockaddr_storage *ss) {
-    if (psutil_sockaddr_port(family, ss) != port)
-        return (0);
-    return (memcmp(psutil_sockaddr_addr(family, ss), pcb_addr,
-                   psutil_sockaddr_addrlen(family)) == 0);
-}
-
-
-static struct tcpcb *
-psutil_search_tcplist(char *buf, struct kinfo_file *kif) {
-    struct tcpcb *tp;
-    struct inpcb *inp;
-    struct xinpgen *xig, *oxig;
-    struct xsocket *so;
-
-    oxig = xig = (struct xinpgen *)buf;
-    for (xig = (struct xinpgen *)((char *)xig + xig->xig_len);
-            xig->xig_len > sizeof(struct xinpgen);
-            xig = (struct xinpgen *)((char *)xig + xig->xig_len)) {
-        tp = &((struct xtcpcb *)xig)->xt_tp;
-        inp = &((struct xtcpcb *)xig)->xt_inp;
-        so = &((struct xtcpcb *)xig)->xt_socket;
-
-        if (so->so_type != kif->kf_sock_type ||
-                so->xso_family != kif->kf_sock_domain ||
-                so->xso_protocol != kif->kf_sock_protocol)
-            continue;
-
-        if (kif->kf_sock_domain == AF_INET) {
-            if (!psutil_sockaddr_matches(
-                    AF_INET, inp->inp_lport, &inp->inp_laddr,
-                    &kif->kf_sa_local))
-                continue;
-            if (!psutil_sockaddr_matches(
-                    AF_INET, inp->inp_fport, &inp->inp_faddr,
-                    &kif->kf_sa_peer))
-                continue;
-        } else {
-            if (!psutil_sockaddr_matches(
-                    AF_INET6, inp->inp_lport, &inp->in6p_laddr,
-                    &kif->kf_sa_local))
-                continue;
-            if (!psutil_sockaddr_matches(
-                    AF_INET6, inp->inp_fport, &inp->in6p_faddr,
-                    &kif->kf_sa_peer))
-                continue;
-        }
-
-        return (tp);
-    }
-    return NULL;
-}
-
-
-int
-psutil_populate_xfiles() {
-    size_t len;
-
-    if ((psutil_xfiles = malloc(len = sizeof *psutil_xfiles)) == NULL) {
-        PyErr_NoMemory();
-        return 0;
-    }
-    while (sysctlbyname("kern.file", psutil_xfiles, &len, 0, 0) == -1) {
-        if (errno != ENOMEM) {
-            PyErr_SetFromErrno(0);
-            return 0;
-        }
-        len *= 2;
-        if ((psutil_xfiles = realloc(psutil_xfiles, len)) == NULL) {
-            PyErr_NoMemory();
-            return 0;
-        }
-    }
-    if (len > 0 && psutil_xfiles->xf_size != sizeof *psutil_xfiles) {
-        PyErr_Format(PyExc_RuntimeError, "struct xfile size mismatch");
-        return 0;
-    }
-    psutil_nxfiles = len / sizeof *psutil_xfiles;
-    return 1;
-}
-
-
-int
-psutil_get_pid_from_sock(int sock_hash) {
-    struct xfile *xf;
-    int hash, n;
-    for (xf = psutil_xfiles, n = 0; n < psutil_nxfiles; ++n, ++xf) {
-        if (xf->xf_data == NULL)
-            continue;
-        hash = (int)((uintptr_t)xf->xf_data % HASHSIZE);
-        if (sock_hash == hash)
-            return xf->xf_pid;
-    }
-    return -1;
-}
-
-
-// Reference:
-// https://gitorious.org/freebsd/freebsd/source/
-//     f1d6f4778d2044502209708bc167c05f9aa48615:usr.bin/sockstat/sockstat.c
-int psutil_gather_inet(int proto, PyObject *py_retlist) {
-    struct xinpgen *xig, *exig;
-    struct xinpcb *xip;
-    struct xtcpcb *xtp;
-    struct inpcb *inp;
-    struct xsocket *so;
-    const char *varname = NULL;
-    size_t len, bufsize;
-    void *buf;
-    int hash;
-    int retry;
-    int type;
-
-    PyObject *py_tuple = NULL;
-    PyObject *py_laddr = NULL;
-    PyObject *py_raddr = NULL;
-
-    switch (proto) {
-        case IPPROTO_TCP:
-            varname = "net.inet.tcp.pcblist";
-            type = SOCK_STREAM;
-            break;
-        case IPPROTO_UDP:
-            varname = "net.inet.udp.pcblist";
-            type = SOCK_DGRAM;
-            break;
-    }
-
-    buf = NULL;
-    bufsize = 8192;
-    retry = 5;
-    do {
-        for (;;) {
-            buf = realloc(buf, bufsize);
-            if (buf == NULL)
-                continue;  // XXX
-            len = bufsize;
-            if (sysctlbyname(varname, buf, &len, NULL, 0) == 0)
-                break;
-            if (errno != ENOMEM) {
-                PyErr_SetFromErrno(0);
-                goto error;
-            }
-            bufsize *= 2;
-        }
-        xig = (struct xinpgen *)buf;
-        exig = (struct xinpgen *)(void *)((char *)buf + len - sizeof *exig);
-        if (xig->xig_len != sizeof *xig || exig->xig_len != sizeof *exig) {
-            PyErr_Format(PyExc_RuntimeError, "struct xinpgen size mismatch");
-            goto error;
-        }
-    } while (xig->xig_gen != exig->xig_gen && retry--);
-
-    for (;;) {
-        int lport, rport, pid, status, family;
-
-        xig = (struct xinpgen *)(void *)((char *)xig + xig->xig_len);
-        if (xig >= exig)
-            break;
-
-        switch (proto) {
-            case IPPROTO_TCP:
-                xtp = (struct xtcpcb *)xig;
-                if (xtp->xt_len != sizeof *xtp) {
-                    PyErr_Format(PyExc_RuntimeError,
-                                 "struct xtcpcb size mismatch");
-                    goto error;
-                }
-                inp = &xtp->xt_inp;
-                so = &xtp->xt_socket;
-                status = xtp->xt_tp.t_state;
-                break;
-            case IPPROTO_UDP:
-                xip = (struct xinpcb *)xig;
-                if (xip->xi_len != sizeof *xip) {
-                    PyErr_Format(PyExc_RuntimeError,
-                                 "struct xinpcb size mismatch");
-                    goto error;
-                }
-                inp = &xip->xi_inp;
-                so = &xip->xi_socket;
-                status = PSUTIL_CONN_NONE;
-                break;
-            default:
-                PyErr_Format(PyExc_RuntimeError, "invalid proto");
-                goto error;
-        }
-
-        char lip[200], rip[200];
-
-        hash = (int)((uintptr_t)so->xso_so % HASHSIZE);
-        pid = psutil_get_pid_from_sock(hash);
-        if (pid < 0)
-            continue;
-        lport = ntohs(inp->inp_lport);
-        rport = ntohs(inp->inp_fport);
-
-        if (inp->inp_vflag & INP_IPV4) {
-            family = AF_INET;
-            inet_ntop(AF_INET, &inp->inp_laddr.s_addr, lip, sizeof(lip));
-            inet_ntop(AF_INET, &inp->inp_faddr.s_addr, rip, sizeof(rip));
-        }
-        else if (inp->inp_vflag & INP_IPV6) {
-            family = AF_INET6;
-            inet_ntop(AF_INET6, &inp->in6p_laddr.s6_addr, lip, sizeof(lip));
-            inet_ntop(AF_INET6, &inp->in6p_faddr.s6_addr, rip, sizeof(rip));
-        }
-
-        // construct python tuple/list
-        py_laddr = Py_BuildValue("(si)", lip, lport);
-        if (!py_laddr)
-            goto error;
-        if (rport != 0)
-            py_raddr = Py_BuildValue("(si)", rip, rport);
-        else
-            py_raddr = Py_BuildValue("()");
-        if (!py_raddr)
-            goto error;
-        py_tuple = Py_BuildValue("(iiiNNii)", -1, family, type, py_laddr,
-                                 py_raddr, status, pid);
-        if (!py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-
-    free(buf);
-    return 1;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_laddr);
-    Py_XDECREF(py_raddr);
-    free(buf);
-    return 0;
-}
-
-
-int psutil_gather_unix(int proto, PyObject *py_retlist) {
-    struct xunpgen *xug, *exug;
-    struct xunpcb *xup;
-    const char *varname = NULL;
-    const char *protoname = NULL;
-    size_t len;
-    size_t bufsize;
-    void *buf;
-    int hash;
-    int retry;
-    int pid;
-    struct sockaddr_un *sun;
-    char path[PATH_MAX];
-
-    PyObject *py_tuple = NULL;
-    PyObject *py_laddr = NULL;
-    PyObject *py_raddr = NULL;
-
-    switch (proto) {
-        case SOCK_STREAM:
-            varname = "net.local.stream.pcblist";
-            protoname = "stream";
-            break;
-        case SOCK_DGRAM:
-            varname = "net.local.dgram.pcblist";
-            protoname = "dgram";
-            break;
-    }
-
-    buf = NULL;
-    bufsize = 8192;
-    retry = 5;
-
-    do {
-        for (;;) {
-            buf = realloc(buf, bufsize);
-            if (buf == NULL) {
-                PyErr_NoMemory();
-                goto error;
-            }
-            len = bufsize;
-            if (sysctlbyname(varname, buf, &len, NULL, 0) == 0)
-                break;
-            if (errno != ENOMEM) {
-                PyErr_SetFromErrno(0);
-                goto error;
-            }
-            bufsize *= 2;
-        }
-        xug = (struct xunpgen *)buf;
-        exug = (struct xunpgen *)(void *)
-            ((char *)buf + len - sizeof *exug);
-        if (xug->xug_len != sizeof *xug || exug->xug_len != sizeof *exug) {
-            PyErr_Format(PyExc_RuntimeError, "struct xinpgen size mismatch");
-            goto error;
-        }
-    } while (xug->xug_gen != exug->xug_gen && retry--);
-
-    for (;;) {
-        xug = (struct xunpgen *)(void *)((char *)xug + xug->xug_len);
-        if (xug >= exug)
-            break;
-        xup = (struct xunpcb *)xug;
-        if (xup->xu_len != sizeof *xup)
-            goto error;
-
-        hash = (int)((uintptr_t) xup->xu_socket.xso_so % HASHSIZE);
-        pid = psutil_get_pid_from_sock(hash);
-        if (pid < 0)
-            continue;
-
-        sun = (struct sockaddr_un *)&xup->xu_addr;
-        snprintf(path, sizeof(path), "%.*s",
-                 (int)(sun->sun_len - (sizeof(*sun) - sizeof(sun->sun_path))),
-                 sun->sun_path);
-
-        py_tuple = Py_BuildValue("(iiisOii)", -1, AF_UNIX, proto, path,
-                                 Py_None, PSUTIL_CONN_NONE, pid);
-        if (!py_tuple)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-        Py_INCREF(Py_None);
-    }
-
-    free(buf);
-    return 1;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_laddr);
-    Py_XDECREF(py_raddr);
-    free(buf);
-    return 0;
-}
-
-
-PyObject*
-psutil_net_connections(PyObject* self, PyObject* args) {
-    // Return system-wide open connections.
-    PyObject *py_retlist = PyList_New(0);
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (psutil_populate_xfiles() != 1)
-        goto error;
-    if (psutil_gather_inet(IPPROTO_TCP, py_retlist) == 0)
-        goto error;
-    if (psutil_gather_inet(IPPROTO_UDP, py_retlist) == 0)
-        goto error;
-    if (psutil_gather_unix(SOCK_STREAM, py_retlist) == 0)
-       goto error;
-    if (psutil_gather_unix(SOCK_DGRAM, py_retlist) == 0)
-        goto error;
-
-    free(psutil_xfiles);
-    return py_retlist;
-
-error:
-    Py_DECREF(py_retlist);
-    free(psutil_xfiles);
-    return NULL;
-}
-
-
-PyObject *
-psutil_proc_connections(PyObject *self, PyObject *args) {
-    // Return connections opened by process.
-    long pid;
-    int i, cnt;
-    struct kinfo_file *freep = NULL;
-    struct kinfo_file *kif;
-    char *tcplist = NULL;
-    struct tcpcb *tcp;
-
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_laddr = NULL;
-    PyObject *py_raddr = NULL;
-    PyObject *py_af_filter = NULL;
-    PyObject *py_type_filter = NULL;
-    PyObject *py_family = NULL;
-    PyObject *py_type = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "lOO", &pid, &py_af_filter, &py_type_filter))
-        goto error;
-    if (!PySequence_Check(py_af_filter) || !PySequence_Check(py_type_filter)) {
-        PyErr_SetString(PyExc_TypeError, "arg 2 or 3 is not a sequence");
-        goto error;
-    }
-
-    freep = kinfo_getfile(pid, &cnt);
-    if (freep == NULL) {
-        psutil_raise_ad_or_nsp(pid);
-        goto error;
-    }
-
-    tcplist = psutil_fetch_tcplist();
-    if (tcplist == NULL) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    for (i = 0; i < cnt; i++) {
-        int lport, rport, state;
-        char lip[200], rip[200];
-        char path[PATH_MAX];
-        int inseq;
-        py_tuple = NULL;
-        py_laddr = NULL;
-        py_raddr = NULL;
-
-        kif = &freep[i];
-        if (kif->kf_type == KF_TYPE_SOCKET) {
-            // apply filters
-            py_family = PyLong_FromLong((long)kif->kf_sock_domain);
-            inseq = PySequence_Contains(py_af_filter, py_family);
-            Py_DECREF(py_family);
-            if (inseq == 0)
-                continue;
-            py_type = PyLong_FromLong((long)kif->kf_sock_type);
-            inseq = PySequence_Contains(py_type_filter, py_type);
-            Py_DECREF(py_type);
-            if (inseq == 0)
-                continue;
-            // IPv4 / IPv6 socket
-            if ((kif->kf_sock_domain == AF_INET) ||
-                    (kif->kf_sock_domain == AF_INET6)) {
-                // fill status
-                state = PSUTIL_CONN_NONE;
-                if (kif->kf_sock_type == SOCK_STREAM) {
-                    tcp = psutil_search_tcplist(tcplist, kif);
-                    if (tcp != NULL)
-                        state = (int)tcp->t_state;
-                }
-
-                // build addr and port
-                inet_ntop(
-                    kif->kf_sock_domain,
-                    psutil_sockaddr_addr(kif->kf_sock_domain,
-                                         &kif->kf_sa_local),
-                    lip,
-                    sizeof(lip));
-                inet_ntop(
-                    kif->kf_sock_domain,
-                    psutil_sockaddr_addr(kif->kf_sock_domain,
-                                         &kif->kf_sa_peer),
-                    rip,
-                    sizeof(rip));
-                lport = htons(psutil_sockaddr_port(kif->kf_sock_domain,
-                                                   &kif->kf_sa_local));
-                rport = htons(psutil_sockaddr_port(kif->kf_sock_domain,
-                                                   &kif->kf_sa_peer));
-
-                // construct python tuple/list
-                py_laddr = Py_BuildValue("(si)", lip, lport);
-                if (!py_laddr)
-                    goto error;
-                if (rport != 0)
-                    py_raddr = Py_BuildValue("(si)", rip, rport);
-                else
-                    py_raddr = Py_BuildValue("()");
-                if (!py_raddr)
-                    goto error;
-                py_tuple = Py_BuildValue(
-                    "(iiiNNi)",
-                    kif->kf_fd,
-                    kif->kf_sock_domain,
-                    kif->kf_sock_type,
-                    py_laddr,
-                    py_raddr,
-                    state
-                );
-                if (!py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-            }
-            // UNIX socket
-            else if (kif->kf_sock_domain == AF_UNIX) {
-                struct sockaddr_un *sun;
-
-                sun = (struct sockaddr_un *)&kif->kf_sa_local;
-                snprintf(
-                    path, sizeof(path), "%.*s",
-                    (int)(sun->sun_len - (sizeof(*sun) - sizeof(sun->sun_path))),
-                    sun->sun_path);
-
-                py_tuple = Py_BuildValue(
-                    "(iiisOi)",
-                    kif->kf_fd,
-                    kif->kf_sock_domain,
-                    kif->kf_sock_type,
-                    path,
-                    Py_None,
-                    PSUTIL_CONN_NONE
-                );
-                if (!py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-                Py_INCREF(Py_None);
-            }
-        }
-    }
-    free(freep);
-    free(tcplist);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_laddr);
-    Py_XDECREF(py_raddr);
-    Py_DECREF(py_retlist);
-    if (freep != NULL)
-        free(freep);
-    if (tcplist != NULL)
-        free(tcplist);
-    return NULL;
-}
diff --git a/psutil/arch/bsd/freebsd_socks.h b/psutil/arch/bsd/freebsd_socks.h
deleted file mode 100644
index 15ccb0b3b1..0000000000
--- a/psutil/arch/bsd/freebsd_socks.h
+++ /dev/null
@@ -1,11 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola'.
- * All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include <Python.h>
-
-PyObject* psutil_proc_connections(PyObject* self, PyObject* args);
-PyObject* psutil_net_connections(PyObject* self, PyObject* args);
diff --git a/psutil/arch/bsd/heap.c b/psutil/arch/bsd/heap.c
new file mode 100644
index 0000000000..334a613cb4
--- /dev/null
+++ b/psutil/arch/bsd/heap.c
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#if defined(PSUTIL_FREEBSD) || defined(PSUTIL_NETBSD)
+#include <Python.h>
+#include <stdlib.h>
+#if defined(PSUTIL_FREEBSD)
+#include <malloc_np.h>
+#else
+#include <malloc.h>
+#endif
+
+#include "../../arch/all/init.h"
+
+
+// Return low-level heap statistics from the C allocator. Return
+// jemalloc heap stats via `mallctl()`. Mimics Linux `mallinfo2()`:
+// - heap_used  ~ stats.allocated  (like `uordblks`)
+// - mmap_used  ~ stats.mapped     (like `hblkhd`)
+PyObject *
+psutil_heap_info(PyObject *self, PyObject *args) {
+    uint64_t epoch = 0;
+    uint64_t allocated = 0, active = 0, mapped = 0;
+    size_t sz_epoch = sizeof(epoch);
+    size_t sz_val;
+    int ret;
+
+    // Flush per-thread tcache so small leaks become visible.
+    // Originates from https://github.com/giampaolo/psleak/issues/6. In
+    // there we had failures for small allocations, which disappeared
+    // after we added this.
+    ret = mallctl("thread.tcache.flush", NULL, NULL, NULL, 0);
+    if (ret != 0)
+        return psutil_oserror_wsyscall("mallctl('thread.tcache.flush')");
+
+    // Read current epoch
+    ret = mallctl("epoch", &epoch, &sz_epoch, NULL, 0);
+    if (ret != 0)
+        return psutil_oserror_wsyscall("mallctl('epoch')");
+
+    // Refresh stats
+    ret = mallctl("epoch", NULL, NULL, &epoch, sz_epoch);
+    if (ret != 0)
+        return psutil_oserror_wsyscall("mallctl('epoch') update");
+
+    // Read stats
+    sz_val = sizeof(allocated);
+    ret = mallctl("stats.allocated", &allocated, &sz_val, NULL, 0);
+    if (ret != 0)
+        return psutil_oserror_wsyscall("mallctl('stats.allocated')");
+
+    sz_val = sizeof(mapped);
+    ret = mallctl("stats.mapped", &mapped, &sz_val, NULL, 0);
+    if (ret != 0)
+        return psutil_oserror_wsyscall("mallctl('stats.mapped')");
+
+    return Py_BuildValue("KK", allocated, mapped);
+}
+
+
+// Release unused heap memory from all jemalloc arenas back to the OS.
+// Aggressively purges free pages from all arenas (main + per-thread).
+// More effective than Linux `heap_trim(0)`.
+PyObject *
+psutil_heap_trim(PyObject *self, PyObject *args) {
+    char cmd[32];
+    int ret;
+
+#ifdef MALLCTL_ARENAS_ALL
+    // FreeBSD. MALLCTL_ARENAS_ALL is a magic number (4096) which means "all
+    // arenas".
+    str_format(cmd, sizeof(cmd), "arena.%u.purge", MALLCTL_ARENAS_ALL);
+    ret = mallctl(cmd, NULL, NULL, NULL, 0);
+    if (ret != 0)
+        return psutil_oserror();
+#else
+    // NetBSD. Iterate over all arenas.
+    unsigned narenas;
+    size_t sz = sizeof(narenas);
+
+    ret = mallctl("arenas.narenas", &narenas, &sz, NULL, 0);
+    if (ret != 0)
+        return psutil_oserror_wsyscall("mallctl('arenas.narenas')");
+
+    for (unsigned i = 0; i < narenas; i++) {
+        str_format(cmd, sizeof(cmd), "arena.%u.purge", i);
+        ret = mallctl(cmd, NULL, NULL, NULL, 0);
+        if (ret != 0)
+            return psutil_oserror_wsyscall("mallctl('arena.{n}.purge')");
+    }
+#endif
+
+    Py_RETURN_NONE;
+}
+#endif  // PSUTIL_FREEBSD || PSUTIL_NETBSD
diff --git a/psutil/arch/bsd/init.c b/psutil/arch/bsd/init.c
new file mode 100644
index 0000000000..d3f00f5f20
--- /dev/null
+++ b/psutil/arch/bsd/init.c
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "../../arch/all/init.h"
+
+
+void
+convert_kvm_err(const char *syscall, char *errbuf) {
+    char fullmsg[512];
+
+    str_format(
+        fullmsg, sizeof(fullmsg), "(originated from %s: %s)", syscall, errbuf
+    );
+    if (strstr(errbuf, "Permission denied") != NULL)
+        psutil_oserror_ad(fullmsg);
+    else if (strstr(errbuf, "Operation not permitted") != NULL)
+        psutil_oserror_ad(fullmsg);
+    else
+        psutil_runtime_error(fullmsg);
+}
diff --git a/psutil/arch/bsd/init.h b/psutil/arch/bsd/init.h
new file mode 100644
index 0000000000..9540901b40
--- /dev/null
+++ b/psutil/arch/bsd/init.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/types.h>
+
+
+#define PSUTIL_KPT2DOUBLE(t) (t##_sec + t##_usec / 1000000.0)
+
+#ifdef PSUTIL_NETBSD
+// Same states as the kernel's P_ZOMBIE(), which we can't use here:
+// it reads p_stat, which in kinfo_proc2 is the LWP status. The
+// process one is p_realstat. A dying process goes SDYING -> SDEAD
+// -> SZOMB, and only the last one has the same value as its LWP
+// counterpart.
+#define PSUTIL_KINFO_ZOMBIE(kp)                            \
+    ((kp).p_realstat == SZOMB || (kp).p_realstat == SDYING \
+     || (kp).p_realstat == SDEAD)
+#elif defined(PSUTIL_OPENBSD)
+// According to /usr/include/sys/proc.h SZOMB is unused.
+// test_zombie_process() shows that SDEAD is the right equivalent.
+#define PSUTIL_KINFO_ZOMBIE(kp) ((kp).p_stat == SZOMB || (kp).p_stat == SDEAD)
+#elif defined(PSUTIL_FREEBSD)
+#define PSUTIL_KINFO_ZOMBIE(kp) ((kp).ki_stat == SZOMB)
+#endif
+
+#if defined(PSUTIL_OPENBSD) || defined(PSUTIL_NETBSD)
+#define PSUTIL_HASNT_KINFO_GETFILE
+struct kinfo_file *kinfo_getfile(pid_t pid, int *cnt);
+#endif
+
+int psutil_kinfo_proc(pid_t pid, void *proc);
+void convert_kvm_err(const char *syscall, char *errbuf);
+int is_zombie(size_t pid);
+
+PyObject *psutil_boot_time(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_count_logical(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_disk_partitions(PyObject *self, PyObject *args);
+PyObject *psutil_heap_info(PyObject *self, PyObject *args);
+PyObject *psutil_heap_trim(PyObject *self, PyObject *args);
+PyObject *psutil_net_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_proc_environ(PyObject *self, PyObject *args);
+PyObject *psutil_proc_name(PyObject *self, PyObject *args);
+PyObject *psutil_proc_oneshot_kinfo(PyObject *self, PyObject *args);
+PyObject *psutil_proc_open_files(PyObject *self, PyObject *args);
+#if defined(PSUTIL_OPENBSD) || defined(PSUTIL_NETBSD)
+PyObject *psutil_swap_mem(PyObject *self, PyObject *args);
+#endif
diff --git a/psutil/arch/bsd/mem.c b/psutil/arch/bsd/mem.c
new file mode 100644
index 0000000000..7a0d838ae8
--- /dev/null
+++ b/psutil/arch/bsd/mem.c
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "../../arch/all/init.h"
+
+#if defined(PSUTIL_OPENBSD) || defined(PSUTIL_NETBSD)
+#include <Python.h>
+#include <sys/swap.h>
+#include <uvm/uvm_extern.h>
+#include <sys/sysctl.h>
+#include <sys/param.h>
+
+
+PyObject *
+psutil_swap_mem(PyObject *self, PyObject *args) {
+    uint64_t swap_total = 0;
+    uint64_t swap_free = 0;
+    uint64_t swap_used = 0;
+    uint64_t sin = 0;
+    uint64_t sout = 0;
+    double percent = 0.0;
+    struct swapent *swdev = NULL;
+    int nswap, i;
+    long pagesize = psutil_getpagesize();
+    PyObject *dict = PyDict_New();
+
+    if (dict == NULL)
+        return NULL;
+
+    nswap = swapctl(SWAP_NSWAP, 0, 0);
+    if (nswap == 0)  // this means there's no swap partition
+        goto done;
+
+    swdev = calloc(nswap, sizeof(*swdev));
+    if (swdev == NULL) {
+        psutil_oserror();
+        goto error;
+    }
+
+    if (swapctl(SWAP_STATS, swdev, nswap) == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    // Total things up.
+    for (i = 0; i < nswap; i++) {
+        if (swdev[i].se_flags & SWF_ENABLE) {
+            swap_total += (uint64_t)swdev[i].se_nblks * DEV_BSIZE;
+            swap_free += (uint64_t)(swdev[i].se_nblks - swdev[i].se_inuse)
+                         * DEV_BSIZE;
+        }
+    }
+
+    // Get swap in/out.
+#if defined(PSUTIL_NETBSD)
+    struct uvmexp_sysctl uv;
+    int mib[] = {CTL_VM, VM_UVMEXP2};
+#else  // OpenBSD
+    struct uvmexp uv;
+    int mib[] = {CTL_VM, VM_UVMEXP};
+#endif
+    if (psutil_sysctl(mib, 2, &uv, sizeof(uv)) != 0)
+        goto error;
+    sin = (uint64_t)uv.pgswapin * pagesize;
+    sout = (uint64_t)uv.pgswapout * pagesize;
+
+    free(swdev);
+
+    swap_used = swap_total - swap_free;
+    percent = psutil_usage_percent((double)swap_used, (double)swap_total, 1);
+
+done:
+    if (!(pydict_add(dict, "total", "K", swap_total)
+          | pydict_add(dict, "used", "K", swap_used)
+          | pydict_add(dict, "free", "K", swap_free)
+          | pydict_add(dict, "percent", "d", percent)
+          | pydict_add(dict, "sin", "K", sin)
+          | pydict_add(dict, "sout", "K", sout)))
+        goto error;
+
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    free(swdev);
+    return NULL;
+}
+#endif  // PSUTIL_OPENBSD || PSUTIL_NETBSD
diff --git a/psutil/arch/bsd/net.c b/psutil/arch/bsd/net.c
new file mode 100644
index 0000000000..a14166bd50
--- /dev/null
+++ b/psutil/arch/bsd/net.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysctl.h>
+#include <string.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_net_io_counters(PyObject *self, PyObject *args) {
+    char *buf = NULL, *lim, *next;
+    struct if_msghdr *ifm;
+    int mib[6];
+    size_t len;
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_ifc_info = NULL;
+
+    if (py_retdict == NULL)
+        return NULL;
+
+    mib[0] = CTL_NET;  // networking subsystem
+    mib[1] = PF_ROUTE;  // type of information
+    mib[2] = 0;  // protocol (IPPROTO_xxx)
+    mib[3] = 0;  // address family
+    mib[4] = NET_RT_IFLIST;  // operation
+    mib[5] = 0;
+
+    if (psutil_sysctl_malloc(mib, 6, &buf, &len) != 0)
+        goto error;
+
+    lim = buf + len;
+
+    for (next = buf; next < lim;) {
+        py_ifc_info = NULL;
+        ifm = (struct if_msghdr *)next;
+        next += ifm->ifm_msglen;
+
+        if (ifm->ifm_type == RTM_IFINFO) {
+            struct if_msghdr *if2m = (struct if_msghdr *)ifm;
+            struct sockaddr_dl *sdl = (struct sockaddr_dl *)(if2m + 1);
+            char ifc_name[32];
+            // sdl_nlen comes from the kernel and is used as an index
+            // below, so don't trust it blindly.
+            size_t namelen = sdl->sdl_nlen;
+
+            if (namelen >= sizeof(ifc_name))
+                namelen = sizeof(ifc_name) - 1;
+            memcpy(ifc_name, sdl->sdl_data, namelen);
+            ifc_name[namelen] = '\0';
+
+            // XXX: ignore usbus interfaces:
+            // http://lists.freebsd.org/pipermail/freebsd-current/2011-October/028752.html
+            // 'ifconfig -a' doesn't show them, nor do we.
+            if (strncmp(ifc_name, "usbus", 5) == 0)
+                continue;
+
+            py_ifc_info = Py_BuildValue(
+                "(kkkkkkki)",
+                if2m->ifm_data.ifi_obytes,
+                if2m->ifm_data.ifi_ibytes,
+                if2m->ifm_data.ifi_opackets,
+                if2m->ifm_data.ifi_ipackets,
+                if2m->ifm_data.ifi_ierrors,
+                if2m->ifm_data.ifi_oerrors,
+                if2m->ifm_data.ifi_iqdrops,
+#ifdef _IFI_OQDROPS
+                if2m->ifm_data.ifi_oqdrops
+#else
+                0
+#endif
+            );
+            if (!py_ifc_info)
+                goto error;
+            if (PyDict_SetItemString(py_retdict, ifc_name, py_ifc_info) != 0)
+                goto error;
+            Py_CLEAR(py_ifc_info);
+        }
+    }
+
+    free(buf);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_ifc_info);
+    Py_DECREF(py_retdict);
+    free(buf);
+    return NULL;
+}
diff --git a/psutil/arch/bsd/netbsd.c b/psutil/arch/bsd/netbsd.c
deleted file mode 100644
index 1e24d58d2f..0000000000
--- a/psutil/arch/bsd/netbsd.c
+++ /dev/null
@@ -1,701 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
- * All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Platform-specific module methods for NetBSD.
- */
-
-#if defined(__NetBSD__)
-#define _KMEMUSER
-#endif
-
-#include <Python.h>
-#include <assert.h>
-#include <err.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/sysctl.h>
-#include <sys/user.h>
-#include <sys/proc.h>
-#include <sys/swap.h>  // for swap_mem
-#include <signal.h>
-#include <kvm.h>
-// connection stuff
-#include <netdb.h>  // for NI_MAXHOST
-#include <sys/socket.h>
-#include <sys/sched.h>  // for CPUSTATES & CP_*
-#define _KERNEL  // for DTYPE_*
-#include <sys/file.h>
-#undef _KERNEL
-#include <sys/disk.h>  // struct diskstats
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-
-#include "netbsd.h"
-#include "netbsd_socks.h"
-#include "../../_psutil_common.h"
-
-#define PSUTIL_KPT2DOUBLE(t) (t ## _sec + t ## _usec / 1000000.0)
-#define PSUTIL_TV2DOUBLE(t) ((t).tv_sec + (t).tv_usec / 1000000.0)
-
-
-// ============================================================================
-// Utility functions
-// ============================================================================
-
-
-int
-psutil_raise_ad_or_nsp(long pid) {
-    // Set exception to AccessDenied if pid exists else NoSuchProcess.
-    if (psutil_pid_exists(pid) == 0)
-        NoSuchProcess();
-    else
-        AccessDenied();
-}
-
-
-int
-psutil_kinfo_proc(pid_t pid, kinfo_proc *proc) {
-    // Fills a kinfo_proc struct based on process pid.
-    int ret;
-    int mib[6];
-    size_t size = sizeof(kinfo_proc);
-
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC2;
-    mib[2] = KERN_PROC_PID;
-    mib[3] = pid;
-    mib[4] = size;
-    mib[5] = 1;
-
-    ret = sysctl((int*)mib, 6, proc, &size, NULL, 0);
-    if (ret == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return -1;
-    }
-    // sysctl stores 0 in the size if we can't find the process information.
-    if (size == 0) {
-        NoSuchProcess();
-        return -1;
-    }
-    return 0;
-}
-
-
-struct kinfo_file *
-kinfo_getfile(pid_t pid, int* cnt) {
-    // Mimic's FreeBSD kinfo_file call, taking a pid and a ptr to an
-    // int as arg and returns an array with cnt struct kinfo_file.
-    int mib[6];
-    size_t len;
-    struct kinfo_file* kf;
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_FILE2;
-    mib[2] = KERN_FILE_BYPID;
-    mib[3] = (int) pid;
-    mib[4] = sizeof(struct kinfo_file);
-    mib[5] = 0;
-
-    // get the size of what would be returned
-    if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-    if ((kf = malloc(len)) == NULL) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-    mib[5] = (int)(len / sizeof(struct kinfo_file));
-    if (sysctl(mib, 6, kf, &len, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    *cnt = (int)(len / sizeof(struct kinfo_file));
-    return kf;
-}
-
-
-int
-psutil_pid_exists(pid_t pid) {
-    // Return 1 if PID exists in the current process list, else 0, -1
-    // on error.
-    // TODO: this should live in _psutil_posix.c but for some reason if I
-    // move it there I get a "include undefined symbol" error.
-    int ret;
-    if (pid < 0)
-        return 0;
-    ret = kill(pid , 0);
-    if (ret == 0)
-        return 1;
-    else {
-        if (ret == ESRCH)
-            return 0;
-        else if (ret == EPERM)
-            return 1;
-        else {
-            PyErr_SetFromErrno(PyExc_OSError);
-            return -1;
-        }
-    }
-}
-
-
-// XXX: This is no longer used as per
-// https://github.com/giampaolo/psutil/pull/557#issuecomment-171912820
-// Current implementation uses /proc instead.
-// Left here just in case.
-PyObject *
-psutil_proc_exe(PyObject *self, PyObject *args) {
-#if __NetBSD_Version__ >= 799000000
-    pid_t pid;
-    char pathname[MAXPATHLEN];
-    int error;
-    int mib[4];
-    int ret;
-    size_t size;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (pid == 0) {
-        // else returns ENOENT
-        return Py_BuildValue("s", "");
-    }
-
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC_ARGS;
-    mib[2] = pid;
-    mib[3] = KERN_PROC_PATHNAME;
-
-    size = sizeof(pathname);
-    error = sysctl(mib, 4, NULL, &size, NULL, 0);
-    if (error == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    error = sysctl(mib, 4, pathname, &size, NULL, 0);
-    if (error == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-    if (size == 0 || strlen(pathname) == 0) {
-        ret = psutil_pid_exists(pid);
-        if (ret == -1)
-            return NULL;
-        else if (ret == 0)
-            return NoSuchProcess();
-        else
-            strcpy(pathname, "");
-    }
-
-#if PY_MAJOR_VERSION >= 3
-    return PyUnicode_DecodeFSDefault(pathname);
-#else
-    return Py_BuildValue("s", pathname);
-#endif
-
-#else
-    return Py_BuildValue("s", "");
-#endif
-}
-
-PyObject *
-psutil_proc_num_threads(PyObject *self, PyObject *args) {
-    // Return number of threads used by process as a Python integer.
-    long pid;
-    kinfo_proc kp;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-    return Py_BuildValue("l", (long)kp.p_nlwps);
-}
-
-PyObject *
-psutil_proc_threads(PyObject *self, PyObject *args) {
-    pid_t pid;
-    int mib[5];
-    int i, nlwps;
-    ssize_t st;
-    size_t size;
-    struct kinfo_lwp *kl = NULL;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_LWP;
-    mib[2] = pid;
-    mib[3] = sizeof(struct kinfo_lwp);
-    mib[4] = 0;
-
-    st = sysctl(mib, 5, NULL, &size, NULL, 0);
-    if (st == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-    if (size == 0) {
-        NoSuchProcess();
-        goto error;
-    }
-
-    mib[4] = size / sizeof(size_t);
-    kl = malloc(size);
-    if (kl == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    st = sysctl(mib, 5, kl, &size, NULL, 0);
-    if (st == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-    if (size == 0) {
-        NoSuchProcess();
-        goto error;
-    }
-
-    nlwps = (int)(size / sizeof(struct kinfo_lwp));
-    for (i = 0; i < nlwps; i++) {
-        py_tuple = Py_BuildValue("idd",
-                                 (&kl[i])->l_lid,
-                                 PSUTIL_KPT2DOUBLE((&kl[i])->l_rtime),
-                                 PSUTIL_KPT2DOUBLE((&kl[i])->l_rtime));
-        if (py_tuple == NULL)
-            goto error;
-        if (PyList_Append(py_retlist, py_tuple))
-            goto error;
-        Py_DECREF(py_tuple);
-    }
-    free(kl);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (kl != NULL)
-        free(kl);
-    return NULL;
-}
-
-
-// ============================================================================
-// APIS
-// ============================================================================
-
-int
-psutil_get_proc_list(kinfo_proc **procList, size_t *procCount) {
-    // Returns a list of all BSD processes on the system.  This routine
-    // allocates the list and puts it in *procList and a count of the
-    // number of entries in *procCount.  You are responsible for freeing
-    // this list (use "free" from System framework).
-    // On success, the function returns 0.
-    // On error, the function returns a BSD errno value.
-    kinfo_proc *result;
-    int done;
-    static const int name[] = { CTL_KERN, KERN_PROC, KERN_PROC, 0 };
-    // Declaring name as const requires us to cast it when passing it to
-    // sysctl because the prototype doesn't include the const modifier.
-    size_t length;
-    char errbuf[_POSIX2_LINE_MAX];
-    kinfo_proc *x;
-    int cnt;
-    kvm_t *kd;
-
-    assert( procList != NULL);
-    assert(*procList == NULL);
-    assert(procCount != NULL);
-
-    kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);
-
-    if (kd == NULL) {
-        PyErr_Format(PyExc_RuntimeError, "kvm_openfiles() failed: %s", errbuf);
-        return errno;
-    }
-
-    result = kvm_getproc2(kd, KERN_PROC_ALL, 0, sizeof(kinfo_proc), &cnt);
-    if (result == NULL) {
-        PyErr_Format(PyExc_RuntimeError, "kvm_getproc2() failed");
-        kvm_close(kd);
-        return errno;
-    }
-
-    *procCount = (size_t)cnt;
-
-    size_t mlen = cnt * sizeof(kinfo_proc);
-
-    if ((*procList = malloc(mlen)) == NULL) {
-        PyErr_NoMemory();
-        kvm_close(kd);
-        return errno;
-    }
-
-    memcpy(*procList, result, mlen);
-    assert(*procList != NULL);
-    kvm_close(kd);
-
-    return 0;
-}
-
-
-char *
-psutil_get_cmd_args(pid_t pid, size_t *argsize) {
-    int mib[4];
-    ssize_t st;
-    size_t argmax;
-    size_t size;
-    char *procargs = NULL;
-
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_ARGMAX;
-
-    size = sizeof(argmax);
-    st = sysctl(mib, 2, &argmax, &size, NULL, 0);
-    if (st == -1) {
-        warn("failed to get kern.argmax");
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    procargs = (char *)malloc(argmax);
-    if (procargs == NULL) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC_ARGS;
-    mib[2] = pid;
-    mib[3] = KERN_PROC_ARGV;
-
-    st = sysctl(mib, 4, procargs, &argmax, NULL, 0);
-    if (st == -1) {
-        warn("failed to get kern.procargs");
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    *argsize = argmax;
-    return procargs;
-}
-
-// Return the command line as a python list object.
-// XXX - most of the times sysctl() returns a truncated string.
-// Also /proc/pid/cmdline behaves the same so it looks like this
-// is a kernel bug.
-PyObject *
-psutil_get_cmdline(pid_t pid) {
-    char *argstr = NULL;
-    int pos = 0;
-    size_t argsize = 0;
-    PyObject *py_arg = NULL;
-    PyObject *py_retlist = PyList_New(0);
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (pid == 0)
-        return py_retlist;
-
-    argstr = psutil_get_cmd_args(pid, &argsize);
-    if (argstr == NULL)
-        goto error;
-
-    // args are returned as a flattened string with \0 separators between
-    // arguments add each string to the list then step forward to the next
-    // separator
-    if (argsize > 0) {
-        while (pos < argsize) {
-#if PY_MAJOR_VERSION >= 3
-            py_arg = PyUnicode_DecodeFSDefault(&argstr[pos]);
-#else
-            py_arg = Py_BuildValue("s", &argstr[pos]);
-#endif
-            if (!py_arg)
-                goto error;
-            if (PyList_Append(py_retlist, py_arg))
-                goto error;
-            Py_DECREF(py_arg);
-            pos = pos + strlen(&argstr[pos]) + 1;
-        }
-    }
-
-    free(argstr);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_arg);
-    Py_DECREF(py_retlist);
-    if (argstr != NULL)
-        free(argstr);
-    return NULL;
-}
-
-
-PyObject *
-psutil_virtual_mem(PyObject *self, PyObject *args) {
-    int64_t total_physmem;
-    size_t size;
-    struct uvmexp_sysctl uv;
-    int physmem_mib[] = {CTL_HW, HW_PHYSMEM64};
-    int uvmexp_mib[] = {CTL_VM, VM_UVMEXP2};
-    long pagesize = getpagesize();
-
-    size = sizeof(total_physmem);
-    if (sysctl(physmem_mib, 2, &total_physmem, &size, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    size = sizeof(uv);
-    if (sysctl(uvmexp_mib, 2, &uv, &size, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    return Py_BuildValue("KKKKKKKK",
-        (unsigned long long) total_physmem,  // total
-        (unsigned long long) uv.free * pagesize,  // free
-        (unsigned long long) uv.active * pagesize,  // active
-        (unsigned long long) uv.inactive * pagesize,  // inactive
-        (unsigned long long) uv.wired * pagesize,  // wired
-        // taken from:
-        // https://github.com/satterly/zabbix-stats/blob/master/src/libs/
-        //      zbxsysinfo/netbsd/memory.c
-        (unsigned long long) uv.filepages + uv.execpages * pagesize,  // cached
-        (unsigned long long) 0,  // buffers
-        (unsigned long long) 0  // shared
-    );
-}
-
-
-PyObject *
-psutil_swap_mem(PyObject *self, PyObject *args) {
-    uint64_t swap_total, swap_free;
-    struct swapent *swdev;
-    int nswap, i;
-
-    nswap = swapctl(SWAP_NSWAP, 0, 0);
-    if (nswap == 0) {
-        // This means there's no swap partition.
-        return Py_BuildValue("(iiiii)", 0, 0, 0, 0, 0);
-    }
-
-    swdev = calloc(nswap, sizeof(*swdev));
-    if (swdev == NULL) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    if (swapctl(SWAP_STATS, swdev, nswap) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    // Total things up.
-    swap_total = swap_free = 0;
-    for (i = 0; i < nswap; i++) {
-        if (swdev[i].se_flags & SWF_ENABLE) {
-            swap_free += (swdev[i].se_nblks - swdev[i].se_inuse);
-            swap_total += swdev[i].se_nblks;
-        }
-    }
-    free(swdev);
-
-    // Get swap in/out
-    unsigned int total;
-    size_t size = sizeof(total);
-    struct uvmexp_sysctl uv;
-    int mib[] = {CTL_VM, VM_UVMEXP2};
-    long pagesize = getpagesize();
-    size = sizeof(uv);
-    if (sysctl(mib, 2, &uv, &size, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    return Py_BuildValue("(LLLll)",
-                         swap_total * DEV_BSIZE,
-                         (swap_total - swap_free) * DEV_BSIZE,
-                         swap_free * DEV_BSIZE,
-                         (long) uv.pgswapin * pagesize,  // swap in
-                         (long) uv.pgswapout * pagesize);  // swap out
-
-error:
-    free(swdev);
-}
-
-
-PyObject *
-psutil_proc_num_fds(PyObject *self, PyObject *args) {
-    long pid;
-    int cnt;
-
-    struct kinfo_file *freep;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    freep = kinfo_getfile(pid, &cnt);
-    if (freep == NULL) {
-        psutil_raise_ad_or_nsp(pid);
-        return NULL;
-    }
-    free(freep);
-
-    return Py_BuildValue("i", cnt);
-}
-
-
-PyObject *
-psutil_per_cpu_times(PyObject *self, PyObject *args) {
-    static int maxcpus;
-    int mib[3];
-    int ncpu;
-    size_t len;
-    size_t size;
-    int i;
-    PyObject *py_cputime = NULL;
-    PyObject *py_retlist = PyList_New(0);
-
-    if (py_retlist == NULL)
-        return NULL;
-    // retrieve the number of cpus
-    mib[0] = CTL_HW;
-    mib[1] = HW_NCPU;
-    len = sizeof(ncpu);
-    if (sysctl(mib, 2, &ncpu, &len, NULL, 0) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-    uint64_t cpu_time[CPUSTATES];
-
-    for (i = 0; i < ncpu; i++) {
-        // per-cpu info
-        mib[0] = CTL_KERN;
-        mib[1] = KERN_CP_TIME;
-        mib[2] = i;
-        size = sizeof(cpu_time);
-        if (sysctl(mib, 3, &cpu_time, &size, NULL, 0) == -1) {
-            warn("failed to get kern.cptime2");
-            PyErr_SetFromErrno(PyExc_OSError);
-            return NULL;
-        }
-
-        py_cputime = Py_BuildValue(
-            "(ddddd)",
-            (double)cpu_time[CP_USER] / CLOCKS_PER_SEC,
-            (double)cpu_time[CP_NICE] / CLOCKS_PER_SEC,
-            (double)cpu_time[CP_SYS] / CLOCKS_PER_SEC,
-            (double)cpu_time[CP_IDLE] / CLOCKS_PER_SEC,
-            (double)cpu_time[CP_INTR] / CLOCKS_PER_SEC);
-        if (!py_cputime)
-            goto error;
-        if (PyList_Append(py_retlist, py_cputime))
-            goto error;
-        Py_DECREF(py_cputime);
-    }
-
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_cputime);
-    Py_DECREF(py_retlist);
-    return NULL;
-}
-
-
-PyObject *
-psutil_disk_io_counters(PyObject *self, PyObject *args) {
-    int i, dk_ndrive, mib[3];
-    size_t len;
-    struct io_sysctl *stats;
-    PyObject *py_disk_info = NULL;
-    PyObject *py_retdict = PyDict_New();
-
-    if (py_retdict == NULL)
-        return NULL;
-    mib[0] = CTL_HW;
-    mib[1] = HW_IOSTATS;
-    mib[2] = sizeof(struct io_sysctl);
-    len = 0;
-    if (sysctl(mib, 3, NULL, &len, NULL, 0) < 0) {
-        warn("can't get HW_IOSTATS");
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-    dk_ndrive = (int)(len / sizeof(struct io_sysctl));
-
-    stats = malloc(len);
-    if (stats == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-    if (sysctl(mib, 3, stats, &len, NULL, 0) < 0 ) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    for (i = 0; i < dk_ndrive; i++) {
-        py_disk_info = Py_BuildValue(
-            "(KKKK)",
-            stats[i].rxfer,
-            stats[i].wxfer,
-            stats[i].rbytes,
-            stats[i].wbytes
-        );
-        if (!py_disk_info)
-            goto error;
-        if (PyDict_SetItemString(py_retdict, stats[i].name, py_disk_info))
-            goto error;
-        Py_DECREF(py_disk_info);
-    }
-
-    free(stats);
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_disk_info);
-    Py_DECREF(py_retdict);
-    if (stats != NULL)
-        free(stats);
-    return NULL;
-}
-
-
-PyObject *
-psutil_cpu_stats(PyObject *self, PyObject *args) {
-    size_t size;
-    struct uvmexp_sysctl uv;
-    int uvmexp_mib[] = {CTL_VM, VM_UVMEXP2};
-
-    size = sizeof(uv);
-    if (sysctl(uvmexp_mib, 2, &uv, &size, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    return Py_BuildValue(
-        "IIIIIII",
-        uv.swtch,  // ctx switches
-        uv.intrs,  // interrupts - XXX always 0, will be determined via /proc
-        uv.softs,  // soft interrupts
-        uv.syscalls,  // syscalls - XXX always 0
-        uv.traps,  // traps
-        uv.faults,  // faults
-        uv.forks  // forks
-    );
-}
diff --git a/psutil/arch/bsd/netbsd.h b/psutil/arch/bsd/netbsd.h
deleted file mode 100644
index 2c8edae674..0000000000
--- a/psutil/arch/bsd/netbsd.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
- * All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include <Python.h>
-
-typedef struct kinfo_proc2 kinfo_proc;
-
-int psutil_kinfo_proc(pid_t pid, kinfo_proc *proc);
-struct kinfo_file * kinfo_getfile(pid_t pid, int* cnt);
-int psutil_get_proc_list(kinfo_proc **procList, size_t *procCount);
-char *psutil_get_cmd_args(pid_t pid, size_t *argsize);
-PyObject * psutil_get_cmdline(pid_t pid);
-int psutil_pid_exists(pid_t pid);
-int psutil_raise_ad_or_nsp(long pid);
-
-//
-PyObject *psutil_proc_threads(PyObject *self, PyObject *args);
-PyObject *psutil_virtual_mem(PyObject *self, PyObject *args);
-PyObject *psutil_swap_mem(PyObject *self, PyObject *args);
-PyObject *psutil_proc_num_fds(PyObject *self, PyObject *args);
-PyObject *psutil_proc_connections(PyObject *self, PyObject *args);
-PyObject *psutil_per_cpu_times(PyObject *self, PyObject *args);
-PyObject* psutil_disk_io_counters(PyObject* self, PyObject* args);
-PyObject* psutil_proc_exe(PyObject* self, PyObject* args);
-PyObject* psutil_proc_num_threads(PyObject* self, PyObject* args);
-PyObject* psutil_cpu_stats(PyObject* self, PyObject* args);
diff --git a/psutil/arch/bsd/netbsd_socks.c b/psutil/arch/bsd/netbsd_socks.c
deleted file mode 100644
index 2acb7f807d..0000000000
--- a/psutil/arch/bsd/netbsd_socks.c
+++ /dev/null
@@ -1,542 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola'.
- * Copyright (c) 2015, Ryo ONODERA.
- * All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-#include <Python.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/sysctl.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <netinet/in.h>
-#include <string.h>
-#include <sys/cdefs.h>
-#include <arpa/inet.h>
-#include <sys/queue.h>
-#include <sys/un.h>
-#include <sys/file.h>
-
-// a signaler for connections without an actual status
-int PSUTIL_CONN_NONE = 128;
-
-// Address family filter
-enum af_filter {
-    INET,
-    INET4,
-    INET6,
-    TCP,
-    TCP4,
-    TCP6,
-    UDP,
-    UDP4,
-    UDP6,
-    UNIX,
-    ALL,
-};
-
-// kinfo_file results
-struct kif {
-    SLIST_ENTRY(kif) kifs;
-    struct kinfo_file *kif;
-};
-
-// kinfo_file results list
-SLIST_HEAD(kifhead, kif) kihead = SLIST_HEAD_INITIALIZER(kihead);
-
-
-// kinfo_pcb results
-struct kpcb {
-    SLIST_ENTRY(kpcb) kpcbs;
-    struct kinfo_pcb *kpcb;
-};
-
-// kinfo_pcb results list
-SLIST_HEAD(kpcbhead, kpcb) kpcbhead = SLIST_HEAD_INITIALIZER(kpcbhead);
-
-static void kiflist_init(void);
-static void kiflist_clear(void);
-static void kpcblist_init(void);
-static void kpcblist_clear(void);
-static int get_files(void);
-static int get_sockets(const char *name);
-static void get_info(int aff);
-
-// Initialize kinfo_file results list
-static void
-kiflist_init(void) {
-    SLIST_INIT(&kihead);
-    return;
-}
-
-// Clear kinfo_file results list
-static void
-kiflist_clear(void) {
-     while (!SLIST_EMPTY(&kihead)) {
-             SLIST_REMOVE_HEAD(&kihead, kifs);
-     }
-
-    return;
-}
-
-// Initialize kinof_pcb result list
-static void
-kpcblist_init(void) {
-    SLIST_INIT(&kpcbhead);
-    return;
-}
-
-// Clear kinof_pcb result list
-static void
-kpcblist_clear(void) {
-     while (!SLIST_EMPTY(&kpcbhead)) {
-             SLIST_REMOVE_HEAD(&kpcbhead, kpcbs);
-     }
-
-    return;
-}
-
-
-// Get all open files including socket
-static int
-get_files(void) {
-    size_t len;
-    int mib[6];
-    char *buf;
-    off_t offset;
-    int j;
-
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_FILE2;
-    mib[2] = KERN_FILE_BYFILE;
-    mib[3] = 0;
-    mib[4] = sizeof(struct kinfo_file);
-    mib[5] = 0;
-
-    if (sysctl(mib, 6, NULL, &len, NULL, 0) == -1)
-        return -1;
-    offset = len % sizeof(off_t);
-    mib[5] = len / sizeof(struct kinfo_file);
-    if ((buf = malloc(len + offset)) == NULL)
-        return -1;
-    if (sysctl(mib, 6, buf + offset, &len, NULL, 0) == -1) {
-        free(buf);
-        return -1;
-    }
-
-    len /= sizeof(struct kinfo_file);
-    struct kinfo_file *ki = (struct kinfo_file *)(buf + offset);
-
-    for (j = 0; j < len; j++) {
-        struct kif *kif = malloc(sizeof(struct kif));
-        kif->kif = &ki[j];
-        SLIST_INSERT_HEAD(&kihead, kif, kifs);
-    }
-
-#if 0
-    // debug
-    struct kif *k;
-    SLIST_FOREACH(k, &kihead, kifs) {
-            printf("%d\n", k->kif->ki_pid);
-    }
-#endif
-
-    return 0;
-}
-
-// Get open sockets
-static int
-get_sockets(const char *name) {
-    size_t namelen;
-    int mib[8];
-    int ret, j;
-    struct kinfo_pcb *pcb;
-    size_t len;
-
-    memset(mib, 0, sizeof(mib));
-
-    if (sysctlnametomib(name, mib, &namelen) == -1)
-        return -1;
-
-    if (sysctl(mib, __arraycount(mib), NULL, &len, NULL, 0) == -1)
-        return -1;
-
-    if ((pcb = malloc(len)) == NULL) {
-        return -1;
-    }
-    memset(pcb, 0, len);
-
-    mib[6] = sizeof(*pcb);
-    mib[7] = len / sizeof(*pcb);
-
-    if (sysctl(mib, __arraycount(mib), pcb, &len, NULL, 0) == -1) {
-        free(pcb);
-        return -1;
-    }
-
-    len /= sizeof(struct kinfo_pcb);
-    struct kinfo_pcb *kp = (struct kinfo_pcb *)pcb;
-
-    for (j = 0; j < len; j++) {
-        struct kpcb *kpcb = malloc(sizeof(struct kpcb));
-        kpcb->kpcb = &kp[j];
-        SLIST_INSERT_HEAD(&kpcbhead, kpcb, kpcbs);
-    }
-
-#if 0
-    // debug
-    struct kif *k;
-    struct kpcb *k;
-    SLIST_FOREACH(k, &kpcbhead, kpcbs) {
-            printf("ki_type: %d\n", k->kpcb->ki_type);
-            printf("ki_family: %d\n", k->kpcb->ki_family);
-    }
-#endif
-
-    return 0;
-}
-
-
-// Collect connections by PID
-PyObject *
-psutil_proc_connections(PyObject *self, PyObject *args) {
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_laddr = NULL;
-    PyObject *py_raddr = NULL;
-    pid_t pid;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-
-    kiflist_init();
-    kpcblist_init();
-    get_info(ALL);
-
-    struct kif *k;
-    SLIST_FOREACH(k, &kihead, kifs) {
-        struct kpcb *kp;
-        if (k->kif->ki_pid == pid) {
-        SLIST_FOREACH(kp, &kpcbhead, kpcbs) {
-            if (k->kif->ki_fdata == kp->kpcb->ki_sockaddr) {
-                pid_t pid;
-                int32_t fd;
-                int32_t family;
-                int32_t type;
-                char laddr[PATH_MAX];
-                int32_t lport;
-                char raddr[PATH_MAX];
-                int32_t rport;
-                int32_t status;
-
-                pid = k->kif->ki_pid;
-                fd = k->kif->ki_fd;
-                family = kp->kpcb->ki_family;
-                type = kp->kpcb->ki_type;
-
-                if (kp->kpcb->ki_family == AF_INET) {
-                    // IPv4
-                    struct sockaddr_in *sin_src =
-                        (struct sockaddr_in *)&kp->kpcb->ki_src;
-                    struct sockaddr_in *sin_dst =
-                        (struct sockaddr_in *)&kp->kpcb->ki_dst;
-                    // source addr
-                    if (inet_ntop(AF_INET, &sin_src->sin_addr, laddr,
-                        sizeof(laddr)) != NULL)
-                    lport = ntohs(sin_src->sin_port);
-                    py_laddr = Py_BuildValue("(si)", laddr, lport);
-                    if (!py_laddr)
-                        goto error;
-                    // remote addr
-                    if (inet_ntop(AF_INET, &sin_dst->sin_addr, raddr,
-                                  sizeof(raddr)) != NULL)
-                        rport = ntohs(sin_dst->sin_port);
-
-                    if (rport != 0)
-                        py_raddr = Py_BuildValue("(si)", raddr, rport);
-                    else
-                        py_raddr = Py_BuildValue("()");
-                    if (!py_raddr)
-                        goto error;
-                    // status
-                    if (kp->kpcb->ki_type == SOCK_STREAM)
-                        status = kp->kpcb->ki_tstate;
-                    else
-                        status = PSUTIL_CONN_NONE;
-                    // construct python tuple
-                    py_tuple = Py_BuildValue("(iiiNNi)", fd, AF_INET,
-                                type, py_laddr, py_raddr, status);
-                    if (!py_tuple)
-                        goto error;
-                    if (PyList_Append(py_retlist, py_tuple))
-                        goto error;
-                }
-                else if (kp->kpcb->ki_family == AF_INET6) {
-                    // IPv6
-                    struct sockaddr_in6 *sin6_src =
-                        (struct sockaddr_in6 *)&kp->kpcb->ki_src;
-                    struct sockaddr_in6 *sin6_dst =
-                        (struct sockaddr_in6 *)&kp->kpcb->ki_dst;
-                    // local addr
-                    if (inet_ntop(AF_INET6, &sin6_src->sin6_addr, laddr,
-                                  sizeof(laddr)) != NULL)
-                        lport = ntohs(sin6_src->sin6_port);
-                    py_laddr = Py_BuildValue("(si)", laddr, lport);
-                    if (!py_laddr)
-                        goto error;
-                    // remote addr
-                    if (inet_ntop(AF_INET6, &sin6_dst->sin6_addr, raddr,
-                        sizeof(raddr)) != NULL)
-                    rport = ntohs(sin6_dst->sin6_port);
-                    if (rport != 0)
-                        py_raddr = Py_BuildValue("(si)", raddr, rport);
-                    else
-                        py_raddr = Py_BuildValue("()");
-                    if (!py_raddr)
-                        goto error;
-                    // status
-                    if (kp->kpcb->ki_type == SOCK_STREAM)
-                        status = kp->kpcb->ki_tstate;
-                    else
-                        status = PSUTIL_CONN_NONE;
-                    // construct python tuple
-                    py_tuple = Py_BuildValue("(iiiNNi)", fd, AF_INET6,
-                                type, py_laddr, py_raddr, status);
-                    if (!py_tuple)
-                        goto error;
-                    if (PyList_Append(py_retlist, py_tuple))
-                        goto error;
-                }
-                else if (kp->kpcb->ki_family == AF_UNIX) {
-                    // UNIX sockets
-                    struct sockaddr_un *sun_src =
-                        (struct sockaddr_un *)&kp->kpcb->ki_src;
-                    struct sockaddr_un *sun_dst =
-                        (struct sockaddr_un *)&kp->kpcb->ki_dst;
-                    strcpy(laddr, sun_src->sun_path);
-                    strcpy(raddr, sun_dst->sun_path);
-                    status = PSUTIL_CONN_NONE;
-
-                    py_tuple = Py_BuildValue("(iiissi)", fd, AF_UNIX,
-                                type, laddr, raddr, status);
-                    if (!py_tuple)
-                        goto error;
-                    if (PyList_Append(py_retlist, py_tuple))
-                        goto error;
-                }
-            }
-        }}
-    }
-
-    kiflist_clear();
-    kpcblist_clear();
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_laddr);
-    Py_XDECREF(py_raddr);
-    return 0;
-}
-
-
-// Collect open file and connections
-static void
-get_info(int aff) {
-    get_files();
-
-    switch (aff) {
-        case INET:
-            get_sockets("net.inet.tcp.pcblist");
-            get_sockets("net.inet.udp.pcblist");
-            get_sockets("net.inet6.tcp6.pcblist");
-            get_sockets("net.inet6.udp6.pcblist");
-            break;
-        case INET4:
-            get_sockets("net.inet.tcp.pcblist");
-            get_sockets("net.inet.udp.pcblist");
-            break;
-        case INET6:
-            get_sockets("net.inet6.tcp6.pcblist");
-            get_sockets("net.inet6.udp6.pcblist");
-            break;
-        case TCP:
-            get_sockets("net.inet.tcp.pcblist");
-            get_sockets("net.inet6.tcp6.pcblist");
-            break;
-        case TCP4:
-            get_sockets("net.inet.tcp.pcblist");
-            break;
-        case TCP6:
-            get_sockets("net.inet6.tcp6.pcblist");
-            break;
-        case UDP:
-            get_sockets("net.inet.udp.pcblist");
-            get_sockets("net.inet6.udp6.pcblist");
-            break;
-        case UDP4:
-            get_sockets("net.inet.udp.pcblist");
-            break;
-        case UDP6:
-            get_sockets("net.inet6.udp6.pcblist");
-            break;
-        case UNIX:
-            get_sockets("net.local.stream.pcblist");
-            get_sockets("net.local.seqpacket.pcblist");
-            get_sockets("net.local.dgram.pcblist");
-            break;
-        case ALL:
-            get_sockets("net.inet.tcp.pcblist");
-            get_sockets("net.inet.udp.pcblist");
-            get_sockets("net.inet6.tcp6.pcblist");
-            get_sockets("net.inet6.udp6.pcblist");
-            get_sockets("net.local.stream.pcblist");
-            get_sockets("net.local.seqpacket.pcblist");
-            get_sockets("net.local.dgram.pcblist");
-            break;
-    }
-    return;
-}
-
-// Collect system wide connections by address family filter
-PyObject *
-psutil_net_connections(PyObject *self, PyObject *args) {
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_laddr = NULL;
-    PyObject *py_raddr = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-    kiflist_init();
-    kpcblist_init();
-    get_info(ALL);
-
-    struct kif *k;
-    SLIST_FOREACH(k, &kihead, kifs) {
-        struct kpcb *kp;
-        SLIST_FOREACH(kp, &kpcbhead, kpcbs) {
-            if (k->kif->ki_fdata == kp->kpcb->ki_sockaddr) {
-                pid_t pid;
-                int32_t fd;
-                int32_t family;
-                int32_t type;
-                char laddr[PATH_MAX];
-                int32_t lport;
-                char raddr[PATH_MAX];
-                int32_t rport;
-                int32_t status;
-
-                pid = k->kif->ki_pid;
-                fd = k->kif->ki_fd;
-                family = kp->kpcb->ki_family;
-                type = kp->kpcb->ki_type;
-                if (kp->kpcb->ki_family == AF_INET) {
-                    // IPv4
-                    struct sockaddr_in *sin_src =
-                        (struct sockaddr_in *)&kp->kpcb->ki_src;
-                    struct sockaddr_in *sin_dst =
-                        (struct sockaddr_in *)&kp->kpcb->ki_dst;
-                    // local addr
-                    if (inet_ntop(AF_INET, &sin_src->sin_addr, laddr,
-                                  sizeof(laddr)) != NULL)
-                        lport = ntohs(sin_src->sin_port);
-                    py_laddr = Py_BuildValue("(si)", laddr, lport);
-                    if (!py_laddr)
-                        goto error;
-                    // remote addr
-                    if (inet_ntop(AF_INET, &sin_dst->sin_addr, raddr,
-                                  sizeof(raddr)) != NULL)
-                        rport = ntohs(sin_dst->sin_port);
-                    if (rport != 0)
-                        py_raddr = Py_BuildValue("(si)", raddr, rport);
-                    else
-                        py_raddr = Py_BuildValue("()");
-                    if (!py_raddr)
-                        goto error;
-                    // status
-                    if (kp->kpcb->ki_type == SOCK_STREAM)
-                        status = kp->kpcb->ki_tstate;
-                    else
-                        status = PSUTIL_CONN_NONE;
-                    // construct python tuple
-                    py_tuple = Py_BuildValue("(iiiNNii)", fd, AF_INET,
-                                type, py_laddr, py_raddr, status, pid);
-                    if (!py_tuple)
-                        goto error;
-                    if (PyList_Append(py_retlist, py_tuple))
-                        goto error;
-                }
-                else if (kp->kpcb->ki_family == AF_INET6) {
-                    // IPv6
-                    struct sockaddr_in6 *sin6_src =
-                        (struct sockaddr_in6 *)&kp->kpcb->ki_src;
-                    struct sockaddr_in6 *sin6_dst =
-                        (struct sockaddr_in6 *)&kp->kpcb->ki_dst;
-                    // local addr
-                    if (inet_ntop(AF_INET6, &sin6_src->sin6_addr, laddr,
-                                  sizeof(laddr)) != NULL)
-                        lport = ntohs(sin6_src->sin6_port);
-                    py_laddr = Py_BuildValue("(si)", laddr, lport);
-                    if (!py_laddr)
-                        goto error;
-                    // remote addr
-                    if (inet_ntop(AF_INET6, &sin6_dst->sin6_addr, raddr,
-                                  sizeof(raddr)) != NULL)
-                        rport = ntohs(sin6_dst->sin6_port);
-                    if (rport != 0)
-                        py_raddr = Py_BuildValue("(si)", raddr, rport);
-                    else
-                        py_raddr = Py_BuildValue("()");
-                    if (!py_raddr)
-                        goto error;
-                    // status
-                    if (kp->kpcb->ki_type == SOCK_STREAM)
-                        status = kp->kpcb->ki_tstate;
-                    else
-                        status = PSUTIL_CONN_NONE;
-                    // construct python tuple
-                    py_tuple = Py_BuildValue("(iiiNNii)", fd, AF_INET6,
-                                type, py_laddr, py_raddr, status, pid);
-                    if (!py_tuple)
-                        goto error;
-                    if (PyList_Append(py_retlist, py_tuple))
-                        goto error;
-                }
-                else if (kp->kpcb->ki_family == AF_UNIX) {
-                    // UNIX sockets
-                    struct sockaddr_un *sun_src =
-                        (struct sockaddr_un *)&kp->kpcb->ki_src;
-                    struct sockaddr_un *sun_dst =
-                        (struct sockaddr_un *)&kp->kpcb->ki_dst;
-                    strcpy(laddr, sun_src->sun_path);
-                    strcpy(raddr, sun_dst->sun_path);
-                    status = PSUTIL_CONN_NONE;
-                    py_tuple = Py_BuildValue("(iiissii)", fd, AF_UNIX,
-                                type, laddr, raddr, status, pid);
-                    if (!py_tuple)
-                        goto error;
-                    if (PyList_Append(py_retlist, py_tuple))
-                        goto error;
-                }
-            }
-        }
-    }
-
-    kiflist_clear();
-    kpcblist_clear();
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_laddr);
-    Py_XDECREF(py_raddr);
-    return 0;
-}
diff --git a/psutil/arch/bsd/netbsd_socks.h b/psutil/arch/bsd/netbsd_socks.h
deleted file mode 100644
index 9e6a97c0a8..0000000000
--- a/psutil/arch/bsd/netbsd_socks.h
+++ /dev/null
@@ -1,10 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola'.
- * Copyright (c) 2015, Ryo ONODERA.
- * All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-PyObject *psutil_proc_connections(PyObject *, PyObject *);
-PyObject *psutil_net_connections(PyObject *, PyObject *);
diff --git a/psutil/arch/bsd/openbsd.c b/psutil/arch/bsd/openbsd.c
deleted file mode 100644
index 242045dc0d..0000000000
--- a/psutil/arch/bsd/openbsd.c
+++ /dev/null
@@ -1,823 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
- * All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Platform-specific module methods for OpenBSD.
- */
-
-#include <Python.h>
-#include <assert.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/param.h>
-#include <sys/sysctl.h>
-#include <sys/user.h>
-#include <sys/proc.h>
-#include <sys/mount.h>  // for VFS_*
-#include <sys/swap.h>  // for swap_mem
-#include <sys/vmmeter.h>  // for vmtotal struct
-#include <signal.h>
-#include <kvm.h>
-// connection stuff
-#include <netdb.h>  // for NI_MAXHOST
-#include <sys/socket.h>
-#include <sys/sched.h>  // for CPUSTATES & CP_*
-#define _KERNEL  // for DTYPE_*
-#include <sys/file.h>
-#undef _KERNEL
-#include <sys/disk.h>  // struct diskstats
-#include <arpa/inet.h> // for inet_ntoa()
-#include <err.h> // for warn() & err()
-
-
-#include "openbsd.h"
-#include "../../_psutil_common.h"
-
-#define PSUTIL_KPT2DOUBLE(t) (t ## _sec + t ## _usec / 1000000.0)
-// #define PSUTIL_TV2DOUBLE(t) ((t).tv_sec + (t).tv_usec / 1000000.0)
-
-// a signaler for connections without an actual status
-int PSUTIL_CONN_NONE = 128;
-
-
-// ============================================================================
-// Utility functions
-// ============================================================================
-
-int
-psutil_kinfo_proc(pid_t pid, struct kinfo_proc *proc) {
-    // Fills a kinfo_proc struct based on process pid.
-    int ret;
-    int mib[6];
-    size_t size = sizeof(struct kinfo_proc);
-
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC;
-    mib[2] = KERN_PROC_PID;
-    mib[3] = pid;
-    mib[4] = size;
-    mib[5] = 1;
-
-    ret = sysctl((int*)mib, 6, proc, &size, NULL, 0);
-    if (ret == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return -1;
-    }
-    // sysctl stores 0 in the size if we can't find the process information.
-    if (size == 0) {
-        NoSuchProcess();
-        return -1;
-    }
-    return 0;
-}
-
-
-struct kinfo_file *
-kinfo_getfile(long pid, int* cnt) {
-    // Mimic's FreeBSD kinfo_file call, taking a pid and a ptr to an
-    // int as arg and returns an array with cnt struct kinfo_file.
-    int mib[6];
-    size_t len;
-    struct kinfo_file* kf;
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_FILE;
-    mib[2] = KERN_FILE_BYPID;
-    mib[3] = (int) pid;
-    mib[4] = sizeof(struct kinfo_file);
-    mib[5] = 0;
-
-    /* get the size of what would be returned */
-    if (sysctl(mib, 6, NULL, &len, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-    if ((kf = malloc(len)) == NULL) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-    mib[5] = (int)(len / sizeof(struct kinfo_file));
-    if (sysctl(mib, 6, kf, &len, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    *cnt = (int)(len / sizeof(struct kinfo_file));
-    return kf;
-}
-
-
-int
-psutil_pid_exists(long pid) {
-    // Return 1 if PID exists in the current process list, else 0, -1
-    // on error.
-    // TODO: this should live in _psutil_posix.c but for some reason if I
-    // move it there I get a "include undefined symbol" error.
-    int ret;
-    if (pid < 0)
-        return 0;
-    ret = kill(pid , 0);
-    if (ret == 0)
-        return 1;
-    else {
-        if (ret == ESRCH)
-            return 0;
-        else if (ret == EPERM)
-            return 1;
-        else {
-            PyErr_SetFromErrno(PyExc_OSError);
-            return -1;
-        }
-    }
-}
-
-
-int
-psutil_raise_ad_or_nsp(long pid) {
-    // Set exception to AccessDenied if pid exists else NoSuchProcess.
-    if (psutil_pid_exists(pid) == 0)
-        NoSuchProcess();
-    else
-        AccessDenied();
-    return 0;
-}
-
-
-// ============================================================================
-// APIS
-// ============================================================================
-
-int
-psutil_get_proc_list(struct kinfo_proc **procList, size_t *procCount) {
-    // Returns a list of all BSD processes on the system.  This routine
-    // allocates the list and puts it in *procList and a count of the
-    // number of entries in *procCount.  You are responsible for freeing
-    // this list (use "free" from System framework).
-    // On success, the function returns 0.
-    // On error, the function returns a BSD errno value.
-    struct kinfo_proc *result;
-    // Declaring name as const requires us to cast it when passing it to
-    // sysctl because the prototype doesn't include the const modifier.
-    char errbuf[_POSIX2_LINE_MAX];
-    int cnt;
-    kvm_t *kd;
-
-    assert(procList != NULL);
-    assert(*procList == NULL);
-    assert(procCount != NULL);
-
-    kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);
-
-    if (kd == NULL) {
-        return errno;
-    }
-
-    result = kvm_getprocs(kd, KERN_PROC_ALL, 0, sizeof(struct kinfo_proc), &cnt);
-    if (result == NULL) {
-        kvm_close(kd);
-        err(1, NULL);
-        return errno;
-    }
-
-    *procCount = (size_t)cnt;
-
-    size_t mlen = cnt * sizeof(struct kinfo_proc);
-
-    if ((*procList = malloc(mlen)) == NULL) {
-        kvm_close(kd);
-        err(1, NULL);
-        return errno;
-    }
-
-    memcpy(*procList, result, mlen);
-    assert(*procList != NULL);
-    kvm_close(kd);
-
-    return 0;
-}
-
-
-char **
-_psutil_get_argv(long pid) {
-    static char **argv;
-    int argv_mib[] = {CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_ARGV};
-    size_t argv_size = 128;
-    /* Loop and reallocate until we have enough space to fit argv. */
-    for (;; argv_size *= 2) {
-        if ((argv = realloc(argv, argv_size)) == NULL)
-            err(1, NULL);
-        if (sysctl(argv_mib, 4, argv, &argv_size, NULL, 0) == 0)
-            return argv;
-        if (errno == ESRCH) {
-            PyErr_SetFromErrno(PyExc_OSError);
-            return NULL;
-        }
-        if (errno != ENOMEM)
-            err(1, NULL);
-    }
-}
-
-
-// returns the command line as a python list object
-PyObject *
-psutil_get_cmdline(long pid) {
-    static char **argv;
-    char **p;
-    PyObject *py_arg = NULL;
-    PyObject *py_retlist = Py_BuildValue("[]");
-
-    if (!py_retlist)
-        return NULL;
-    if (pid < 0)
-        return py_retlist;
-
-    if ((argv = _psutil_get_argv(pid)) == NULL)
-        goto error;
-
-    for (p = argv; *p != NULL; p++) {
-#if PY_MAJOR_VERSION >= 3
-        py_arg = PyUnicode_DecodeFSDefault(*p);
-#else
-        py_arg = Py_BuildValue("s", *p);
-#endif
-        if (!py_arg)
-            goto error;
-        if (PyList_Append(py_retlist, py_arg))
-            goto error;
-        Py_DECREF(py_arg);
-    }
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_arg);
-    Py_DECREF(py_retlist);
-    return NULL;
-}
-
-
-PyObject *
-psutil_proc_threads(PyObject *self, PyObject *args) {
-    // OpenBSD reference:
-    // https://github.com/janmojzis/pstree/blob/master/proc_kvm.c
-    // Note: this requires root access, else it will fail trying
-    // to access /dev/kmem.
-    long pid;
-    kvm_t *kd = NULL;
-    int nentries, i;
-    char errbuf[4096];
-    struct kinfo_proc *kp;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        goto error;
-
-    kd = kvm_openfiles(0, 0, 0, O_RDONLY, errbuf);
-    if (! kd) {
-        if (strstr(errbuf, "Permission denied") != NULL)
-            AccessDenied();
-        else
-            PyErr_Format(PyExc_RuntimeError, "kvm_openfiles() failed");
-        goto error;
-    }
-
-    kp = kvm_getprocs(
-        kd, KERN_PROC_PID | KERN_PROC_SHOW_THREADS | KERN_PROC_KTHREAD, pid,
-        sizeof(*kp), &nentries);
-    if (! kp) {
-        if (strstr(errbuf, "Permission denied") != NULL)
-            AccessDenied();
-        else
-            PyErr_Format(PyExc_RuntimeError, "kvm_getprocs() failed");
-        goto error;
-    }
-
-    for (i = 0; i < nentries; i++) {
-        if (kp[i].p_tid < 0)
-            continue;
-        if (kp[i].p_pid == pid) {
-            py_tuple = Py_BuildValue(
-                "Idd",
-                kp[i].p_tid,
-                PSUTIL_KPT2DOUBLE(kp[i].p_uutime),
-                PSUTIL_KPT2DOUBLE(kp[i].p_ustime));
-            if (py_tuple == NULL)
-                goto error;
-            if (PyList_Append(py_retlist, py_tuple))
-                goto error;
-            Py_DECREF(py_tuple);
-        }
-    }
-
-    kvm_close(kd);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_DECREF(py_retlist);
-    if (kd != NULL)
-        kvm_close(kd);
-    return NULL;
-}
-
-
-PyObject *
-psutil_virtual_mem(PyObject *self, PyObject *args) {
-    int64_t total_physmem;
-    int uvmexp_mib[] = {CTL_VM, VM_UVMEXP};
-    int bcstats_mib[] = {CTL_VFS, VFS_GENERIC, VFS_BCACHESTAT};
-    int physmem_mib[] = {CTL_HW, HW_PHYSMEM64};
-    int vmmeter_mib[] = {CTL_VM, VM_METER};
-    size_t size;
-    struct uvmexp uvmexp;
-    struct bcachestats bcstats;
-    struct vmtotal vmdata;
-    long pagesize = getpagesize();
-
-    size = sizeof(total_physmem);
-    if (sysctl(physmem_mib, 2, &total_physmem, &size, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    size = sizeof(uvmexp);
-    if (sysctl(uvmexp_mib, 2, &uvmexp, &size, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    size = sizeof(bcstats);
-    if (sysctl(bcstats_mib, 3, &bcstats, &size, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    size = sizeof(vmdata);
-    if (sysctl(vmmeter_mib, 2, &vmdata, &size, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    return Py_BuildValue("KKKKKKKK",
-        // Note: many programs calculate total memory as
-        // "uvmexp.npages * pagesize" but this is incorrect and does not
-        // match "sysctl | grep hw.physmem".
-        (unsigned long long) total_physmem,
-        (unsigned long long) uvmexp.free * pagesize,
-        (unsigned long long) uvmexp.active * pagesize,
-        (unsigned long long) uvmexp.inactive * pagesize,
-        (unsigned long long) uvmexp.wired * pagesize,
-        // this is how "top" determines it
-        (unsigned long long) bcstats.numbufpages * pagesize,  // cached
-        (unsigned long long) 0,  // buffers
-        (unsigned long long) vmdata.t_vmshr + vmdata.t_rmshr  // shared
-    );
-}
-
-
-PyObject *
-psutil_swap_mem(PyObject *self, PyObject *args) {
-    uint64_t swap_total, swap_free;
-    struct swapent *swdev;
-    int nswap, i;
-
-    if ((nswap = swapctl(SWAP_NSWAP, 0, 0)) == 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    if ((swdev = calloc(nswap, sizeof(*swdev))) == NULL) {
-        PyErr_NoMemory();
-        return NULL;
-    }
-
-    if (swapctl(SWAP_STATS, swdev, nswap) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    // Total things up.
-    swap_total = swap_free = 0;
-    for (i = 0; i < nswap; i++) {
-        if (swdev[i].se_flags & SWF_ENABLE) {
-            swap_free += (swdev[i].se_nblks - swdev[i].se_inuse);
-            swap_total += swdev[i].se_nblks;
-        }
-    }
-
-    free(swdev);
-    return Py_BuildValue("(LLLII)",
-                         swap_total * DEV_BSIZE,
-                         (swap_total - swap_free) * DEV_BSIZE,
-                         swap_free * DEV_BSIZE,
-                         // swap in / swap out is not supported as the
-                         // swapent struct does not provide any info
-                         // about it.
-                         0, 0);
-
-error:
-    free(swdev);
-    return NULL;
-}
-
-
-PyObject *
-psutil_proc_num_fds(PyObject *self, PyObject *args) {
-    long pid;
-    int cnt;
-
-    struct kinfo_file *freep;
-    struct kinfo_proc kipp;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kipp) == -1)
-        return NULL;
-
-    freep = kinfo_getfile(pid, &cnt);
-    if (freep == NULL) {
-        psutil_raise_ad_or_nsp(pid);
-        return NULL;
-    }
-    free(freep);
-
-    return Py_BuildValue("i", cnt);
-}
-
-
-PyObject *
-psutil_proc_cwd(PyObject *self, PyObject *args) {
-    // Reference:
-    // http://anoncvs.spacehopper.org/openbsd-src/tree/bin/ps/print.c#n179
-    long pid;
-    struct kinfo_proc kp;
-    char path[MAXPATHLEN];
-    size_t pathlen = sizeof path;
-
-    if (! PyArg_ParseTuple(args, "l", &pid))
-        return NULL;
-    if (psutil_kinfo_proc(pid, &kp) == -1)
-        return NULL;
-
-    int name[] = { CTL_KERN, KERN_PROC_CWD, pid };
-    if (sysctl(name, 3, path, &pathlen, NULL, 0) != 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-#if PY_MAJOR_VERSION >= 3
-    return PyUnicode_DecodeFSDefault(path);
-#else
-    return Py_BuildValue("s", path);
-#endif
-}
-
-
-// see sys/kern/kern_sysctl.c lines 1100 and
-// usr.bin/fstat/fstat.c print_inet_details()
-static char *
-psutil_convert_ipv4(int family, uint32_t addr[4]) {
-    struct in_addr a;
-    memcpy(&a, addr, sizeof(a));
-    return inet_ntoa(a);
-}
-
-
-static char *
-psutil_inet6_addrstr(struct in6_addr *p)
-{
-    struct sockaddr_in6 sin6;
-    static char hbuf[NI_MAXHOST];
-    const int niflags = NI_NUMERICHOST;
-
-    memset(&sin6, 0, sizeof(sin6));
-    sin6.sin6_family = AF_INET6;
-    sin6.sin6_len = sizeof(struct sockaddr_in6);
-    sin6.sin6_addr = *p;
-    if (IN6_IS_ADDR_LINKLOCAL(p) &&
-        *(u_int16_t *)&sin6.sin6_addr.s6_addr[2] != 0) {
-        sin6.sin6_scope_id =
-            ntohs(*(u_int16_t *)&sin6.sin6_addr.s6_addr[2]);
-        sin6.sin6_addr.s6_addr[2] = sin6.sin6_addr.s6_addr[3] = 0;
-    }
-
-    if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len,
-        hbuf, sizeof(hbuf), NULL, 0, niflags))
-        return "invalid";
-
-    return hbuf;
-}
-
-
-PyObject *
-psutil_proc_connections(PyObject *self, PyObject *args) {
-    long pid;
-    int i, cnt;
-
-    struct kinfo_file *freep = NULL;
-    struct kinfo_file *kif;
-    char *tcplist = NULL;
-
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_laddr = NULL;
-    PyObject *py_raddr = NULL;
-    PyObject *py_af_filter = NULL;
-    PyObject *py_type_filter = NULL;
-    PyObject *py_family = NULL;
-    PyObject *_type = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-    if (! PyArg_ParseTuple(args, "lOO", &pid, &py_af_filter, &py_type_filter))
-        goto error;
-    if (!PySequence_Check(py_af_filter) || !PySequence_Check(py_type_filter)) {
-        PyErr_SetString(PyExc_TypeError, "arg 2 or 3 is not a sequence");
-        goto error;
-    }
-
-    freep = kinfo_getfile(pid, &cnt);
-    if (freep == NULL) {
-        psutil_raise_ad_or_nsp(pid);
-        goto error;
-    }
-
-    for (i = 0; i < cnt; i++) {
-        int state;
-        int lport;
-        int rport;
-        char addrbuf[NI_MAXHOST + 2];
-        int inseq;
-        struct in6_addr laddr6;
-        py_tuple = NULL;
-        py_laddr = NULL;
-        py_raddr = NULL;
-
-        kif = &freep[i];
-        if (kif->f_type == DTYPE_SOCKET) {
-            // apply filters
-            py_family = PyLong_FromLong((long)kif->so_family);
-            inseq = PySequence_Contains(py_af_filter, py_family);
-            Py_DECREF(py_family);
-            if (inseq == 0)
-                continue;
-            _type = PyLong_FromLong((long)kif->so_type);
-            inseq = PySequence_Contains(py_type_filter, _type);
-            Py_DECREF(_type);
-            if (inseq == 0)
-                continue;
-
-            // IPv4 / IPv6 socket
-            if ((kif->so_family == AF_INET) || (kif->so_family == AF_INET6)) {
-                // fill status
-                if (kif->so_type == SOCK_STREAM)
-                    state = kif->t_state;
-                else
-                    state = PSUTIL_CONN_NONE;
-
-                // ports
-                lport = ntohs(kif->inp_lport);
-                rport = ntohs(kif->inp_fport);
-
-                // local address, IPv4
-                if (kif->so_family == AF_INET) {
-                    py_laddr = Py_BuildValue(
-                        "(si)",
-                        psutil_convert_ipv4(kif->so_family, kif->inp_laddru),
-                        lport);
-                    if (!py_laddr)
-                        goto error;
-                }
-                else {
-                    // local address, IPv6
-                    memcpy(&laddr6, kif->inp_laddru, sizeof(laddr6));
-                    snprintf(addrbuf, sizeof(addrbuf), "%s",
-                             psutil_inet6_addrstr(&laddr6));
-                    py_laddr = Py_BuildValue("(si)", addrbuf, lport);
-                    if (!py_laddr)
-                        goto error;
-                }
-
-                if (rport != 0) {
-                    // remote address, IPv4
-                    if (kif->so_family == AF_INET) {
-                        py_raddr = Py_BuildValue(
-                            "(si)",
-                            psutil_convert_ipv4(
-                                kif->so_family, kif->inp_faddru),
-                            rport);
-                    }
-                    else {
-                        // remote address, IPv6
-                        memcpy(&laddr6, kif->inp_faddru, sizeof(laddr6));
-                        snprintf(addrbuf, sizeof(addrbuf), "%s",
-                                 psutil_inet6_addrstr(&laddr6));
-                        py_raddr = Py_BuildValue("(si)", addrbuf, rport);
-                        if (!py_raddr)
-                            goto error;
-                    }
-                }
-                else {
-                    py_raddr = Py_BuildValue("()");
-                }
-
-                if (!py_raddr)
-                    goto error;
-                py_tuple = Py_BuildValue(
-                    "(iiiNNi)",
-                    kif->fd_fd,
-                    kif->so_family,
-                    kif->so_type,
-                    py_laddr,
-                    py_raddr,
-                    state);
-                if (!py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-            }
-            // UNIX socket
-            else if (kif->so_family == AF_UNIX) {
-                py_tuple = Py_BuildValue(
-                    "(iiisOi)",
-                    kif->fd_fd,
-                    kif->so_family,
-                    kif->so_type,
-                    kif->unp_path,
-                    Py_None,
-                    PSUTIL_CONN_NONE);
-                if (!py_tuple)
-                    goto error;
-                if (PyList_Append(py_retlist, py_tuple))
-                    goto error;
-                Py_DECREF(py_tuple);
-                Py_INCREF(Py_None);
-            }
-        }
-    }
-    free(freep);
-    free(tcplist);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_tuple);
-    Py_XDECREF(py_laddr);
-    Py_XDECREF(py_raddr);
-    Py_DECREF(py_retlist);
-    if (freep != NULL)
-        free(freep);
-    if (tcplist != NULL)
-        free(tcplist);
-    return NULL;
-}
-
-
-PyObject *
-psutil_per_cpu_times(PyObject *self, PyObject *args) {
-    int mib[3];
-    int ncpu;
-    size_t len;
-    size_t size;
-    int i;
-    PyObject *py_retlist = PyList_New(0);
-    PyObject *py_cputime = NULL;
-
-    if (py_retlist == NULL)
-        return NULL;
-
-
-    // retrieve the number of cpus
-    mib[0] = CTL_HW;
-    mib[1] = HW_NCPU;
-    len = sizeof(ncpu);
-    if (sysctl(mib, 2, &ncpu, &len, NULL, 0) == -1) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-    uint64_t cpu_time[CPUSTATES];
-
-    for (i = 0; i < ncpu; i++) {
-        // per-cpu info
-        mib[0] = CTL_KERN;
-        mib[1] = KERN_CPTIME2;
-        mib[2] = i;
-        size = sizeof(cpu_time);
-        if (sysctl(mib, 3, &cpu_time, &size, NULL, 0) == -1) {
-            warn("failed to get kern.cptime2");
-            PyErr_SetFromErrno(PyExc_OSError);
-            return NULL;
-        }
-
-        py_cputime = Py_BuildValue(
-            "(ddddd)",
-            (double)cpu_time[CP_USER] / CLOCKS_PER_SEC,
-            (double)cpu_time[CP_NICE] / CLOCKS_PER_SEC,
-            (double)cpu_time[CP_SYS] / CLOCKS_PER_SEC,
-            (double)cpu_time[CP_IDLE] / CLOCKS_PER_SEC,
-            (double)cpu_time[CP_INTR] / CLOCKS_PER_SEC);
-        if (!py_cputime)
-            goto error;
-        if (PyList_Append(py_retlist, py_cputime))
-            goto error;
-        Py_DECREF(py_cputime);
-    }
-
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_cputime);
-    Py_DECREF(py_retlist);
-    return NULL;
-}
-
-
-PyObject *
-psutil_disk_io_counters(PyObject *self, PyObject *args) {
-    int i, dk_ndrive, mib[3];
-    size_t len;
-    struct diskstats *stats;
-
-    PyObject *py_retdict = PyDict_New();
-    PyObject *py_disk_info = NULL;
-    if (py_retdict == NULL)
-        return NULL;
-
-    mib[0] = CTL_HW;
-    mib[1] = HW_DISKSTATS;
-    len = 0;
-    if (sysctl(mib, 2, NULL, &len, NULL, 0) < 0) {
-        warn("can't get hw.diskstats size");
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-    dk_ndrive = (int)(len / sizeof(struct diskstats));
-
-    stats = malloc(len);
-    if (stats == NULL) {
-        warn("can't malloc");
-        PyErr_NoMemory();
-        goto error;
-    }
-    if (sysctl(mib, 2, stats, &len, NULL, 0) < 0 ) {
-        warn("could not read hw.diskstats");
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    for (i = 0; i < dk_ndrive; i++) {
-        py_disk_info = Py_BuildValue(
-            "(KKKK)",
-            stats[i].ds_rxfer,  // num reads
-            stats[i].ds_wxfer,  // num writes
-            stats[i].ds_rbytes,  // read bytes
-            stats[i].ds_wbytes  // write bytes
-        );
-        if (!py_disk_info)
-            goto error;
-        if (PyDict_SetItemString(py_retdict, stats[i].ds_name, py_disk_info))
-            goto error;
-        Py_DECREF(py_disk_info);
-    }
-
-    free(stats);
-    return py_retdict;
-
-error:
-    Py_XDECREF(py_disk_info);
-    Py_DECREF(py_retdict);
-    if (stats != NULL)
-        free(stats);
-    return NULL;
-}
-
-
-PyObject *
-psutil_cpu_stats(PyObject *self, PyObject *args) {
-    size_t size;
-    struct uvmexp uv;
-    int uvmexp_mib[] = {CTL_VM, VM_UVMEXP};
-
-    size = sizeof(uv);
-    if (sysctl(uvmexp_mib, 2, &uv, &size, NULL, 0) < 0) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        return NULL;
-    }
-
-    return Py_BuildValue(
-        "IIIIIII",
-        uv.swtch,  // ctx switches
-        uv.intrs,  // interrupts - XXX always 0, will be determined via /proc
-        uv.softs,  // soft interrupts
-        uv.syscalls,  // syscalls - XXX always 0
-        uv.traps,  // traps
-        uv.faults,  // faults
-        uv.forks  // forks
-    );
-}
diff --git a/psutil/arch/bsd/openbsd.h b/psutil/arch/bsd/openbsd.h
deleted file mode 100644
index 923dfde189..0000000000
--- a/psutil/arch/bsd/openbsd.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
- * All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include <Python.h>
-
-typedef struct kinfo_proc kinfo_proc;
-
-int psutil_kinfo_proc(pid_t pid, struct kinfo_proc *proc);
-struct kinfo_file * kinfo_getfile(long pid, int* cnt);
-int psutil_get_proc_list(struct kinfo_proc **procList, size_t *procCount);
-char **_psutil_get_argv(long pid);
-PyObject * psutil_get_cmdline(long pid);
-int psutil_pid_exists(long pid);
-int psutil_raise_ad_or_nsp(long pid);
-
-//
-PyObject *psutil_proc_threads(PyObject *self, PyObject *args);
-PyObject *psutil_virtual_mem(PyObject *self, PyObject *args);
-PyObject *psutil_swap_mem(PyObject *self, PyObject *args);
-PyObject *psutil_proc_num_fds(PyObject *self, PyObject *args);
-PyObject *psutil_proc_cwd(PyObject *self, PyObject *args);
-PyObject *psutil_proc_connections(PyObject *self, PyObject *args);
-PyObject *psutil_per_cpu_times(PyObject *self, PyObject *args);
-PyObject* psutil_disk_io_counters(PyObject* self, PyObject* args);
-PyObject* psutil_cpu_stats(PyObject* self, PyObject* args);
diff --git a/psutil/arch/bsd/proc.c b/psutil/arch/bsd/proc.c
new file mode 100644
index 0000000000..2e26001eaa
--- /dev/null
+++ b/psutil/arch/bsd/proc.c
@@ -0,0 +1,490 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <kvm.h>
+#include <sys/param.h>
+#include <sys/proc.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
+#include <sys/file.h>
+#include <sys/vnode.h>
+#ifdef PSUTIL_FREEBSD
+#include <sys/user.h>
+#include <libutil.h>
+#endif
+
+#include "../../arch/all/init.h"
+
+
+#ifdef PSUTIL_FREEBSD
+#define KP(field) kp.ki_##field
+#define KP_RU(field) kp.ki_rusage.ru_##field
+#else
+#define KP(field) kp.p_##field
+#define KP_RU(field) kp.p_uru_##field
+#endif
+
+
+// Collect different info about a process in one shot and return them
+// as a Python dict.
+PyObject *
+psutil_proc_oneshot_kinfo(PyObject *self, PyObject *args) {
+    pid_t pid;
+    long rss;
+    long vms;
+    long memtext;
+    long memdata;
+    long memstack;
+    long peak_rss;
+    long ttynr;
+    int oncpu;
+    int status;
+    double create_time;
+    double user_time;
+    double sys_time;
+    double ch_user_time;
+    double ch_sys_time;
+#ifdef PSUTIL_NETBSD
+    struct kinfo_proc2 kp;
+#else
+    struct kinfo_proc kp;
+#endif
+    long pagesize = psutil_getpagesize();
+    char name_buf[256];  // buffer for process name
+    PyObject *py_name = NULL;
+    PyObject *dict = PyDict_New();
+
+    if (!dict)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+    if (psutil_kinfo_proc(pid, &kp) == -1)
+        goto error;
+
+        // Process name
+#ifdef PSUTIL_FREEBSD
+    str_format(name_buf, sizeof(name_buf), "%s", kp.ki_comm);
+#elif defined(PSUTIL_OPENBSD) || defined(PSUTIL_NETBSD)
+    str_format(name_buf, sizeof(name_buf), "%s", kp.p_comm);
+#endif
+    py_name = PyUnicode_DecodeFSDefault(name_buf);
+    if (!py_name) {
+        // If decoding fails, fall back to None safely
+        PyErr_Clear();
+        py_name = Py_None;
+        Py_INCREF(py_name);
+    }
+
+    // Calculate memory.
+#ifdef PSUTIL_FREEBSD
+    rss = (long)kp.ki_rssize * pagesize;
+    vms = (long)kp.ki_size;
+    memtext = (long)kp.ki_tsize * pagesize;
+    memdata = (long)kp.ki_dsize * pagesize;
+    memstack = (long)kp.ki_ssize * pagesize;
+    peak_rss = kp.ki_rusage.ru_maxrss * 1024;  // expressed in KB
+#else
+    rss = (long)kp.p_vm_rssize * pagesize;
+    peak_rss = kp.p_uru_maxrss * 1024;  // expressed in KB
+#ifdef PSUTIL_OPENBSD
+    // VMS, this is how ps determines it on OpenBSD:
+    // https://github.com/openbsd/src/blob/
+    //     588f7f8c69786211f2d16865c552afb91b1c7cba/bin/ps/print.c#L505
+    vms = (long)(kp.p_vm_dsize + kp.p_vm_ssize + kp.p_vm_tsize) * pagesize;
+#elif PSUTIL_NETBSD
+    // VMS, this is how top determines it on NetBSD:
+    // https://github.com/IIJ-NetBSD/netbsd-src/blob/master/external/
+    //     bsd/top/dist/machine/m_netbsd.c
+    vms = (long)kp.p_vm_msize * pagesize;
+#endif
+    memtext = (long)kp.p_vm_tsize * pagesize;
+    memdata = (long)kp.p_vm_dsize * pagesize;
+    memstack = (long)kp.p_vm_ssize * pagesize;
+#endif
+
+    // kernel doesn't always update peak_rss atomically, so rss can
+    // briefly exceed it. Difference is almost always 16KB. peak_rss is
+    // 0 for kernel/root PIDs: we leave it as-is so the caller knows it
+    // can't be relied upon.
+    if ((peak_rss < rss && peak_rss != 0)) {
+        psutil_debug(
+            "pid: %ld, ru_maxrss (%ld KB) < rss (%ld KB); using rss as "
+            "peak_rss",
+            (long)pid,
+            peak_rss / 1024,
+            rss / 1024
+        );
+        peak_rss = rss;  // use rss as peak_rss
+    }
+
+#ifdef PSUTIL_FREEBSD
+    create_time = PSUTIL_TV2DOUBLE(kp.ki_start);
+    user_time = PSUTIL_TV2DOUBLE(kp.ki_rusage.ru_utime);
+    sys_time = PSUTIL_TV2DOUBLE(kp.ki_rusage.ru_stime);
+    ch_user_time = PSUTIL_TV2DOUBLE(kp.ki_rusage_ch.ru_utime);
+    ch_sys_time = PSUTIL_TV2DOUBLE(kp.ki_rusage_ch.ru_stime);
+#else
+    create_time = PSUTIL_KPT2DOUBLE(kp.p_ustart);
+    user_time = PSUTIL_KPT2DOUBLE(kp.p_uutime);
+    sys_time = PSUTIL_KPT2DOUBLE(kp.p_ustime);
+    // OpenBSD and NetBSD provide children user + system times summed
+    // together (no distinction).
+    ch_user_time = PSUTIL_KPT2DOUBLE(kp.p_uctime);
+    ch_sys_time = ch_user_time;
+#endif
+
+#ifdef PSUTIL_FREEBSD
+    // what CPU we're on; top was used as an example:
+    // https://svnweb.freebsd.org/base/head/usr.bin/top/machine.c?
+    //     view=markup&pathrev=273835
+    // XXX - note: for "intr" PID this is -1.
+    if (kp.ki_stat == SRUN && kp.ki_oncpu != NOCPU)
+        oncpu = kp.ki_oncpu;
+    else
+        oncpu = kp.ki_lastcpu;
+#else
+    // On Net/OpenBSD we have kp.p_cpuid but it appears it's always
+    // set to KI_NOCPU. Even if it's not, ki_lastcpu does not exist
+    // so there's no way to determine where "sleeping" processes
+    // were. Not supported.
+    oncpu = -1;
+#endif
+
+#ifdef PSUTIL_NETBSD
+    // p_stat is the LWP status, except for a dying process, where it
+    // holds the process status instead. The 2 sets of values overlap
+    // (e.g. SDYING == LSSLEEP), so a process which is exiting would
+    // look like it's sleeping. Report all such states as zombie.
+    status = PSUTIL_KINFO_ZOMBIE(kp) ? LSZOMB : kp.p_stat;
+#else
+    status = KP(stat);
+#endif
+
+    // Controlling terminal, normalized to -1 when there's none.
+#ifdef PSUTIL_FREEBSD
+    ttynr = kp.ki_tdev == NODEV ? -1 : (long)kp.ki_tdev;
+#else
+    ttynr = kp.p_tdev == (uint32_t)NODEV ? -1 : (long)kp.p_tdev;
+#endif
+
+    // clang-format off
+    if (!pydict_add(dict, "ppid", _Py_PARSE_PID, KP(ppid))) goto error;
+    if (!pydict_add(dict, "status", "i", status)) goto error;
+    if (!pydict_add(dict, "real_uid", "l", (long)KP(ruid))) goto error;
+    if (!pydict_add(dict, "effective_uid", "l", (long)KP(uid))) goto error;
+    if (!pydict_add(dict, "saved_uid", "l", (long)KP(svuid))) goto error;
+    if (!pydict_add(dict, "real_gid", "l", (long)KP(rgid))) goto error;
+    if (!pydict_add(dict, "effective_gid", "l", (long)KP(groups)[0])) goto error;
+    if (!pydict_add(dict, "saved_gid", "l", (long)KP(svgid))) goto error;
+    if (!pydict_add(dict, "ttynr", "l", ttynr)) goto error;
+    if (!pydict_add(dict, "create_time", "d", create_time)) goto error;
+    if (!pydict_add(dict, "ctx_switches_vol", "l", (long)KP_RU(nvcsw))) goto error;
+    if (!pydict_add(dict, "ctx_switches_unvol", "l", (long)KP_RU(nivcsw))) goto error;
+    if (!pydict_add(dict, "read_io_count", "l", (long)KP_RU(inblock))) goto error;
+    if (!pydict_add(dict, "write_io_count", "l", (long)KP_RU(oublock))) goto error;
+    if (!pydict_add(dict, "user_time", "d", user_time)) goto error;
+    if (!pydict_add(dict, "sys_time", "d", sys_time)) goto error;
+    if (!pydict_add(dict, "ch_user_time", "d", ch_user_time)) goto error;
+    if (!pydict_add(dict, "ch_sys_time", "d", ch_sys_time)) goto error;
+    if (!pydict_add(dict, "min_faults", "l", (long)KP_RU(minflt))) goto error;
+    if (!pydict_add(dict, "maj_faults", "l", (long)KP_RU(majflt))) goto error;
+    if (!pydict_add(dict, "nice", "i", KP(nice) - NZERO)) goto error;
+    if (!pydict_add(dict, "rss", "l", rss)) goto error;
+    if (!pydict_add(dict, "vms", "l", vms)) goto error;
+    if (!pydict_add(dict, "memtext", "l", memtext)) goto error;
+    if (!pydict_add(dict, "memdata", "l", memdata)) goto error;
+    if (!pydict_add(dict, "memstack", "l", memstack)) goto error;
+    if (!pydict_add(dict, "peak_rss", "l", peak_rss)) goto error;
+    if (!pydict_add(dict, "cpunum", "i", oncpu)) goto error;
+    if (!pydict_add(dict, "name", "O", py_name)) goto error;
+    // clang-format on
+
+    Py_DECREF(py_name);
+    return dict;
+
+error:
+    Py_XDECREF(py_name);
+    Py_DECREF(dict);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_name(PyObject *self, PyObject *args) {
+    pid_t pid;
+#ifdef PSUTIL_NETBSD
+    struct kinfo_proc2 kp;
+#else
+    struct kinfo_proc kp;
+#endif
+    char str[1000];
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if (psutil_kinfo_proc(pid, &kp) == -1)
+        return NULL;
+
+#ifdef PSUTIL_FREEBSD
+    str_format(str, sizeof(str), "%s", kp.ki_comm);
+#elif defined(PSUTIL_OPENBSD) || defined(PSUTIL_NETBSD)
+    str_format(str, sizeof(str), "%s", kp.p_comm);
+#endif
+    return PyUnicode_DecodeFSDefault(str);
+}
+
+
+PyObject *
+psutil_proc_environ(PyObject *self, PyObject *args) {
+    int i, cnt = -1;
+    long pid;
+    char *s, **envs, errbuf[_POSIX2_LINE_MAX];
+    PyObject *py_value = NULL, *py_retdict = NULL;
+    kvm_t *kd;
+#ifdef PSUTIL_NETBSD
+    struct kinfo_proc2 *p;
+    struct kinfo_proc2 kp;
+#else
+    struct kinfo_proc *p;
+#endif
+#ifdef PSUTIL_OPENBSD
+    struct kinfo_proc kp;
+#endif
+
+    if (!PyArg_ParseTuple(args, "l", &pid))
+        return NULL;
+
+#if defined(PSUTIL_FREEBSD)
+    kd = kvm_openfiles(NULL, "/dev/null", NULL, 0, errbuf);
+#else
+    kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);
+#endif
+    if (!kd) {
+        convert_kvm_err("kvm_openfiles", errbuf);
+        return NULL;
+    }
+
+    py_retdict = PyDict_New();
+    if (!py_retdict)
+        goto error;
+
+#if defined(PSUTIL_FREEBSD)
+    p = kvm_getprocs(kd, KERN_PROC_PID, pid, &cnt);
+#elif defined(PSUTIL_OPENBSD)
+    p = kvm_getprocs(kd, KERN_PROC_PID, pid, sizeof(*p), &cnt);
+#elif defined(PSUTIL_NETBSD)
+    p = kvm_getproc2(kd, KERN_PROC_PID, pid, sizeof(*p), &cnt);
+#endif
+    if (!p) {
+        psutil_oserror_nsp("kvm_getprocs");
+        goto error;
+    }
+    if (cnt <= 0) {
+        psutil_oserror_nsp(cnt < 0 ? kvm_geterr(kd) : "kvm_getprocs: cnt==0");
+        goto error;
+    }
+
+    // A zombie has no environment.
+    if (PSUTIL_KINFO_ZOMBIE(*p)) {
+        PyErr_SetString(ZombieProcessError, "kvm_getprocs -> zombie");
+        goto error;
+    }
+
+    // On *BSD kernels there are a few kernel-only system processes without an
+    // environment (See e.g. "procstat -e 0 | 1 | 2 ..." on FreeBSD.)
+    // Some system process have no stats attached at all
+    // (they are marked with P_SYSTEM.)
+    // On FreeBSD, it's possible that the process is swapped or paged out,
+    // then there no access to the environ stored in the process' user area.
+    // To make unittest suite happy, return an empty environment.
+#if defined(PSUTIL_FREEBSD)
+    if (!((p)->ki_flag & P_INMEM) || ((p)->ki_flag & P_SYSTEM)) {
+        kvm_close(kd);
+        return py_retdict;
+    }
+#elif defined(PSUTIL_OPENBSD)
+    if ((p)->p_flag & P_SYSTEM) {
+        kvm_close(kd);
+        return py_retdict;
+    }
+#endif
+
+#if defined(PSUTIL_NETBSD)
+    envs = kvm_getenvv2(kd, p, 0);
+#else
+    envs = kvm_getenvv(kd, p, 0);
+#endif
+    if (!envs) {
+        // Map to "psutil" general high-level exceptions
+        switch (errno) {
+            case 0:
+                // Process has cleared it's environment, return empty one
+                kvm_close(kd);
+                return py_retdict;
+            case EPERM:
+                psutil_oserror_ad("kvm_getenvv -> EPERM");
+                break;
+            case ESRCH:
+                psutil_oserror_nsp("kvm_getenvv -> ESRCH");
+                break;
+#if defined(PSUTIL_NETBSD) || defined(PSUTIL_OPENBSD)
+            case EBUSY:
+                // An exec is in progress (NetBSD: p_reflock is write
+                // held; OpenBSD: PS_INEXEC is set).
+                psutil_debug(
+                    "proc %ld environ(): return empty dict due to EBUSY", pid
+                );
+                kvm_close(kd);
+                return py_retdict;
+            case EINVAL:
+            case EFAULT:
+                // The check above races. EINVAL: zombie, exiting or
+                // system proc. EFAULT: started exiting.
+                if (psutil_kinfo_proc(pid, &kp) == -1)
+                    goto error;  // reaped in the meantime, raises NSP
+                if (PSUTIL_KINFO_ZOMBIE(kp))
+                    PyErr_SetString(
+                        ZombieProcessError, "kvm_getenvv -> zombie"
+                    );
+                else
+                    psutil_oserror_wsyscall("kvm_getenvv");
+                break;
+#elif defined(PSUTIL_FREEBSD)
+            case ENOMEM:
+                // Unfortunately, under FreeBSD kvm_getenvv() returns
+                // failure for certain processes ( e.g. try
+                // "sudo procstat -e <pid of your XOrg server>".)
+                // Map the error condition to 'AccessDenied'.
+                str_format(
+                    errbuf,
+                    sizeof(errbuf),
+                    "kvm_getenvv(pid=%ld, ki_uid=%d) -> ENOMEM",
+                    pid,
+                    p->ki_uid
+                );
+                psutil_oserror_ad(errbuf);
+                break;
+#endif
+            default:
+                str_format(
+                    errbuf, sizeof(errbuf), "kvm_getenvv(pid=%ld)", pid
+                );
+                psutil_oserror_wsyscall(errbuf);
+                break;
+        }
+        goto error;
+    }
+
+    for (i = 0; envs[i] != NULL; i++) {
+        s = strchr(envs[i], '=');
+        if (!s)
+            continue;
+        *s++ = 0;
+        py_value = PyUnicode_DecodeFSDefault(s);
+        if (!py_value)
+            goto error;
+        if (PyDict_SetItemString(py_retdict, envs[i], py_value)) {
+            goto error;
+        }
+        Py_DECREF(py_value);
+    }
+
+    kvm_close(kd);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_value);
+    Py_XDECREF(py_retdict);
+    kvm_close(kd);
+    return NULL;
+}
+
+
+// Return files opened by process as a list of (path, fd) tuples.
+// TODO: this is broken as it may report empty paths. 'procstat'
+// utility has the same problem see:
+// https://github.com/giampaolo/psutil/issues/595
+PyObject *
+psutil_proc_open_files(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int i;
+    int cnt;
+    int regular;
+    int fd;
+    char *path;
+    struct kinfo_file *freep = NULL;
+    struct kinfo_file *kif;
+#ifdef PSUTIL_NETBSD
+    struct kinfo_proc2 kipp;
+#else
+    struct kinfo_proc kipp;
+#endif
+    PyObject *py_path = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+    if (psutil_kinfo_proc(pid, &kipp) == -1)
+        goto error;
+
+    errno = 0;
+    freep = kinfo_getfile(pid, &cnt);
+
+    if (freep == NULL) {
+#if defined(PSUTIL_OPENBSD)
+        if ((pid == 0) && (errno == ESRCH)) {
+            psutil_debug(
+                "open_files() returned ESRCH for PID 0; forcing `return []`"
+            );
+            PyErr_Clear();
+            return py_retlist;
+        }
+#else
+        psutil_raise_for_pid(pid, "kinfo_getfile()");
+#endif
+        goto error;
+    }
+
+    for (i = 0; i < cnt; i++) {
+        kif = &freep[i];
+
+#ifdef PSUTIL_FREEBSD
+        regular = (kif->kf_type == KF_TYPE_VNODE)
+                  && (kif->kf_vnode_type == KF_VTYPE_VREG);
+        fd = kif->kf_fd;
+        path = kif->kf_path;
+#elif PSUTIL_OPENBSD
+        regular = (kif->f_type == DTYPE_VNODE) && (kif->v_type == VREG);
+        fd = kif->fd_fd;
+        // struct kinfo_file has no path field (FreeBSD has kf_path).
+        path = "";
+#elif PSUTIL_NETBSD
+        regular = (kif->ki_ftype == DTYPE_VNODE) && (kif->ki_vtype == VREG);
+        fd = kif->ki_fd;
+        // struct kinfo_file has no path field (FreeBSD has kf_path).
+        path = "";
+#endif
+        if (regular == 1) {
+            py_path = PyUnicode_DecodeFSDefault(path);
+            if (!py_path)
+                goto error;
+            if (!pylist_append_fmt(py_retlist, "(Oi)", py_path, fd))
+                goto error;
+            Py_CLEAR(py_path);
+        }
+    }
+    free(freep);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_path);
+    Py_DECREF(py_retlist);
+    if (freep != NULL)
+        free(freep);
+    return NULL;
+}
diff --git a/psutil/arch/bsd/proc_utils.c b/psutil/arch/bsd/proc_utils.c
new file mode 100644
index 0000000000..bf4754528b
--- /dev/null
+++ b/psutil/arch/bsd/proc_utils.c
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/proc.h>
+#include <limits.h>
+#include <unistd.h>
+#ifdef PSUTIL_FREEBSD
+#include <sys/user.h>
+#endif
+
+#include "../../arch/all/init.h"
+
+
+// Fills a kinfo_proc or kinfo_proc2 struct based on process PID.
+int
+psutil_kinfo_proc(pid_t pid, void *proc) {
+#if defined(PSUTIL_FREEBSD)
+    size_t size = sizeof(struct kinfo_proc);
+    int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
+    int len = 4;
+#elif defined(PSUTIL_OPENBSD)
+    size_t size = sizeof(struct kinfo_proc);
+    int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid, (int)size, 1};
+    int len = 6;
+#elif defined(PSUTIL_NETBSD)
+    size_t size = sizeof(struct kinfo_proc2);
+    int mib[] = {CTL_KERN, KERN_PROC2, KERN_PROC_PID, pid, (int)size, 1};
+    int len = 6;
+#else
+#error "unsupported BSD variant"
+#endif
+
+    if (pid < 0 || proc == NULL)
+        return psutil_badargs("psutil_kinfo_proc");
+
+    if (sysctl(mib, len, proc, &size, NULL, 0) == -1) {
+        psutil_oserror_wsyscall("sysctl(kinfo_proc)");
+        return -1;
+    }
+
+    // sysctl stores 0 in size if the process doesn't exist.
+    if (size == 0) {
+        psutil_oserror_nsp("sysctl(kinfo_proc), size = 0");
+        return -1;
+    }
+
+    return 0;
+}
+
+
+// Mimic's FreeBSD kinfo_file call, taking a pid and a ptr to an
+// int as arg and returns an array with cnt struct kinfo_file.
+// Caller is responsible for freeing the returned pointer with free().
+#ifdef PSUTIL_HASNT_KINFO_GETFILE
+struct kinfo_file *
+kinfo_getfile(pid_t pid, int *cnt) {
+    if (pid < 0 || !cnt) {
+        psutil_badargs("kinfo_getfile");
+        return NULL;
+    }
+
+    int mib[6];
+    size_t len;
+    struct kinfo_file *kf = NULL;
+
+    mib[0] = CTL_KERN;
+#ifdef PSUTIL_NETBSD
+    mib[1] = KERN_FILE2;
+#else
+    mib[1] = KERN_FILE;
+#endif
+    mib[2] = KERN_FILE_BYPID;
+    mib[3] = pid;
+    mib[4] = sizeof(struct kinfo_file);
+    mib[5] = INT_MAX;
+
+    if (psutil_sysctl_malloc(mib, 6, (char **)&kf, &len) != 0) {
+        return NULL;
+    }
+
+    // Calculate number of entries and check for overflow
+    if (len / sizeof(struct kinfo_file) > INT_MAX) {
+        psutil_debug("exceeded INT_MAX");
+        free(kf);
+        errno = EOVERFLOW;
+        return NULL;
+    }
+
+    *cnt = (int)(len / sizeof(struct kinfo_file));
+    return kf;
+}
+#endif  // PSUTIL_HASNT_KINFO_GETFILE
+
+
+int
+is_zombie(size_t pid) {
+#ifdef PSUTIL_NETBSD
+    struct kinfo_proc2 kp;
+#else
+    struct kinfo_proc kp;
+#endif
+    if (psutil_kinfo_proc(pid, &kp) == -1) {
+        errno = 0;
+        PyErr_Clear();
+        return 0;
+    }
+
+    return PSUTIL_KINFO_ZOMBIE(kp);
+}
diff --git a/psutil/arch/bsd/sys.c b/psutil/arch/bsd/sys.c
new file mode 100644
index 0000000000..8205dd2af5
--- /dev/null
+++ b/psutil/arch/bsd/sys.c
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysctl.h>
+
+#include "../../arch/all/init.h"
+
+
+// Return a Python float indicating the system boot time expressed in
+// seconds since the epoch.
+PyObject *
+psutil_boot_time(PyObject *self, PyObject *args) {
+    // fetch sysctl "kern.boottime"
+    static int request[2] = {CTL_KERN, KERN_BOOTTIME};
+    struct timeval boottime;
+
+    if (psutil_sysctl(request, 2, &boottime, sizeof(boottime)) != 0)
+        return NULL;
+    return Py_BuildValue("d", (double)boottime.tv_sec);
+}
diff --git a/psutil/arch/freebsd/cpu.c b/psutil/arch/freebsd/cpu.c
new file mode 100644
index 0000000000..84b879aa1f
--- /dev/null
+++ b/psutil/arch/freebsd/cpu.c
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// System-wide CPU related functions.
+// Original code was refactored and moved from psutil/arch/freebsd/specific.c
+// in 2020 (and was moved in there previously already) from cset
+// a4c0a0eb0d2a872ab7a45e47fcf37ef1fde5b012.
+// For reference, here's the git history with original(ish) implementations:
+// - CPU stats: fb0154ef164d0e5942ac85102ab660b8d2938fbb
+// - CPU freq: 459556dd1e2979cdee22177339ced0761caf4c83
+// - CPU cores: e0d6d7865df84dc9a1d123ae452fd311f79b1dde
+
+#include <Python.h>
+#include <sys/sysctl.h>
+#include <devstat.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_per_cpu_times(PyObject *self, PyObject *args) {
+    int maxcpus;
+    int mib[2];
+    int ncpu;
+    size_t size;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    // retrieve the number of CPUs currently online
+    mib[0] = CTL_HW;
+    mib[1] = HW_NCPU;
+    if (psutil_sysctl(mib, 2, &ncpu, sizeof(ncpu)) != 0) {
+        goto error;
+    }
+
+    // allocate buffer dynamically based on actual CPU count
+    long(*cpu_time)[CPUSTATES] = malloc(ncpu * sizeof(*cpu_time));
+    if (!cpu_time) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    // get per-cpu times using ncpu count
+    size = ncpu * sizeof(*cpu_time);
+    if (psutil_sysctlbyname("kern.cp_times", cpu_time, size) == -1) {
+        free(cpu_time);
+        goto error;
+    }
+
+    for (int i = 0; i < ncpu; i++) {
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(ddddd)",
+                (double)cpu_time[i][CP_USER] / CLOCKS_PER_SEC,
+                (double)cpu_time[i][CP_NICE] / CLOCKS_PER_SEC,
+                (double)cpu_time[i][CP_SYS] / CLOCKS_PER_SEC,
+                (double)cpu_time[i][CP_IDLE] / CLOCKS_PER_SEC,
+                (double)cpu_time[i][CP_INTR] / CLOCKS_PER_SEC
+            ))
+        {
+            free(cpu_time);
+            goto error;
+        }
+    }
+
+    free(cpu_time);
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    return NULL;
+}
+
+
+PyObject *
+psutil_cpu_count_cores(PyObject *self, PyObject *args) {
+    int num;
+
+    if (psutil_sysctlbyname("kern.smp.cores", &num, sizeof(num)) != 0)
+        Py_RETURN_NONE;
+    return Py_BuildValue("i", num);
+}
+
+
+PyObject *
+psutil_cpu_stats(PyObject *self, PyObject *args) {
+    unsigned int v_soft;
+    unsigned int v_intr;
+    unsigned int v_syscall;
+    unsigned int v_trap;
+    unsigned int v_swtch;
+    size_t size = sizeof(v_soft);
+
+    if (psutil_sysctlbyname("vm.stats.sys.v_soft", &v_soft, size) != 0)
+        return NULL;
+    if (psutil_sysctlbyname("vm.stats.sys.v_intr", &v_intr, size) != 0)
+        return NULL;
+    if (psutil_sysctlbyname("vm.stats.sys.v_syscall", &v_syscall, size) != 0)
+        return NULL;
+    if (psutil_sysctlbyname("vm.stats.sys.v_trap", &v_trap, size) != 0)
+        return NULL;
+    if (psutil_sysctlbyname("vm.stats.sys.v_swtch", &v_swtch, size) != 0)
+        return NULL;
+
+    return Py_BuildValue(
+        "IIIII",
+        v_swtch,  // ctx switches
+        v_intr,  // interrupts
+        v_soft,  // software interrupts
+        v_syscall,  // syscalls
+        v_trap  // traps
+    );
+}
+
+
+// Return frequency information of a given CPU. As of Dec 2018 only CPU
+// 0 appears to be supported and all other cores match the frequency of
+// CPU 0.
+PyObject *
+psutil_cpu_freq(PyObject *self, PyObject *args) {
+    int current;
+    int core;
+    char sensor[26];
+    char available_freq_levels[1000] = {0};
+    size_t size;
+    PyObject *py_freq_levels;
+    PyObject *py_retlist;
+
+    if (!PyArg_ParseTuple(args, "i", &core))
+        return NULL;
+
+    // https://www.unix.com/man-page/FreeBSD/4/cpufreq/
+    size = sizeof(current);
+    str_format(sensor, sizeof(sensor), "dev.cpu.%d.freq", core);
+    if (psutil_sysctlbyname(sensor, &current, size) != 0)
+        goto error;
+
+    // In case of failure, an empty string is returned.
+    size = sizeof(available_freq_levels);
+    str_format(sensor, sizeof(sensor), "dev.cpu.%d.freq_levels", core);
+    if (psutil_sysctlbyname(sensor, &available_freq_levels, size) != 0)
+        psutil_debug("cpu freq levels failed (ignored)");
+
+    py_freq_levels = PyUnicode_DecodeFSDefault(available_freq_levels);
+    if (py_freq_levels == NULL)
+        return NULL;
+    py_retlist = Py_BuildValue("iO", current, py_freq_levels);
+    Py_DECREF(py_freq_levels);
+    return py_retlist;
+
+error:
+    if (errno == ENOENT)
+        PyErr_SetString(PyExc_NotImplementedError, "unable to read frequency");
+    else
+        psutil_oserror();
+    return NULL;
+}
diff --git a/psutil/arch/freebsd/disk.c b/psutil/arch/freebsd/disk.c
new file mode 100644
index 0000000000..1f3b7c06cc
--- /dev/null
+++ b/psutil/arch/freebsd/disk.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <devstat.h>
+
+#include "../../arch/all/init.h"
+
+
+// convert a bintime struct to milliseconds
+#define PSUTIL_BT2MSEC(bt) \
+    (bt.sec * 1000         \
+     + (((uint64_t)1000000000 * (uint32_t)(bt.frac >> 32)) >> 32) / 1000000)
+
+
+PyObject *
+psutil_disk_io_counters(PyObject *self, PyObject *args) {
+    int i;
+    int ret;
+    struct statinfo stats;
+
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_disk_info = NULL;
+
+    if (py_retdict == NULL)
+        return NULL;
+    Py_BEGIN_ALLOW_THREADS
+    ret = devstat_checkversion(NULL);
+    Py_END_ALLOW_THREADS
+    if (ret < 0) {
+        psutil_runtime_error("devstat_checkversion() syscall failed");
+        goto error;
+    }
+
+    stats.dinfo = (struct devinfo *)malloc(sizeof(struct devinfo));
+    if (stats.dinfo == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+    bzero(stats.dinfo, sizeof(struct devinfo));
+
+    Py_BEGIN_ALLOW_THREADS
+    ret = devstat_getdevs(NULL, &stats);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_runtime_error("devstat_getdevs() syscall failed");
+        goto error;
+    }
+
+    for (i = 0; i < stats.dinfo->numdevs; i++) {
+        py_disk_info = NULL;
+        struct devstat current;
+        char disk_name[128];
+        current = stats.dinfo->devices[i];
+        str_format(
+            disk_name,
+            sizeof(disk_name),
+            "%s%d",
+            current.device_name,
+            current.unit_number
+        );
+
+        py_disk_info = Py_BuildValue(
+            "(KKKKLLL)",
+            current.operations[DEVSTAT_READ],  // no reads
+            current.operations[DEVSTAT_WRITE],  // no writes
+            current.bytes[DEVSTAT_READ],  // bytes read
+            current.bytes[DEVSTAT_WRITE],  // bytes written
+            (long long)PSUTIL_BT2MSEC(current.duration[DEVSTAT_READ]
+            ),  // r time
+            (long long)PSUTIL_BT2MSEC(current.duration[DEVSTAT_WRITE]
+            ),  // w time
+            (long long)PSUTIL_BT2MSEC(current.busy_time)  // busy time
+        );  // finished transactions
+        if (!py_disk_info)
+            goto error;
+        if (PyDict_SetItemString(py_retdict, disk_name, py_disk_info))
+            goto error;
+        Py_DECREF(py_disk_info);
+    }
+
+    if (stats.dinfo->mem_ptr)
+        free(stats.dinfo->mem_ptr);
+    free(stats.dinfo);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_disk_info);
+    Py_DECREF(py_retdict);
+    if (stats.dinfo != NULL)
+        free(stats.dinfo);
+    return NULL;
+}
diff --git a/psutil/arch/freebsd/init.h b/psutil/arch/freebsd/init.h
new file mode 100644
index 0000000000..7ecb8790c3
--- /dev/null
+++ b/psutil/arch/freebsd/init.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Jay Loden.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/types.h>
+
+int _psutil_pids(pid_t **pids_array, int *pids_count);
+
+PyObject *psutil_cpu_count_cores(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_freq(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_stats(PyObject *self, PyObject *args);
+PyObject *psutil_disk_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_net_connections(PyObject *self, PyObject *args);
+PyObject *psutil_per_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cmdline(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cpu_affinity_get(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cpu_affinity_set(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cwd(PyObject *self, PyObject *args);
+PyObject *psutil_proc_exe(PyObject *self, PyObject *args);
+PyObject *psutil_proc_getrlimit(PyObject *self, PyObject *args);
+PyObject *psutil_proc_memory_maps(PyObject *self, PyObject *args);
+PyObject *psutil_proc_net_connections(PyObject *self, PyObject *args);
+PyObject *psutil_proc_num_fds(PyObject *self, PyObject *args);
+PyObject *psutil_proc_num_threads(PyObject *self, PyObject *args);
+PyObject *psutil_proc_setrlimit(PyObject *self, PyObject *args);
+PyObject *psutil_proc_threads(PyObject *self, PyObject *args);
+PyObject *psutil_sensors_battery(PyObject *self, PyObject *args);
+PyObject *psutil_sensors_cpu_temperature(PyObject *self, PyObject *args);
+PyObject *psutil_swap_mem(PyObject *self, PyObject *args);
+PyObject *psutil_virtual_mem(PyObject *self, PyObject *args);
diff --git a/psutil/arch/freebsd/mem.c b/psutil/arch/freebsd/mem.c
new file mode 100644
index 0000000000..ac3a234db7
--- /dev/null
+++ b/psutil/arch/freebsd/mem.c
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <kvm.h>
+#include <sys/sysctl.h>
+#include <sys/vmmeter.h>
+#include <vm/vm_param.h>
+#include <paths.h>
+#include <fcntl.h>
+
+#include "../../arch/all/init.h"
+
+#ifndef _PATH_DEVNULL
+#define _PATH_DEVNULL "/dev/null"
+#endif
+
+
+// shorter alias for psutil_sysctlbyname()
+static inline int
+sbn(const char *name, void *oldp, size_t oldlen) {
+    return psutil_sysctlbyname(name, oldp, oldlen);
+}
+
+
+PyObject *
+psutil_virtual_mem(PyObject *self, PyObject *args) {
+    unsigned long _total;
+    long _buffers;
+    unsigned int _active, _inactive, _wired, _cached, _free;
+    unsigned long long total, buffers, active, inactive, wired, cached, free;
+    unsigned long long avail, used, shared;
+    double percent;
+    struct vmtotal vm;
+    int mib[] = {CTL_VM, VM_METER};
+    long pagesize = psutil_getpagesize();
+    PyObject *dict = PyDict_New();
+
+    if (dict == NULL)
+        return NULL;
+
+    if (sbn("hw.physmem", &_total, sizeof(_total)) != 0)
+        goto error;
+    if (sbn("vm.stats.vm.v_active_count", &_active, sizeof(_active)) != 0)
+        goto error;
+    if (sbn("vm.stats.vm.v_inactive_count", &_inactive, sizeof(_inactive))
+        != 0)
+        goto error;
+    if (sbn("vm.stats.vm.v_wire_count", &_wired, sizeof(_wired)) != 0)
+        goto error;
+    if (sbn("vm.stats.vm.v_free_count", &_free, sizeof(_free)) != 0)
+        goto error;
+    if (sbn("vfs.bufspace", &_buffers, sizeof(_buffers)) != 0)
+        goto error;
+
+    // Optional; ignore error if not avail
+    if (sbn("vm.stats.vm.v_cache_count", &_cached, sizeof(_cached)) != 0) {
+        PyErr_Clear();
+        _cached = 0;
+    }
+
+    if (psutil_sysctl(mib, 2, &vm, sizeof(vm)) != 0)
+        goto error;
+
+    total = (unsigned long long)_total;
+    buffers = (unsigned long long)_buffers;
+    free = (unsigned long long)_free * pagesize;
+    active = (unsigned long long)_active * pagesize;
+    inactive = (unsigned long long)_inactive * pagesize;
+    wired = (unsigned long long)_wired * pagesize;
+    cached = (unsigned long long)_cached * pagesize;
+    shared = (unsigned long long)(vm.t_vmshr + vm.t_rmshr) * pagesize;
+
+    // matches freebsd-memory CLI:
+    // * https://people.freebsd.org/~rse/dist/freebsd-memory
+    // * https://www.cyberciti.biz/files/scripts/freebsd-memory.pl.txt
+    // matches zabbix:
+    // * https://github.com/zabbix/zabbix/blob/af5e0f8/src/libs/zbxsysinfo/freebsd/memory.c#L143
+    avail = (inactive + cached + free);
+    used = (active + wired + cached);
+    percent = psutil_usage_percent((double)(total - avail), (double)total, 1);
+
+    if (!(pydict_add(dict, "total", "K", total)
+          | pydict_add(dict, "available", "K", avail)
+          | pydict_add(dict, "percent", "d", percent)
+          | pydict_add(dict, "used", "K", used)
+          | pydict_add(dict, "free", "K", free)
+          | pydict_add(dict, "active", "K", active)
+          | pydict_add(dict, "inactive", "K", inactive)
+          | pydict_add(dict, "buffers", "K", buffers)
+          | pydict_add(dict, "cached", "K", cached)
+          | pydict_add(dict, "shared", "K", shared)
+          | pydict_add(dict, "wired", "K", wired)))
+        goto error;
+
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    return NULL;
+}
+
+
+PyObject *
+psutil_swap_mem(PyObject *self, PyObject *args) {
+    // Return swap memory stats (see 'swapinfo' cmdline tool)
+    kvm_t *kd;
+    struct kvm_swap kvmsw[1];
+    unsigned long long total, used, free;
+    unsigned int swapin, swapout, nodein, nodeout;
+    long pagesize = psutil_getpagesize();
+    double percent;
+    PyObject *dict = PyDict_New();
+
+    if (dict == NULL)
+        return NULL;
+
+    kd = kvm_open(NULL, _PATH_DEVNULL, NULL, O_RDONLY, "kvm_open failed");
+    if (kd == NULL) {
+        psutil_runtime_error("kvm_open() syscall failed");
+        goto error;
+    }
+
+    if (kvm_getswapinfo(kd, kvmsw, 1, 0) < 0) {
+        kvm_close(kd);
+        psutil_runtime_error("kvm_getswapinfo() syscall failed");
+        goto error;
+    }
+
+    kvm_close(kd);
+
+    if (sbn("vm.stats.vm.v_swapin", &swapin, sizeof(swapin)) != 0)
+        goto error;
+    if (sbn("vm.stats.vm.v_swapout", &swapout, sizeof(swapout)) != 0)
+        goto error;
+    if (sbn("vm.stats.vm.v_vnodein", &nodein, sizeof(nodein)) != 0)
+        goto error;
+    if (sbn("vm.stats.vm.v_vnodeout", &nodeout, sizeof(nodeout)) != 0)
+        goto error;
+
+    total = (unsigned long long)kvmsw[0].ksw_total * pagesize;
+    used = (unsigned long long)kvmsw[0].ksw_used * pagesize;
+    free = (unsigned long long)(kvmsw[0].ksw_total - kvmsw[0].ksw_used)
+           * pagesize;
+    percent = psutil_usage_percent((double)used, (double)total, 1);
+
+    if (!(pydict_add(dict, "total", "K", total)
+          | pydict_add(dict, "used", "K", used)
+          | pydict_add(dict, "free", "K", free)
+          | pydict_add(dict, "percent", "d", percent)
+          | pydict_add(dict, "sin", "I", swapin + swapout)
+          | pydict_add(dict, "sout", "I", nodein + nodeout)))
+        goto error;
+
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    return NULL;
+}
diff --git a/psutil/arch/freebsd/pids.c b/psutil/arch/freebsd/pids.c
new file mode 100644
index 0000000000..051eb66b87
--- /dev/null
+++ b/psutil/arch/freebsd/pids.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/user.h>
+
+#include "../../arch/all/init.h"
+
+
+int
+_psutil_pids(pid_t **pids_array, int *pids_count) {
+    int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PROC, 0};
+    size_t len = 0;
+    char *buf = NULL;
+    struct kinfo_proc *proc_list = NULL;
+    size_t num_procs = 0;
+
+    *pids_array = NULL;
+    *pids_count = 0;
+
+    if (psutil_sysctl_malloc(mib, 4, &buf, &len) != 0)
+        return -1;
+
+    if (len == 0) {
+        psutil_runtime_error("no PIDs found");
+        goto error;
+    }
+
+    proc_list = (struct kinfo_proc *)buf;
+    num_procs = len / sizeof(struct kinfo_proc);
+
+    *pids_array = malloc(num_procs * sizeof(pid_t));
+    if (!*pids_array) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    for (size_t i = 0; i < num_procs; i++) {
+        (*pids_array)[i] = proc_list[i].ki_pid;  // FreeBSD PID field
+    }
+
+    *pids_count = (int)num_procs;
+    free(buf);
+    return 0;
+
+error:
+    if (buf != NULL)
+        free(buf);
+    return -1;
+}
diff --git a/psutil/arch/freebsd/proc.c b/psutil/arch/freebsd/proc.c
new file mode 100644
index 0000000000..236f4a329b
--- /dev/null
+++ b/psutil/arch/freebsd/proc.c
@@ -0,0 +1,557 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/cpuset.h>
+#include <sys/sysctl.h>
+#include <sys/user.h>
+#include <libutil.h>
+
+#include "../../arch/all/init.h"
+
+
+// remove spaces from string
+static void
+psutil_remove_spaces(char *str) {
+    char *p1 = str;
+    char *p2 = str;
+    do
+        while (*p2 == ' ')
+            p2++;
+    while ((*p1++ = *p2++));
+}
+
+
+PyObject *
+psutil_proc_cmdline(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int mib[4];
+    char *procargs = NULL;
+    size_t size = 0;
+    size_t pos = 0;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_ARGS;
+    mib[3] = pid;
+
+    if (psutil_sysctl_malloc(mib, 4, &procargs, &size) != 0)
+        goto error;
+
+    // args are returned as a flattened string with \0 separators between
+    // arguments add each string to the list then step forward to the next
+    // separator
+    if (size > 0) {
+        while (pos < size) {
+            if (!pylist_append_obj(
+                    py_retlist, PyUnicode_DecodeFSDefault(&procargs[pos])
+                ))
+                goto error;
+            pos += strlen(&procargs[pos]) + 1;
+        }
+    }
+
+    free(procargs);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_retlist);
+    if (procargs != NULL)
+        free(procargs);
+    return NULL;
+}
+
+
+// Return process pathname executable. Thanks to Robert N. M. Watson:
+// http://fxr.googlebit.com/source/usr.bin/procstat/procstat_bin.c?v=8-CURRENT
+PyObject *
+psutil_proc_exe(PyObject *self, PyObject *args) {
+    pid_t pid;
+    char pathname[PATH_MAX];
+    int error;
+    int mib[4];
+    int ret;
+    size_t size;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_PATHNAME;
+    mib[3] = pid;
+
+    size = sizeof(pathname);
+    error = sysctl(mib, 4, pathname, &size, NULL, 0);
+    if (error == -1) {
+        // see: https://github.com/giampaolo/psutil/issues/907
+        if (errno == ENOENT) {
+            return PyUnicode_DecodeFSDefault("");
+        }
+        else {
+            return psutil_oserror_wsyscall("sysctl(KERN_PROC_PATHNAME)");
+        }
+    }
+    if (size == 0 || strlen(pathname) == 0) {
+        ret = psutil_pid_exists(pid);
+        if (ret == -1) {
+            psutil_oserror();
+            return NULL;
+        }
+        else if (ret == 0)
+            return psutil_oserror_nsp("psutil_pid_exists -> 0");
+        else
+            str_copy(pathname, sizeof(pathname), "");
+    }
+
+    return PyUnicode_DecodeFSDefault(pathname);
+}
+
+
+PyObject *
+psutil_proc_num_threads(PyObject *self, PyObject *args) {
+    // Return number of threads used by process as a Python integer.
+    pid_t pid;
+    struct kinfo_proc kp;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if (psutil_kinfo_proc(pid, &kp) == -1)
+        return NULL;
+    return Py_BuildValue("l", (long)kp.ki_numthreads);
+}
+
+
+PyObject *
+psutil_proc_threads(PyObject *self, PyObject *args) {
+    // Retrieves all threads used by process returning a list of tuples
+    // including thread id, user time and system time.
+    // Thanks to Robert N. M. Watson:
+    // http://code.metager.de/source/xref/freebsd/usr.bin/procstat/procstat_threads.c
+    pid_t pid;
+    int mib[4];
+    struct kinfo_proc *kip = NULL;
+    struct kinfo_proc *kipp = NULL;
+    unsigned int i;
+    size_t size = 0;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+
+    // we need to re-query for thread information, so don't use *kipp
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_PID | KERN_PROC_INC_THREAD;
+    mib[3] = pid;
+
+    if (psutil_sysctl_malloc(mib, 4, (char **)&kip, &size) != 0)
+        goto error;
+
+    // subtle check: size == 0 means no such process
+    if (size == 0) {
+        psutil_oserror_nsp("sysctl (size = 0)");
+        goto error;
+    }
+
+    for (i = 0; i < size / sizeof(*kip); i++) {
+        kipp = &kip[i];
+        if (!pylist_append_fmt(
+                py_retlist,
+                "Idd",
+                kipp->ki_tid,
+                PSUTIL_TV2DOUBLE(kipp->ki_rusage.ru_utime),
+                PSUTIL_TV2DOUBLE(kipp->ki_rusage.ru_stime)
+            ))
+        {
+            goto error;
+        }
+    }
+
+    free(kip);
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    free(kip);
+    return NULL;
+}
+
+PyObject *
+psutil_proc_cwd(PyObject *self, PyObject *args) {
+    pid_t pid;
+    struct kinfo_file *freep = NULL;
+    struct kinfo_file *kif;
+    struct kinfo_proc kipp;
+    PyObject *py_path = NULL;
+
+    int i, cnt;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+    if (psutil_kinfo_proc(pid, &kipp) == -1)
+        goto error;
+
+    errno = 0;
+    freep = kinfo_getfile(pid, &cnt);
+    if (freep == NULL) {
+        psutil_raise_for_pid(pid, "kinfo_getfile()");
+        goto error;
+    }
+
+    for (i = 0; i < cnt; i++) {
+        kif = &freep[i];
+        if (kif->kf_fd == KF_FD_TYPE_CWD) {
+            py_path = PyUnicode_DecodeFSDefault(kif->kf_path);
+            if (!py_path)
+                goto error;
+            break;
+        }
+    }
+    /*
+     * For lower pids it seems we can't retrieve any information
+     * (lsof can't do that it either).  Since this happens even
+     * as root we return an empty string instead of AccessDenied.
+     */
+    if (py_path == NULL)
+        py_path = PyUnicode_DecodeFSDefault("");
+    free(freep);
+    return py_path;
+
+error:
+    Py_XDECREF(py_path);
+    if (freep != NULL)
+        free(freep);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_num_fds(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int cnt;
+
+    struct kinfo_file *freep;
+    struct kinfo_proc kipp;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if (psutil_kinfo_proc(pid, &kipp) == -1)
+        return NULL;
+
+    errno = 0;
+    freep = kinfo_getfile(pid, &cnt);
+    if (freep == NULL) {
+        psutil_raise_for_pid(pid, "kinfo_getfile()");
+        return NULL;
+    }
+    free(freep);
+
+    return Py_BuildValue("i", cnt);
+}
+
+
+PyObject *
+psutil_proc_memory_maps(PyObject *self, PyObject *args) {
+    // Return a list of tuples for every process memory maps.
+    // 'procstat' cmdline utility has been used as an example.
+    pid_t pid;
+    int ptrwidth;
+    int i, cnt;
+    char addr[1000];
+    char perms[4];
+    char *path;
+    struct kinfo_proc kp;
+    struct kinfo_vmentry *freep = NULL;
+    struct kinfo_vmentry *kve;
+    ptrwidth = 2 * sizeof(void *);
+    long pagesize = psutil_getpagesize();
+    PyObject *py_path = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+    if (psutil_kinfo_proc(pid, &kp) == -1)
+        goto error;
+
+    errno = 0;
+    freep = kinfo_getvmmap(pid, &cnt);
+    if (freep == NULL) {
+        psutil_raise_for_pid(pid, "kinfo_getvmmap()");
+        goto error;
+    }
+    for (i = 0; i < cnt; i++) {
+        kve = &freep[i];
+        addr[0] = '\0';
+        perms[0] = '\0';
+        str_format(
+            addr,
+            sizeof(addr),
+            "%#*jx-%#*jx",
+            ptrwidth,
+            (uintmax_t)kve->kve_start,
+            ptrwidth,
+            (uintmax_t)kve->kve_end
+        );
+        psutil_remove_spaces(addr);
+        str_append(
+            perms,
+            sizeof(perms),
+            kve->kve_protection & KVME_PROT_READ ? "r" : "-"
+        );
+        str_append(
+            perms,
+            sizeof(perms),
+            kve->kve_protection & KVME_PROT_WRITE ? "w" : "-"
+        );
+        str_append(
+            perms,
+            sizeof(perms),
+            kve->kve_protection & KVME_PROT_EXEC ? "x" : "-"
+        );
+
+        if (strlen(kve->kve_path) == 0) {
+            switch (kve->kve_type) {
+                case KVME_TYPE_NONE:
+                    path = "[none]";
+                    break;
+                case KVME_TYPE_DEFAULT:
+                    path = "[default]";
+                    break;
+                case KVME_TYPE_VNODE:
+                    path = "[vnode]";
+                    break;
+                case KVME_TYPE_SWAP:
+                    path = "[swap]";
+                    break;
+                case KVME_TYPE_DEVICE:
+                    path = "[device]";
+                    break;
+                case KVME_TYPE_PHYS:
+                    path = "[phys]";
+                    break;
+                case KVME_TYPE_DEAD:
+                    path = "[dead]";
+                    break;
+#ifdef KVME_TYPE_SG
+                case KVME_TYPE_SG:
+                    path = "[sg]";
+                    break;
+#endif
+                case KVME_TYPE_UNKNOWN:
+                    path = "[unknown]";
+                    break;
+                default:
+                    path = "[?]";
+                    break;
+            }
+        }
+        else {
+            path = kve->kve_path;
+        }
+
+        py_path = PyUnicode_DecodeFSDefault(path);
+        if (!py_path)
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "ssOKKii",
+                addr,  // "start-end" address
+                perms,  // "rwx" permissions
+                py_path,  // path
+                (unsigned long long)kve->kve_resident * pagesize,  // rss
+                (unsigned long long)kve->kve_private_resident  // private
+                    * pagesize,
+                kve->kve_ref_count,  // ref count
+                kve->kve_shadow_count  // shadow count
+            ))
+        {
+            goto error;
+        }
+        Py_DECREF(py_path);
+        py_path = NULL;
+    }
+    free(freep);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_path);
+    Py_DECREF(py_retlist);
+    if (freep != NULL)
+        free(freep);
+    return NULL;
+}
+
+
+// Get process CPU affinity. Reference:
+// http://sources.freebsd.org/RELENG_9/src/usr.bin/cpuset/cpuset.c
+PyObject *
+psutil_proc_cpu_affinity_get(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int ret;
+    int i;
+    cpuset_t mask;
+    PyObject *py_retlist;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    ret = cpuset_getaffinity(
+        CPU_LEVEL_WHICH, CPU_WHICH_PID, pid, sizeof(mask), &mask
+    );
+    if (ret != 0)
+        return psutil_oserror();
+
+    py_retlist = PyList_New(0);
+    if (py_retlist == NULL)
+        return NULL;
+
+    for (i = 0; i < CPU_SETSIZE; i++) {
+        if (CPU_ISSET(i, &mask)) {
+            if (!pylist_append_fmt(py_retlist, "i", i))
+                goto error;
+        }
+    }
+
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    return NULL;
+}
+
+
+// Set process CPU affinity. Reference:
+// http://sources.freebsd.org/RELENG_9/src/usr.bin/cpuset/cpuset.c
+PyObject *
+psutil_proc_cpu_affinity_set(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int i;
+    int seq_len;
+    int ret;
+    cpuset_t cpu_set;
+    PyObject *py_cpu_set;
+    PyObject *py_cpu_seq = NULL;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "O", &pid, &py_cpu_set))
+        return NULL;
+
+    py_cpu_seq = PySequence_Fast(py_cpu_set, "expected a sequence or integer");
+    if (!py_cpu_seq)
+        return NULL;
+    seq_len = PySequence_Fast_GET_SIZE(py_cpu_seq);
+
+    // calculate the mask
+    CPU_ZERO(&cpu_set);
+    for (i = 0; i < seq_len; i++) {
+        PyObject *item = PySequence_Fast_GET_ITEM(py_cpu_seq, i);
+        long value = PyLong_AsLong(item);
+        if (value == -1 || PyErr_Occurred())
+            goto error;
+        CPU_SET(value, &cpu_set);
+    }
+
+    // set affinity
+    ret = cpuset_setaffinity(
+        CPU_LEVEL_WHICH, CPU_WHICH_PID, pid, sizeof(cpu_set), &cpu_set
+    );
+    if (ret != 0) {
+        psutil_oserror();
+        goto error;
+    }
+
+    Py_DECREF(py_cpu_seq);
+    Py_RETURN_NONE;
+
+error:
+    if (py_cpu_seq != NULL)
+        Py_DECREF(py_cpu_seq);
+    return NULL;
+}
+
+
+// An emulation of Linux prlimit(). Returns a (soft, hard) tuple.
+PyObject *
+psutil_proc_getrlimit(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int resource;
+    int name[5];
+    struct rlimit rlp;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i", &pid, &resource))
+        return NULL;
+
+    name[0] = CTL_KERN;
+    name[1] = KERN_PROC;
+    name[2] = KERN_PROC_RLIMIT;
+    name[3] = pid;
+    name[4] = resource;
+
+    if (psutil_sysctl(name, 5, &rlp, sizeof(rlp)) != 0)
+        return NULL;
+
+#if defined(HAVE_LONG_LONG)
+    return Py_BuildValue(
+        "LL", (PY_LONG_LONG)rlp.rlim_cur, (PY_LONG_LONG)rlp.rlim_max
+    );
+#else
+    return Py_BuildValue("ll", (long)rlp.rlim_cur, (long)rlp.rlim_max);
+#endif
+}
+
+
+// An emulation of Linux prlimit() (set).
+PyObject *
+psutil_proc_setrlimit(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int ret;
+    int resource;
+    int name[5];
+    struct rlimit new;
+    struct rlimit *newp = NULL;
+    PyObject *py_soft = NULL;
+    PyObject *py_hard = NULL;
+
+    if (!PyArg_ParseTuple(
+            args, _Py_PARSE_PID "iOO", &pid, &resource, &py_soft, &py_hard
+        ))
+        return NULL;
+
+    name[0] = CTL_KERN;
+    name[1] = KERN_PROC;
+    name[2] = KERN_PROC_RLIMIT;
+    name[3] = pid;
+    name[4] = resource;
+
+#if defined(HAVE_LONG_LONG)
+    new.rlim_cur = PyLong_AsLongLong(py_soft);
+    if (new.rlim_cur == (rlim_t)-1 && PyErr_Occurred())
+        return NULL;
+    new.rlim_max = PyLong_AsLongLong(py_hard);
+    if (new.rlim_max == (rlim_t)-1 && PyErr_Occurred())
+        return NULL;
+#else
+    new.rlim_cur = PyLong_AsLong(py_soft);
+    if (new.rlim_cur == (rlim_t)-1 && PyErr_Occurred())
+        return NULL;
+    new.rlim_max = PyLong_AsLong(py_hard);
+    if (new.rlim_max == (rlim_t)-1 && PyErr_Occurred())
+        return NULL;
+#endif
+    newp = &new;
+    ret = sysctl(name, 5, NULL, 0, newp, sizeof(*newp));
+    if (ret == -1)
+        return psutil_oserror();
+    Py_RETURN_NONE;
+}
diff --git a/psutil/arch/freebsd/proc_socks.c b/psutil/arch/freebsd/proc_socks.c
new file mode 100644
index 0000000000..d017bdee1a
--- /dev/null
+++ b/psutil/arch/freebsd/proc_socks.c
@@ -0,0 +1,409 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Retrieves per-process open socket connections.
+
+#include <Python.h>
+#include <sys/param.h>
+#include <sys/user.h>
+#include <sys/socketvar.h>  // for struct xsocket
+#include <sys/un.h>
+#include <sys/sysctl.h>
+#include <netinet/in.h>  // for xinpcb struct
+#include <netinet/in_pcb.h>
+#include <netinet/tcp_var.h>  // for struct xtcpcb
+#include <arpa/inet.h>  // for inet_ntop()
+#include <libutil.h>
+
+#include "../../arch/all/init.h"
+
+
+// The tcplist fetching and walking is borrowed from netstat/inet.c.
+static char *
+psutil_fetch_tcplist(void) {
+    char *buf;
+    size_t len;
+
+    for (;;) {
+        if (sysctlbyname("net.inet.tcp.pcblist", NULL, &len, NULL, 0) < 0) {
+            psutil_oserror();
+            return NULL;
+        }
+        buf = malloc(len);
+        if (buf == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+        if (sysctlbyname("net.inet.tcp.pcblist", buf, &len, NULL, 0) < 0) {
+            free(buf);
+            psutil_oserror();
+            return NULL;
+        }
+        return buf;
+    }
+}
+
+
+static int
+psutil_sockaddr_port(int family, struct sockaddr_storage *ss) {
+    struct sockaddr_in6 *sin6;
+    struct sockaddr_in *sin;
+
+    if (family == AF_INET) {
+        sin = (struct sockaddr_in *)ss;
+        return (sin->sin_port);
+    }
+    else {
+        sin6 = (struct sockaddr_in6 *)ss;
+        return (sin6->sin6_port);
+    }
+}
+
+
+static void *
+psutil_sockaddr_addr(int family, struct sockaddr_storage *ss) {
+    struct sockaddr_in6 *sin6;
+    struct sockaddr_in *sin;
+
+    if (family == AF_INET) {
+        sin = (struct sockaddr_in *)ss;
+        return (&sin->sin_addr);
+    }
+    else {
+        sin6 = (struct sockaddr_in6 *)ss;
+        return (&sin6->sin6_addr);
+    }
+}
+
+
+static socklen_t
+psutil_sockaddr_addrlen(int family) {
+    if (family == AF_INET)
+        return (sizeof(struct in_addr));
+    else
+        return (sizeof(struct in6_addr));
+}
+
+
+static int
+psutil_sockaddr_matches(
+    int family, int port, void *pcb_addr, struct sockaddr_storage *ss
+) {
+    if (psutil_sockaddr_port(family, ss) != port)
+        return (0);
+    return (
+        memcmp(
+            psutil_sockaddr_addr(family, ss),
+            pcb_addr,
+            psutil_sockaddr_addrlen(family)
+        )
+        == 0
+    );
+}
+
+
+#if __FreeBSD_version >= 1200026
+static struct xtcpcb *
+psutil_search_tcplist(char *buf, struct kinfo_file *kif) {
+    struct xtcpcb *tp;
+    struct xinpcb *inp;
+#else
+static struct tcpcb *
+psutil_search_tcplist(char *buf, struct kinfo_file *kif) {
+    struct tcpcb *tp;
+    struct inpcb *inp;
+#endif
+    struct xinpgen *xig, *oxig;
+    struct xsocket *so;
+
+    oxig = xig = (struct xinpgen *)buf;
+    for (xig = (struct xinpgen *)((char *)xig + xig->xig_len);
+         xig->xig_len > sizeof(struct xinpgen);
+         xig = (struct xinpgen *)((char *)xig + xig->xig_len))
+    {
+#if __FreeBSD_version >= 1200026
+        tp = (struct xtcpcb *)xig;
+        inp = &tp->xt_inp;
+        so = &inp->xi_socket;
+#else
+        tp = &((struct xtcpcb *)xig)->xt_tp;
+        inp = &((struct xtcpcb *)xig)->xt_inp;
+        so = &((struct xtcpcb *)xig)->xt_socket;
+#endif
+
+        if (so->so_type != kif->kf_sock_type
+            || so->xso_family != kif->kf_sock_domain
+            || so->xso_protocol != kif->kf_sock_protocol)
+            continue;
+
+        if (kif->kf_sock_domain == AF_INET) {
+            if (!psutil_sockaddr_matches(
+                    AF_INET,
+                    inp->inp_lport,
+                    &inp->inp_laddr,
+#if __FreeBSD_version < 1200031
+                    &kif->kf_sa_local
+                ))
+#else
+                    &kif->kf_un.kf_sock.kf_sa_local
+                ))
+#endif
+                continue;
+            if (!psutil_sockaddr_matches(
+                    AF_INET,
+                    inp->inp_fport,
+                    &inp->inp_faddr,
+#if __FreeBSD_version < 1200031
+                    &kif->kf_sa_peer
+                ))
+#else
+                    &kif->kf_un.kf_sock.kf_sa_peer
+                ))
+#endif
+                continue;
+        }
+        else {
+            if (!psutil_sockaddr_matches(
+                    AF_INET6,
+                    inp->inp_lport,
+                    &inp->in6p_laddr,
+#if __FreeBSD_version < 1200031
+                    &kif->kf_sa_local
+                ))
+#else
+                    &kif->kf_un.kf_sock.kf_sa_local
+                ))
+#endif
+                continue;
+            if (!psutil_sockaddr_matches(
+                    AF_INET6,
+                    inp->inp_fport,
+                    &inp->in6p_faddr,
+#if __FreeBSD_version < 1200031
+                    &kif->kf_sa_peer
+                ))
+#else
+                    &kif->kf_un.kf_sock.kf_sa_peer
+                ))
+#endif
+                continue;
+        }
+
+        return (tp);
+    }
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_net_connections(PyObject *self, PyObject *args) {
+    // Return connections opened by process.
+    pid_t pid;
+    int i;
+    int cnt;
+    psutil_conn_filters filters;
+    struct kinfo_file *freep = NULL;
+    struct kinfo_file *kif;
+    char *tcplist = NULL;
+#if __FreeBSD_version >= 1200026
+    struct xtcpcb *tcp;
+#else
+    struct tcpcb *tcp;
+#endif
+
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_laddr = NULL;
+    PyObject *py_raddr = NULL;
+    PyObject *py_af_filter = NULL;
+    PyObject *py_type_filter = NULL;
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(
+            args, _Py_PARSE_PID "OO", &pid, &py_af_filter, &py_type_filter
+        ))
+    {
+        goto error;
+    }
+    if (psutil_parse_conn_filters(py_af_filter, py_type_filter, &filters) != 0)
+        goto error;
+
+    errno = 0;
+    freep = kinfo_getfile(pid, &cnt);
+    if (freep == NULL) {
+        psutil_raise_for_pid(pid, "kinfo_getfile()");
+        goto error;
+    }
+
+    tcplist = psutil_fetch_tcplist();
+    if (tcplist == NULL) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (i = 0; i < cnt; i++) {
+        int lport, rport, state;
+        char lip[INET6_ADDRSTRLEN], rip[INET6_ADDRSTRLEN];
+        char path[PATH_MAX];
+        py_laddr = NULL;
+        py_raddr = NULL;
+
+        kif = &freep[i];
+        if (kif->kf_type == KF_TYPE_SOCKET) {
+            // apply filters
+            if (!((kif->kf_sock_domain == AF_INET && filters.v4)
+                  || (kif->kf_sock_domain == AF_INET6 && filters.v6)
+                  || (kif->kf_sock_domain == AF_UNIX && filters.unix_)))
+            {
+                continue;
+            }
+            if (!((kif->kf_sock_type == SOCK_STREAM && filters.tcp)
+                  || (kif->kf_sock_type == SOCK_DGRAM && filters.udp)))
+            {
+                continue;
+            }
+            // IPv4 / IPv6 socket
+            if ((kif->kf_sock_domain == AF_INET)
+                || (kif->kf_sock_domain == AF_INET6))
+            {
+                // fill status
+                state = PSUTIL_CONN_NONE;
+                if (kif->kf_sock_type == SOCK_STREAM) {
+                    tcp = psutil_search_tcplist(tcplist, kif);
+                    if (tcp != NULL)
+                        state = (int)tcp->t_state;
+                }
+
+                // build addr and port
+                inet_ntop(
+                    kif->kf_sock_domain,
+                    psutil_sockaddr_addr(
+                        kif->kf_sock_domain,
+#if __FreeBSD_version < 1200031
+                        &kif->kf_sa_local
+                    ),
+#else
+                        &kif->kf_un.kf_sock.kf_sa_local
+                    ),
+#endif
+                    lip,
+                    sizeof(lip)
+                );
+                inet_ntop(
+                    kif->kf_sock_domain,
+                    psutil_sockaddr_addr(
+                        kif->kf_sock_domain,
+#if __FreeBSD_version < 1200031
+                        &kif->kf_sa_peer
+                    ),
+#else
+                        &kif->kf_un.kf_sock.kf_sa_peer
+                    ),
+#endif
+                    rip,
+                    sizeof(rip)
+                );
+                lport = htons(psutil_sockaddr_port(
+                    kif->kf_sock_domain,
+#if __FreeBSD_version < 1200031
+                    &kif->kf_sa_local
+                ));
+#else
+                    &kif->kf_un.kf_sock.kf_sa_local
+                ));
+#endif
+                rport = htons(psutil_sockaddr_port(
+                    kif->kf_sock_domain,
+#if __FreeBSD_version < 1200031
+                    &kif->kf_sa_peer
+                ));
+#else
+                    &kif->kf_un.kf_sock.kf_sa_peer
+                ));
+#endif
+
+                // construct python tuple/list
+                py_laddr = Py_BuildValue("(si)", lip, lport);
+                if (!py_laddr)
+                    goto error;
+                if (rport != 0)
+                    py_raddr = Py_BuildValue("(si)", rip, rport);
+                else
+                    py_raddr = Py_BuildValue("()");
+                if (!py_raddr)
+                    goto error;
+                if (!pylist_append_fmt(
+                        py_retlist,
+                        "(iiiNNi)",
+                        kif->kf_fd,
+                        kif->kf_sock_domain,
+                        kif->kf_sock_type,
+                        py_laddr,
+                        py_raddr,
+                        state
+                    ))
+                {
+                    goto error;
+                }
+                py_laddr = NULL;
+                py_raddr = NULL;
+            }
+            // UNIX socket.
+            // Note: remote path cannot be determined.
+            else if (kif->kf_sock_domain == AF_UNIX) {
+                struct sockaddr_un *sun;
+
+#if __FreeBSD_version < 1200031
+                sun = (struct sockaddr_un *)&kif->kf_sa_local;
+#else
+                sun = (struct sockaddr_un *)&kif->kf_un.kf_sock.kf_sa_local;
+#endif
+                str_format(
+                    path,
+                    sizeof(path),
+                    "%.*s",
+                    (int)(sun->sun_len - (sizeof(*sun) - sizeof(sun->sun_path))
+                    ),
+                    sun->sun_path
+                );
+
+                py_laddr = PyUnicode_DecodeFSDefault(path);
+                if (!py_laddr)
+                    goto error;
+
+                if (!pylist_append_fmt(
+                        py_retlist,
+                        "(iiiOsi)",
+                        kif->kf_fd,
+                        kif->kf_sock_domain,
+                        kif->kf_sock_type,
+                        py_laddr,
+                        "",  // raddr can't be determined
+                        PSUTIL_CONN_NONE
+                    ))
+                {
+                    goto error;
+                }
+                Py_DECREF(py_laddr);
+                py_laddr = NULL;
+            }
+        }
+    }
+    free(freep);
+    free(tcplist);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_laddr);
+    Py_XDECREF(py_raddr);
+    Py_DECREF(py_retlist);
+    if (freep != NULL)
+        free(freep);
+    if (tcplist != NULL)
+        free(tcplist);
+    return NULL;
+}
diff --git a/psutil/arch/freebsd/sensors.c b/psutil/arch/freebsd/sensors.c
new file mode 100644
index 0000000000..8259f88e3b
--- /dev/null
+++ b/psutil/arch/freebsd/sensors.c
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Original code was refactored and moved from psutil/arch/freebsd/specific.c
+// For reference, here's the git history with original(ish) implementations:
+// - sensors_battery(): 022cf0a05d34f4274269d4f8002ee95b9f3e32d2
+// - sensors_cpu_temperature(): bb5d032be76980a9e110f03f1203bd35fa85a793
+//   (patch by Alex Manuskin)
+
+#include <Python.h>
+#include <sys/sysctl.h>
+
+#include "../../arch/all/init.h"
+
+
+#define DECIKELVIN_2_CELSIUS(t) (t - 2731) / 10
+
+
+PyObject *
+psutil_sensors_battery(PyObject *self, PyObject *args) {
+    int percent;
+    int minsleft;
+    int power_plugged;
+    size_t size = sizeof(percent);
+
+    if (psutil_sysctlbyname("hw.acpi.battery.life", &percent, size) != 0)
+        goto error;
+    if (psutil_sysctlbyname("hw.acpi.battery.time", &minsleft, size) != 0)
+        goto error;
+    if (psutil_sysctlbyname("hw.acpi.acline", &power_plugged, size) != 0)
+        goto error;
+    return Py_BuildValue("dii", (double)percent, minsleft, power_plugged);
+
+error:
+    // see: https://github.com/giampaolo/psutil/issues/1074
+    if (errno == ENOENT)
+        PyErr_SetString(PyExc_NotImplementedError, "no battery");
+    else
+        psutil_oserror();
+    return NULL;
+}
+
+
+// Return temperature information for a given CPU core number.
+PyObject *
+psutil_sensors_cpu_temperature(PyObject *self, PyObject *args) {
+    int current;
+    int tjmax;
+    int core;
+    char sensor[26];
+    size_t size = sizeof(current);
+
+    if (!PyArg_ParseTuple(args, "i", &core))
+        return NULL;
+    str_format(sensor, sizeof(sensor), "dev.cpu.%d.temperature", core);
+    if (psutil_sysctlbyname(sensor, &current, size) != 0)
+        goto error;
+    current = DECIKELVIN_2_CELSIUS(current);
+
+    // Return -273 in case of failure.
+    str_format(sensor, sizeof(sensor), "dev.cpu.%d.coretemp.tjmax", core);
+    if (psutil_sysctlbyname(sensor, &tjmax, size) != 0)
+        tjmax = 0;
+    tjmax = DECIKELVIN_2_CELSIUS(tjmax);
+
+    return Py_BuildValue("ii", current, tjmax);
+
+error:
+    if (errno == ENOENT)
+        PyErr_SetString(PyExc_NotImplementedError, "no temperature sensors");
+    else
+        psutil_oserror();
+    return NULL;
+}
diff --git a/psutil/arch/freebsd/sys_socks.c b/psutil/arch/freebsd/sys_socks.c
new file mode 100644
index 0000000000..1d07a9c59a
--- /dev/null
+++ b/psutil/arch/freebsd/sys_socks.c
@@ -0,0 +1,435 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Retrieves system-wide open socket connections. This is based off of
+// sockstat utility source code:
+// https://github.com/freebsd/freebsd/blob/master/usr.bin/sockstat/sockstat.c
+
+#include <Python.h>
+#include <sys/param.h>
+#include <sys/user.h>
+#include <sys/file.h>
+#include <sys/socketvar.h>  // for struct xsocket
+#include <sys/un.h>
+#include <sys/unpcb.h>
+#include <sys/sysctl.h>
+#include <netinet/in.h>  // for xinpcb struct
+#include <netinet/ip.h>
+#include <netinet/in_pcb.h>
+#include <netinet/tcp_var.h>  // for struct xtcpcb
+#include <arpa/inet.h>  // for inet_ntop()
+
+#include "../../arch/all/init.h"
+
+
+static int
+psutil_populate_xfiles(struct xfile **psutil_xfiles, int *psutil_nxfiles) {
+    struct xfile *new_psutil_xfiles;
+    size_t len = sizeof(struct xfile);
+
+    while (sysctlbyname("kern.file", *psutil_xfiles, &len, 0, 0) == -1) {
+        if (errno != ENOMEM) {
+            psutil_oserror();
+            return -1;
+        }
+        len *= 2;
+        new_psutil_xfiles = realloc(*psutil_xfiles, len);
+        if (new_psutil_xfiles == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        *psutil_xfiles = new_psutil_xfiles;
+    }
+    if (len > 0 && (*psutil_xfiles)->xf_size != sizeof(struct xfile)) {
+        psutil_runtime_error("struct xfile size mismatch");
+        return -1;
+    }
+    *psutil_nxfiles = len / sizeof(struct xfile);
+    return 0;
+}
+
+
+static struct xfile *
+psutil_get_file_from_sock(
+    kvaddr_t sock, struct xfile *psutil_xfiles, int psutil_nxfiles
+) {
+    struct xfile *xf;
+    int n;
+
+    for (xf = psutil_xfiles, n = 0; n < psutil_nxfiles; ++n, ++xf) {
+        if (xf->xf_data == sock)
+            return xf;
+    }
+    return NULL;
+}
+
+
+// Reference:
+// https://github.com/freebsd/freebsd/blob/master/usr.bin/sockstat/sockstat.c
+static int
+psutil_gather_inet(
+    int proto,
+    const psutil_conn_filters *filters,
+    PyObject *py_retlist,
+    struct xfile *psutil_xfiles,
+    int psutil_nxfiles
+) {
+    struct xinpgen *xig, *exig;
+    struct xinpcb *xip;
+    struct xtcpcb *xtp;
+#if __FreeBSD_version >= 1200026
+    struct xinpcb *inp;
+#else
+    struct inpcb *inp;
+#endif
+    struct xsocket *so;
+    const char *varname = NULL;
+    size_t len, bufsize;
+    void *buf;
+    int retry;
+    int type;
+
+    PyObject *py_laddr = NULL;
+    PyObject *py_raddr = NULL;
+
+    switch (proto) {
+        case IPPROTO_TCP:
+            varname = "net.inet.tcp.pcblist";
+            type = SOCK_STREAM;
+            break;
+        case IPPROTO_UDP:
+            varname = "net.inet.udp.pcblist";
+            type = SOCK_DGRAM;
+            break;
+    }
+
+    buf = NULL;
+    bufsize = 8192;
+    retry = 5;
+    do {
+        for (;;) {
+            buf = realloc(buf, bufsize);
+            if (buf == NULL)
+                continue;  // XXX
+            len = bufsize;
+            if (sysctlbyname(varname, buf, &len, NULL, 0) == 0)
+                break;
+            if (errno != ENOMEM) {
+                psutil_oserror();
+                goto error;
+            }
+            bufsize *= 2;
+        }
+        xig = (struct xinpgen *)buf;
+        exig = (struct xinpgen *)(void *)((char *)buf + len - sizeof *exig);
+        if (xig->xig_len != sizeof *xig || exig->xig_len != sizeof *exig) {
+            psutil_runtime_error("struct xinpgen size mismatch");
+            goto error;
+        }
+    } while (xig->xig_gen != exig->xig_gen && retry--);
+
+    for (;;) {
+        struct xfile *xf;
+        int lport, rport, status, family;
+
+        xig = (struct xinpgen *)(void *)((char *)xig + xig->xig_len);
+        if (xig >= exig)
+            break;
+
+        switch (proto) {
+            case IPPROTO_TCP:
+                xtp = (struct xtcpcb *)xig;
+                if (xtp->xt_len != sizeof *xtp) {
+                    psutil_runtime_error("struct xtcpcb size mismatch");
+                    goto error;
+                }
+                inp = &xtp->xt_inp;
+#if __FreeBSD_version >= 1200026
+                so = &inp->xi_socket;
+                status = xtp->t_state;
+#else
+                so = &xtp->xt_socket;
+                status = xtp->xt_tp.t_state;
+#endif
+                break;
+            case IPPROTO_UDP:
+                xip = (struct xinpcb *)xig;
+                if (xip->xi_len != sizeof *xip) {
+                    psutil_runtime_error("struct xinpcb size mismatch");
+                    goto error;
+                }
+#if __FreeBSD_version >= 1200026
+                inp = xip;
+#else
+                inp = &xip->xi_inp;
+#endif
+                so = &xip->xi_socket;
+                status = PSUTIL_CONN_NONE;
+                break;
+            default:
+                psutil_runtime_error("invalid proto");
+                goto error;
+        }
+
+        // filter
+        if ((inp->inp_vflag & INP_IPV4) && !filters->v4)
+            continue;
+        if ((inp->inp_vflag & INP_IPV6) && !filters->v6)
+            continue;
+
+        char lip[INET6_ADDRSTRLEN], rip[INET6_ADDRSTRLEN];
+
+        xf = psutil_get_file_from_sock(
+            so->xso_so, psutil_xfiles, psutil_nxfiles
+        );
+        if (xf == NULL)
+            continue;
+        lport = ntohs(inp->inp_lport);
+        rport = ntohs(inp->inp_fport);
+
+        if (inp->inp_vflag & INP_IPV4) {
+            family = AF_INET;
+            inet_ntop(AF_INET, &inp->inp_laddr.s_addr, lip, sizeof(lip));
+            inet_ntop(AF_INET, &inp->inp_faddr.s_addr, rip, sizeof(rip));
+        }
+        else if (inp->inp_vflag & INP_IPV6) {
+            family = AF_INET6;
+            inet_ntop(AF_INET6, &inp->in6p_laddr.s6_addr, lip, sizeof(lip));
+            inet_ntop(AF_INET6, &inp->in6p_faddr.s6_addr, rip, sizeof(rip));
+        }
+
+        // construct python tuple/list
+        py_laddr = Py_BuildValue("(si)", lip, lport);
+        if (!py_laddr)
+            goto error;
+        if (rport != 0)
+            py_raddr = Py_BuildValue("(si)", rip, rport);
+        else
+            py_raddr = Py_BuildValue("()");
+        if (!py_raddr)
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "iiiNNi" _Py_PARSE_PID,
+                xf->xf_fd,  // fd
+                family,  // family
+                type,  // type
+                py_laddr,  // laddr
+                py_raddr,  // raddr
+                status,  // status
+                xf->xf_pid  // pid
+            ))
+        {
+            goto error;
+        }
+        py_laddr = NULL;
+        py_raddr = NULL;
+    }
+
+    free(buf);
+    return 0;
+
+error:
+    Py_XDECREF(py_laddr);
+    Py_XDECREF(py_raddr);
+    free(buf);
+    return -1;
+}
+
+
+static int
+psutil_gather_unix(
+    int proto,
+    PyObject *py_retlist,
+    struct xfile *psutil_xfiles,
+    int psutil_nxfiles
+) {
+    struct xunpgen *xug, *exug;
+    struct xunpcb *xup;
+    const char *varname = NULL;
+    const char *protoname = NULL;
+    size_t len;
+    size_t bufsize;
+    void *buf;
+    int retry;
+    struct sockaddr_un *sun;
+    char path[PATH_MAX];
+
+    PyObject *py_lpath = NULL;
+
+    switch (proto) {
+        case SOCK_STREAM:
+            varname = "net.local.stream.pcblist";
+            protoname = "stream";
+            break;
+        case SOCK_DGRAM:
+            varname = "net.local.dgram.pcblist";
+            protoname = "dgram";
+            break;
+    }
+
+    buf = NULL;
+    bufsize = 8192;
+    retry = 5;
+
+    do {
+        for (;;) {
+            buf = realloc(buf, bufsize);
+            if (buf == NULL) {
+                PyErr_NoMemory();
+                goto error;
+            }
+            len = bufsize;
+            if (sysctlbyname(varname, buf, &len, NULL, 0) == 0)
+                break;
+            if (errno != ENOMEM) {
+                psutil_oserror();
+                goto error;
+            }
+            bufsize *= 2;
+        }
+        xug = (struct xunpgen *)buf;
+        exug = (struct xunpgen *)(void *)((char *)buf + len - sizeof *exug);
+        if (xug->xug_len != sizeof *xug || exug->xug_len != sizeof *exug) {
+            psutil_runtime_error("struct xinpgen size mismatch");
+            goto error;
+        }
+    } while (xug->xug_gen != exug->xug_gen && retry--);
+
+    for (;;) {
+        struct xfile *xf;
+
+        xug = (struct xunpgen *)(void *)((char *)xug + xug->xug_len);
+        if (xug >= exug)
+            break;
+        xup = (struct xunpcb *)xug;
+        if (xup->xu_len != sizeof *xup)
+            goto error;
+
+        xf = psutil_get_file_from_sock(
+            xup->xu_socket.xso_so, psutil_xfiles, psutil_nxfiles
+        );
+        if (xf == NULL)
+            continue;
+
+        sun = (struct sockaddr_un *)&xup->xu_addr;
+        str_format(
+            path,
+            sizeof(path),
+            "%.*s",
+            (int)(sun->sun_len - (sizeof(*sun) - sizeof(sun->sun_path))),
+            sun->sun_path
+        );
+        py_lpath = PyUnicode_DecodeFSDefault(path);
+        if (!py_lpath)
+            goto error;
+
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(iiiOsii)",
+                xf->xf_fd,  // fd
+                AF_UNIX,  // family
+                proto,  // type
+                py_lpath,  // lpath
+                "",  // rath
+                PSUTIL_CONN_NONE,  // status
+                xf->xf_pid  // pid
+            ))
+        {
+            goto error;
+        }
+        Py_DECREF(py_lpath);
+        py_lpath = NULL;
+    }
+
+    free(buf);
+    return 0;
+
+error:
+    Py_XDECREF(py_lpath);
+    free(buf);
+    return -1;
+}
+
+
+PyObject *
+psutil_net_connections(PyObject *self, PyObject *args) {
+    int psutil_nxfiles;
+    psutil_conn_filters filters;
+    struct xfile *psutil_xfiles;
+    PyObject *py_af_filter = NULL;
+    PyObject *py_type_filter = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, "OO", &py_af_filter, &py_type_filter)) {
+        goto error;
+    }
+    if (psutil_parse_conn_filters(py_af_filter, py_type_filter, &filters) != 0)
+        goto error;
+
+    psutil_xfiles = malloc(sizeof(struct xfile));
+    if (psutil_xfiles == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    if (psutil_populate_xfiles(&psutil_xfiles, &psutil_nxfiles) != 0)
+        goto error_free_psutil_xfiles;
+
+    // TCP
+    if (filters.tcp) {
+        if (psutil_gather_inet(
+                IPPROTO_TCP,
+                &filters,
+                py_retlist,
+                psutil_xfiles,
+                psutil_nxfiles
+            )
+            != 0)
+        {
+            goto error_free_psutil_xfiles;
+        }
+    }
+    // UDP
+    if (filters.udp) {
+        if (psutil_gather_inet(
+                IPPROTO_UDP,
+                &filters,
+                py_retlist,
+                psutil_xfiles,
+                psutil_nxfiles
+            )
+            != 0)
+        {
+            goto error_free_psutil_xfiles;
+        }
+    }
+    // UNIX
+    if (filters.unix_) {
+        if (psutil_gather_unix(
+                SOCK_STREAM, py_retlist, psutil_xfiles, psutil_nxfiles
+            )
+            != 0)
+            goto error_free_psutil_xfiles;
+        if (psutil_gather_unix(
+                SOCK_DGRAM, py_retlist, psutil_xfiles, psutil_nxfiles
+            )
+            != 0)
+            goto error_free_psutil_xfiles;
+    }
+
+    free(psutil_xfiles);
+    return py_retlist;
+
+error_free_psutil_xfiles:
+    free(psutil_xfiles);
+error:
+    Py_DECREF(py_retlist);
+    return NULL;
+}
diff --git a/psutil/arch/linux/disk.c b/psutil/arch/linux/disk.c
new file mode 100644
index 0000000000..86ec542e44
--- /dev/null
+++ b/psutil/arch/linux/disk.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "../../arch/all/init.h"
+
+#include <Python.h>
+#include <mntent.h>
+
+
+// Return disk mounted partitions as a list of tuples including device,
+// mount point and filesystem type.
+PyObject *
+psutil_disk_partitions(PyObject *self, PyObject *args) {
+    FILE *file = NULL;
+    struct mntent *entry;
+    char *mtab_path;
+    PyObject *py_dev = NULL;
+    PyObject *py_mountp = NULL;
+    PyObject *py_retlist;
+
+    if (!PyArg_ParseTuple(args, "s", &mtab_path))
+        return NULL;
+
+    py_retlist = PyList_New(0);
+    if (py_retlist == NULL)
+        return NULL;
+
+    Py_BEGIN_ALLOW_THREADS
+    file = setmntent(mtab_path, "r");
+    Py_END_ALLOW_THREADS
+    if ((file == 0) || (file == NULL)) {
+        psutil_debug("setmntent() failed");
+        PyErr_SetFromErrnoWithFilename(PyExc_OSError, mtab_path);
+        goto error;
+    }
+
+    // NOTE: getmntent() is MT-Unsafe (it returns a pointer to a static
+    // buffer), so we can't release the GIL around it.
+    while ((entry = getmntent(file)) != NULL) {
+        py_dev = PyUnicode_DecodeFSDefault(entry->mnt_fsname);
+        if (!py_dev)
+            goto error;
+        py_mountp = PyUnicode_DecodeFSDefault(entry->mnt_dir);
+        if (!py_mountp)
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(OOss)",
+                py_dev,  // device
+                py_mountp,  // mount point
+                entry->mnt_type,  // fs type
+                entry->mnt_opts  // options
+            ))
+        {
+            goto error;
+        }
+        Py_CLEAR(py_dev);
+        Py_CLEAR(py_mountp);
+    }
+    endmntent(file);
+    return py_retlist;
+
+error:
+    if (file != NULL)
+        endmntent(file);
+    Py_XDECREF(py_dev);
+    Py_XDECREF(py_mountp);
+    Py_DECREF(py_retlist);
+    return NULL;
+}
diff --git a/psutil/arch/linux/heap.c b/psutil/arch/linux/heap.c
new file mode 100644
index 0000000000..d3ef444712
--- /dev/null
+++ b/psutil/arch/linux/heap.c
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "../../arch/all/init.h"
+
+#if defined(PSUTIL_HAS_HEAP_INFO)  // Not available on MUSL / Alpine Linux
+#include <Python.h>
+#include <malloc.h>
+#include <dlfcn.h>
+
+
+// A copy of glibc's mallinfo2 layout. Allows compilation even if
+// <malloc.h> doesn't define mallinfo2.
+struct my_mallinfo2 {
+    size_t arena;
+    size_t ordblks;
+    size_t smblks;
+    size_t hblks;
+    size_t hblkhd;
+    size_t usmblks;
+    size_t fsmblks;
+    size_t uordblks;
+    size_t fordblks;
+    size_t keepcost;
+};
+
+
+// psutil_heap_info() -> (heap_used, mmap_used)
+// Return low-level heap statistics from the C allocator (glibc).
+PyObject *
+psutil_heap_info(PyObject *self, PyObject *args) {
+    static int warned = 0;
+    void *handle = NULL;
+    void *fun = NULL;
+    unsigned long long uord, mmap;
+
+    handle = dlopen("libc.so.6", RTLD_LAZY);
+    if (handle != NULL) {
+        fun = dlsym(handle, "mallinfo2");
+    }
+
+    // mallinfo2() appeared in glibc 2.33, February 2021.
+    if (fun != NULL) {
+        struct my_mallinfo2 m2;
+
+        m2 = ((struct my_mallinfo2(*)(void))fun)();
+
+        uord = (unsigned long long)m2.uordblks;
+        mmap = (unsigned long long)m2.hblkhd;
+    }
+
+    // mallinfo() is broken due to its fields that are 32-bit
+    // integers, meaning they overflow if process allocates more than
+    // 2GB in the heap.
+    else {
+        struct mallinfo m1;
+
+        if (!warned) {
+            psutil_debug("WARNING: using deprecated mallinfo()");
+            warned = 1;
+        }
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+        m1 = mallinfo();
+#pragma GCC diagnostic pop
+
+        uord = (unsigned long long)m1.uordblks;
+        mmap = (unsigned long long)m1.hblkhd;
+    }
+
+    if (handle)
+        dlclose(handle);
+
+    return Py_BuildValue("KK", uord, mmap);
+}
+
+
+// Release unused memory held by the allocator back to the OS.
+PyObject *
+psutil_heap_trim(PyObject *self, PyObject *args) {
+    // heap_trim returns 1 if some memory was released, else 0.
+    int ret = malloc_trim(0);
+    return PyBool_FromLong(ret);
+}
+#endif  // PSUTIL_HAS_HEAP_INFO
diff --git a/psutil/arch/linux/init.h b/psutil/arch/linux/init.h
new file mode 100644
index 0000000000..60c45548ad
--- /dev/null
+++ b/psutil/arch/linux/init.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/syscall.h>  // __NR_*
+#include <sched.h>  // CPU_ALLOC
+
+PyObject *psutil_disk_partitions(PyObject *self, PyObject *args);
+PyObject *psutil_linux_sysinfo(PyObject *self, PyObject *args);
+PyObject *psutil_net_if_duplex_speed(PyObject *self, PyObject *args);
+PyObject *psutil_proc_ioprio_get(PyObject *self, PyObject *args);
+PyObject *psutil_proc_ioprio_set(PyObject *self, PyObject *args);
+
+// Should exist starting from CentOS 6 (year 2011).
+#ifdef CPU_ALLOC
+#define PSUTIL_HAS_CPU_AFFINITY
+PyObject *psutil_proc_cpu_affinity_get(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cpu_affinity_set(PyObject *self, PyObject *args);
+#endif
+
+// Does not exist on MUSL / Alpine Linux.
+#if defined(__GLIBC__)
+#define PSUTIL_HAS_HEAP_INFO
+#define PSUTIL_HAS_HEAP_TRIM
+PyObject *psutil_heap_trim(PyObject *self, PyObject *args);
+PyObject *psutil_heap_info(PyObject *self, PyObject *args);
+#endif
diff --git a/psutil/arch/linux/mem.c b/psutil/arch/linux/mem.c
new file mode 100644
index 0000000000..044e6042d4
--- /dev/null
+++ b/psutil/arch/linux/mem.c
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysinfo.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_linux_sysinfo(PyObject *self, PyObject *args) {
+    struct sysinfo info;
+
+    if (sysinfo(&info) != 0)
+        return psutil_oserror();
+    // note: boot time might also be determined from here
+    return Py_BuildValue(
+        "(kkkkkkI)",
+        info.totalram,  // total
+        info.freeram,  // free
+        info.bufferram,  // buffer
+        info.sharedram,  // shared
+        info.totalswap,  // swap tot
+        info.freeswap,  // swap free
+        info.mem_unit  // multiplier
+    );
+}
diff --git a/psutil/arch/linux/net.c b/psutil/arch/linux/net.c
new file mode 100644
index 0000000000..17b23e2669
--- /dev/null
+++ b/psutil/arch/linux/net.c
@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <linux/sockios.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <linux/if.h>
+#include <linux/version.h>
+#include <unistd.h>
+
+#include "../../arch/all/init.h"
+
+// see: https://github.com/giampaolo/psutil/issues/659
+#ifdef PSUTIL_ETHTOOL_MISSING_TYPES
+#include <linux/types.h>
+typedef __u64 u64;
+typedef __u32 u32;
+typedef __u16 u16;
+typedef __u8 u8;
+#endif
+
+// Avoid redefinition of struct sysinfo with musl libc.
+#define _LINUX_SYSINFO_H
+#include <linux/ethtool.h>
+
+// * defined in linux/ethtool.h but not always available (e.g. Android)
+// * #ifdef check needed for old kernels, see:
+//   https://github.com/giampaolo/psutil/issues/2164
+static inline uint32_t
+psutil_ethtool_cmd_speed(const struct ethtool_cmd *ecmd) {
+#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 27)
+    return ecmd->speed;
+#else
+    return (ecmd->speed_hi << 16) | ecmd->speed;
+#endif
+}
+
+// May happen on old RedHat versions, see:
+// https://github.com/giampaolo/psutil/issues/607
+#ifndef DUPLEX_UNKNOWN
+#define DUPLEX_UNKNOWN 0xff
+#endif
+
+// https://github.com/giampaolo/psutil/pull/2156
+#ifndef SPEED_UNKNOWN
+#define SPEED_UNKNOWN -1
+#endif
+
+// References:
+// * https://github.com/dpaleino/wicd/blob/master/wicd/backends/be-ioctl.py
+// * http://www.i-scream.org/libstatgrab/
+PyObject *
+psutil_net_if_duplex_speed(PyObject *self, PyObject *args) {
+    char *nic_name;
+    int sock = 0;
+    int ret;
+    int duplex;
+    __u32 uint_speed;
+    int speed;
+    struct ifreq ifr;
+    struct ethtool_cmd ethcmd;
+    PyObject *py_retlist = NULL;
+
+    if (!PyArg_ParseTuple(args, "s", &nic_name))
+        return NULL;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock == -1)
+        return psutil_oserror_wsyscall("socket()");
+    str_copy(ifr.ifr_name, sizeof(ifr.ifr_name), nic_name);
+
+
+    // duplex and speed
+    memset(&ethcmd, 0, sizeof ethcmd);
+    ethcmd.cmd = ETHTOOL_GSET;
+    ifr.ifr_data = (void *)&ethcmd;
+    // The driver may read the PHY / EEPROM to answer this, and it
+    // takes rtnl_lock() meanwhile.
+    Py_BEGIN_ALLOW_THREADS
+    ret = ioctl(sock, SIOCETHTOOL, &ifr);
+    Py_END_ALLOW_THREADS
+
+    if (ret != -1) {
+        duplex = ethcmd.duplex;
+        // speed is returned from ethtool as a __u32 ranging from 0 to INT_MAX
+        // or SPEED_UNKNOWN (-1)
+        uint_speed = psutil_ethtool_cmd_speed(&ethcmd);
+        if (uint_speed == (__u32)SPEED_UNKNOWN || uint_speed > INT_MAX) {
+            speed = 0;
+        }
+        else {
+            speed = (int)uint_speed;
+        }
+    }
+    else {
+        if ((errno == EOPNOTSUPP) || (errno == EINVAL) || (errno == EBUSY)) {
+            // EOPNOTSUPP may occur in case of wi-fi cards.
+            // For EINVAL see:
+            // https://github.com/giampaolo/psutil/issues/797
+            //     #issuecomment-202999532
+            // EBUSY may occur with broken drivers or busy devices.
+            duplex = DUPLEX_UNKNOWN;
+            speed = 0;
+        }
+        else {
+            psutil_oserror_wsyscall("ioctl(SIOCETHTOOL)");
+            goto error;
+        }
+    }
+
+    py_retlist = Py_BuildValue("[ii]", duplex, speed);
+    if (!py_retlist)
+        goto error;
+    close(sock);
+    return py_retlist;
+
+error:
+    if (sock != -1)
+        close(sock);
+    return NULL;
+}
diff --git a/psutil/arch/linux/proc.c b/psutil/arch/linux/proc.c
new file mode 100644
index 0000000000..9e1bb3bd60
--- /dev/null
+++ b/psutil/arch/linux/proc.c
@@ -0,0 +1,191 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "../../arch/all/init.h"
+
+#include <Python.h>
+#include <sys/syscall.h>
+#include <sched.h>
+#include <unistd.h>
+
+
+// ====================================================================
+// --- process priority (niceness)
+// ====================================================================
+
+
+enum {
+    IOPRIO_WHO_PROCESS = 1,
+};
+
+static inline int
+ioprio_get(int which, int who) {
+    return syscall(__NR_ioprio_get, which, who);
+}
+
+static inline int
+ioprio_set(int which, int who, int ioprio) {
+    return syscall(__NR_ioprio_set, which, who, ioprio);
+}
+
+#define IOPRIO_CLASS_SHIFT 13
+#define IOPRIO_PRIO_MASK ((1UL << IOPRIO_CLASS_SHIFT) - 1)
+
+#define IOPRIO_PRIO_CLASS(mask) ((mask) >> IOPRIO_CLASS_SHIFT)
+#define IOPRIO_PRIO_DATA(mask) ((mask) & IOPRIO_PRIO_MASK)
+#define IOPRIO_PRIO_VALUE(class, data) (((class) << IOPRIO_CLASS_SHIFT) | data)
+
+// Return a (ioclass, iodata) Python tuple representing process I/O
+// priority.
+PyObject *
+psutil_proc_ioprio_get(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int ioprio, ioclass, iodata;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    ioprio = ioprio_get(IOPRIO_WHO_PROCESS, pid);
+    if (ioprio == -1)
+        return psutil_oserror();
+    ioclass = IOPRIO_PRIO_CLASS(ioprio);
+    iodata = IOPRIO_PRIO_DATA(ioprio);
+    return Py_BuildValue("ii", ioclass, iodata);
+}
+
+
+// A wrapper around ioprio_set(); sets process I/O priority. ioclass
+// can be either IOPRIO_CLASS_RT, IOPRIO_CLASS_BE, IOPRIO_CLASS_IDLE or
+// 0. iodata goes from 0 to 7 depending on ioclass specified.
+PyObject *
+psutil_proc_ioprio_set(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int ioprio, ioclass, iodata;
+    int retval;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "ii", &pid, &ioclass, &iodata)) {
+        return NULL;
+    }
+    ioprio = IOPRIO_PRIO_VALUE(ioclass, iodata);
+    retval = ioprio_set(IOPRIO_WHO_PROCESS, pid, ioprio);
+    if (retval == -1)
+        return psutil_oserror();
+    Py_RETURN_NONE;
+}
+
+
+// ====================================================================
+// --- process CPU affinity
+// ====================================================================
+
+
+#ifdef PSUTIL_HAS_CPU_AFFINITY
+// Return process CPU affinity as a list of integers.
+PyObject *
+psutil_proc_cpu_affinity_get(PyObject *self, PyObject *args) {
+    int cpu, ncpus, count, cpucount_s;
+    pid_t pid;
+    size_t setsize;
+    cpu_set_t *mask = NULL;
+    PyObject *py_list = NULL;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    // The minimum number of CPUs allocated in a cpu_set_t.
+    ncpus = sizeof(unsigned long) * CHAR_BIT;
+    while (1) {
+        setsize = CPU_ALLOC_SIZE(ncpus);
+        mask = CPU_ALLOC(ncpus);
+        if (mask == NULL) {
+            psutil_debug("CPU_ALLOC() failed");
+            return PyErr_NoMemory();
+        }
+        if (sched_getaffinity(pid, setsize, mask) == 0)
+            break;
+        CPU_FREE(mask);
+        if (errno != EINVAL)
+            return psutil_oserror();
+        if (ncpus > INT_MAX / 2) {
+            PyErr_SetString(
+                PyExc_OverflowError,
+                "could not allocate "
+                "a large enough CPU set"
+            );
+            return NULL;
+        }
+        ncpus = ncpus * 2;
+    }
+
+    py_list = PyList_New(0);
+    if (py_list == NULL)
+        goto error;
+
+    cpucount_s = CPU_COUNT_S(setsize, mask);
+    for (cpu = 0, count = cpucount_s; count; cpu++) {
+        if (CPU_ISSET_S(cpu, setsize, mask)) {
+            if (!pylist_append_obj(py_list, PyLong_FromLong(cpu)))
+                goto error;
+            --count;
+        }
+    }
+    CPU_FREE(mask);
+    return py_list;
+
+error:
+    if (mask)
+        CPU_FREE(mask);
+    Py_XDECREF(py_list);
+    return NULL;
+}
+
+
+// Set process CPU affinity; expects a bitmask.
+PyObject *
+psutil_proc_cpu_affinity_set(PyObject *self, PyObject *args) {
+    cpu_set_t cpu_set;
+    size_t len;
+    pid_t pid;
+    Py_ssize_t i, seq_len;
+    PyObject *py_cpu_set;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "O", &pid, &py_cpu_set))
+        return NULL;
+
+    if (!PySequence_Check(py_cpu_set)) {
+        return PyErr_Format(
+            PyExc_TypeError,
+            "sequence argument expected, got %R",
+            Py_TYPE(py_cpu_set)
+        );
+    }
+
+    seq_len = PySequence_Size(py_cpu_set);
+    if (seq_len < 0) {
+        return NULL;
+    }
+    CPU_ZERO(&cpu_set);
+    for (i = 0; i < seq_len; i++) {
+        PyObject *item = PySequence_GetItem(py_cpu_set, i);
+        if (!item) {
+            return NULL;
+        }
+        long value = PyLong_AsLong(item);
+        Py_XDECREF(item);
+        if ((value == -1) || PyErr_Occurred()) {
+            if (!PyErr_Occurred())
+                PyErr_SetString(PyExc_ValueError, "invalid CPU value");
+            return NULL;
+        }
+        CPU_SET(value, &cpu_set);
+    }
+
+    len = sizeof(cpu_set);
+    if (sched_setaffinity(pid, len, &cpu_set)) {
+        return psutil_oserror();
+    }
+
+    Py_RETURN_NONE;
+}
+#endif  // PSUTIL_HAS_CPU_AFFINITY
diff --git a/psutil/arch/netbsd/cpu.c b/psutil/arch/netbsd/cpu.c
new file mode 100644
index 0000000000..6142fe3800
--- /dev/null
+++ b/psutil/arch/netbsd/cpu.c
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sched.h>
+#include <sys/sysctl.h>
+#include <uvm/uvm_extern.h>
+
+#include "../../arch/all/init.h"
+
+// CPU related functions. Original code was refactored and moved from
+// psutil/arch/netbsd/specific.c in 2023 (and was moved in there previously
+// already) from cset 84219ad. For reference, here's the git history with
+// original(ish) implementations:
+// - per CPU times: 312442ad2a5b5d0c608476c5ab3e267735c3bc59 (Jan 2016)
+// - CPU stats: a991494e4502e1235ebc62b5ba450287d0dedec0 (Jan 2016)
+
+
+PyObject *
+psutil_cpu_stats(PyObject *self, PyObject *args) {
+    struct uvmexp_sysctl uv;
+    int uvmexp_mib[] = {CTL_VM, VM_UVMEXP2};
+
+    // https://man.netbsd.org/man9/uvm.9
+    if (psutil_sysctl(uvmexp_mib, 2, &uv, sizeof(uv)) != 0)
+        return NULL;
+
+    return Py_BuildValue(
+        "KKKKKKK",
+        (uint64_t)uv.swtch,  // ctx switches
+        (uint64_t)uv.intrs,  // interrupts
+        (uint64_t)uv.softs,  // soft interrupts
+        (uint64_t)uv.syscalls,  // syscalls
+        (uint64_t)uv.traps,  // traps
+        (uint64_t)uv.faults,  // faults
+        (uint64_t)uv.forks  // forks
+    );
+}
+
+
+PyObject *
+psutil_per_cpu_times(PyObject *self, PyObject *args) {
+    int mib[3];
+    int ncpu;
+    size_t len;
+    size_t size;
+    int i;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    // retrieve the number of cpus
+    mib[0] = CTL_HW;
+    mib[1] = HW_NCPU;
+    if (psutil_sysctl(mib, 2, &ncpu, sizeof(ncpu)) != 0)
+        goto error;
+
+    uint64_t cpu_time[CPUSTATES];
+
+    for (i = 0; i < ncpu; i++) {
+        // per-cpu info
+        mib[0] = CTL_KERN;
+        mib[1] = KERN_CP_TIME;
+        mib[2] = i;
+        if (psutil_sysctl(mib, 3, &cpu_time, sizeof(cpu_time)) != 0)
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(ddddd)",
+                (double)cpu_time[CP_USER] / CLOCKS_PER_SEC,
+                (double)cpu_time[CP_NICE] / CLOCKS_PER_SEC,
+                (double)cpu_time[CP_SYS] / CLOCKS_PER_SEC,
+                (double)cpu_time[CP_IDLE] / CLOCKS_PER_SEC,
+                (double)cpu_time[CP_INTR] / CLOCKS_PER_SEC
+            ))
+        {
+            goto error;
+        }
+    }
+
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    return NULL;
+}
diff --git a/psutil/arch/netbsd/disk.c b/psutil/arch/netbsd/disk.c
new file mode 100644
index 0000000000..7f817248cb
--- /dev/null
+++ b/psutil/arch/netbsd/disk.c
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Disk related functions. Original code was refactored and moved from
+// psutil/arch/netbsd/specific.c in 2023 (and was moved in there previously
+// already) from cset 84219ad. For reference, here's the git history with
+// original(ish) implementations:
+// - disk IO counters: 312442ad2a5b5d0c608476c5ab3e267735c3bc59 (Jan 2016)
+
+#include <Python.h>
+#include <sys/sysctl.h>
+#include <sys/disk.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_disk_io_counters(PyObject *self, PyObject *args) {
+    int i, dk_ndrive;
+    int mib[3];
+    struct io_sysctl *stats = NULL;
+    size_t stats_len;
+    PyObject *py_disk_info = NULL;
+    PyObject *py_retdict = PyDict_New();
+
+    if (py_retdict == NULL)
+        return NULL;
+
+    mib[0] = CTL_HW;
+    mib[1] = HW_IOSTATS;
+    mib[2] = sizeof(struct io_sysctl);
+
+    // Use helper to allocate and fill buffer
+    if (psutil_sysctl_malloc(mib, 3, (char **)&stats, &stats_len) == -1)
+        goto error;
+
+    dk_ndrive = (int)(stats_len / sizeof(struct io_sysctl));
+
+    for (i = 0; i < dk_ndrive; i++) {
+        py_disk_info = Py_BuildValue(
+            "(KKKK)",
+            stats[i].rxfer,
+            stats[i].wxfer,
+            stats[i].rbytes,
+            stats[i].wbytes
+        );
+        if (!py_disk_info)
+            goto error;
+        if (PyDict_SetItemString(py_retdict, stats[i].name, py_disk_info))
+            goto error;
+        Py_DECREF(py_disk_info);
+    }
+
+    free(stats);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_disk_info);
+    Py_DECREF(py_retdict);
+    if (stats != NULL)
+        free(stats);
+    return NULL;
+}
diff --git a/psutil/arch/netbsd/init.h b/psutil/arch/netbsd/init.h
new file mode 100644
index 0000000000..2949da7856
--- /dev/null
+++ b/psutil/arch/netbsd/init.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'.
+ * Copyright (c) 2015, Ryo ONODERA.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/types.h>
+
+int _psutil_pids(pid_t **pids_array, int *pids_count);
+
+PyObject *psutil_cpu_stats(PyObject *self, PyObject *args);
+PyObject *psutil_disk_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_net_connections(PyObject *, PyObject *);
+PyObject *psutil_per_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cmdline(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cwd(PyObject *self, PyObject *args);
+PyObject *psutil_proc_exe(PyObject *self, PyObject *args);
+PyObject *psutil_proc_net_connections(PyObject *, PyObject *);
+PyObject *psutil_proc_net_connections(PyObject *self, PyObject *args);
+PyObject *psutil_proc_num_fds(PyObject *self, PyObject *args);
+PyObject *psutil_proc_num_threads(PyObject *self, PyObject *args);
+PyObject *psutil_proc_threads(PyObject *self, PyObject *args);
+PyObject *psutil_virtual_mem(PyObject *self, PyObject *args);
diff --git a/psutil/arch/netbsd/mem.c b/psutil/arch/netbsd/mem.c
new file mode 100644
index 0000000000..870aa1f0dc
--- /dev/null
+++ b/psutil/arch/netbsd/mem.c
@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Memory related functions. Original code was refactored and moved from
+// psutil/arch/netbsd/specific.c in 2023 (and was moved in there previously
+// already) from cset 84219ad. For reference, here's the git history with
+// original(ish) implementations:
+// - virtual memory: 0749a69c01b374ca3e2180aaafc3c95e3b2d91b9 (Oct 2016)
+// - swap memory: 312442ad2a5b5d0c608476c5ab3e267735c3bc59 (Jan 2016)
+
+#include <Python.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/sysctl.h>
+#include <sys/vmmeter.h>
+#include <uvm/uvm_extern.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_virtual_mem(PyObject *self, PyObject *args) {
+    struct uvmexp_sysctl uv;
+    struct vmtotal vmdata;
+    int uvmexp_mib[] = {CTL_VM, VM_UVMEXP2};
+    int vmmeter_mib[] = {CTL_VM, VM_METER};
+    unsigned long long total, free, active, inactive, wired, cached;
+    unsigned long long buffers, shared, used, avail;
+    double percent;
+    long pagesize = psutil_getpagesize();
+    PyObject *dict = PyDict_New();
+
+    if (dict == NULL)
+        return NULL;
+
+    if (psutil_sysctl(uvmexp_mib, 2, &uv, sizeof(uv)) != 0)
+        goto error;
+    if (psutil_sysctl(vmmeter_mib, 2, &vmdata, sizeof(vmdata)) != 0)
+        goto error;
+
+    total = (unsigned long long)uv.npages << uv.pageshift;
+    free = (unsigned long long)uv.free << uv.pageshift;
+    active = (unsigned long long)uv.active << uv.pageshift;
+    inactive = (unsigned long long)uv.inactive << uv.pageshift;
+    wired = (unsigned long long)uv.wired << uv.pageshift;
+
+    // Updated by kernel every 5 secs. We have:
+    //   u_int32_t t_vmshr;  /* shared virtual memory */
+    //   u_int32_t t_avmshr; /* active shared virtual memory */
+    //   u_int32_t t_rmshr;  /* shared real memory */
+    // We return `t_rmshr` (real shared). Reason: report physical
+    // resource pressure rather than just kernel bookkeeping.
+    shared = (unsigned long long)vmdata.t_rmshr * pagesize;
+
+    // Note: on OpenBSD 'cached' and 'buffers' are aliases; not on NetBSD.
+    buffers = (unsigned long long)uv.filepages << uv.pageshift;
+
+    // same as 'vmstat -s' (2 distinct values)
+    cached = (unsigned long long)(uv.filepages + uv.execpages) * pagesize;
+
+    // Before avail was calculated as (inactive + cached + free), same
+    // as zabbix, but it turned out it could exceed total (see #2233),
+    // so zabbix seems to be wrong. Htop calculates it differently, and
+    // the used value seem more realistic, so let's match htop.
+    // https://github.com/htop-dev/htop/blob/e7f447b/netbsd/NetBSDProcessList.c#L162
+    // https://github.com/zabbix/zabbix/blob/af5e0f8/src/libs/zbxsysinfo/netbsd/memory.c#L135
+    used = active + wired;
+    avail = total - used;
+    percent = psutil_usage_percent((double)(total - avail), (double)total, 1);
+
+    if (!(pydict_add(dict, "total", "K", total)
+          | pydict_add(dict, "available", "K", avail)
+          | pydict_add(dict, "percent", "d", percent)
+          | pydict_add(dict, "used", "K", used)
+          | pydict_add(dict, "free", "K", free)
+          | pydict_add(dict, "active", "K", active)
+          | pydict_add(dict, "inactive", "K", inactive)
+          | pydict_add(dict, "buffers", "K", buffers)
+          | pydict_add(dict, "wired", "K", wired)
+          | pydict_add(dict, "cached", "K", cached)
+          | pydict_add(dict, "shared", "K", shared)))
+        goto error;
+
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    return NULL;
+}
diff --git a/psutil/arch/netbsd/pids.c b/psutil/arch/netbsd/pids.c
new file mode 100644
index 0000000000..ebf5127f06
--- /dev/null
+++ b/psutil/arch/netbsd/pids.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <stdlib.h>
+#include <kvm.h>
+#include <sys/sysctl.h>
+
+#include "../../arch/all/init.h"
+
+
+int
+_psutil_pids(pid_t **pids_array, int *pids_count) {
+    char errbuf[_POSIX2_LINE_MAX];
+    kvm_t *kd;
+    struct kinfo_proc2 *proc_list = NULL;
+    struct kinfo_proc2 *result;
+    int cnt;
+    size_t i;
+
+    *pids_array = NULL;
+    *pids_count = 0;
+
+    kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);
+    if (kd == NULL) {
+        psutil_runtime_error("kvm_openfiles() failed: %s", errbuf);
+        return -1;
+    }
+
+    result = kvm_getproc2(
+        kd, KERN_PROC_ALL, 0, sizeof(struct kinfo_proc2), &cnt
+    );
+    if (result == NULL) {
+        psutil_runtime_error("kvm_getproc2() failed");
+        kvm_close(kd);
+        return -1;
+    }
+
+    if (cnt == 0) {
+        psutil_runtime_error("no PIDs found");
+        kvm_close(kd);
+        return -1;
+    }
+
+    *pids_array = malloc(cnt * sizeof(pid_t));
+    if (!*pids_array) {
+        PyErr_NoMemory();
+        kvm_close(kd);
+        return -1;
+    }
+
+    for (i = 0; i < (size_t)cnt; i++) {
+        (*pids_array)[i] = result[i].p_pid;
+    }
+
+    *pids_count = cnt;
+    kvm_close(kd);
+    return 0;
+}
diff --git a/psutil/arch/netbsd/proc.c b/psutil/arch/netbsd/proc.c
new file mode 100644
index 0000000000..8b8280aa9c
--- /dev/null
+++ b/psutil/arch/netbsd/proc.c
@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysctl.h>
+#include <kvm.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_proc_cwd(PyObject *self, PyObject *args) {
+    long pid;
+    char path[MAXPATHLEN];
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+#ifdef KERN_PROC_CWD  // available since NetBSD 99.43
+    int name[] = {CTL_KERN, KERN_PROC_ARGS, pid, KERN_PROC_CWD};
+    size_t pathlen = sizeof(path);
+
+    if (sysctl(name, 4, path, &pathlen, NULL, 0) != 0)
+        goto error;
+#else
+    char buf[32];
+    ssize_t len;
+
+    str_format(buf, sizeof(buf), "/proc/%d/cwd", (int)pid);
+    len = readlink(buf, path, sizeof(path) - 1);
+    if (len == -1)
+        goto error;
+    path[len] = '\0';
+#endif
+
+    return PyUnicode_DecodeFSDefault(path);
+
+error:
+    if (errno == ENOENT)
+        psutil_oserror_nsp("sysctl -> ENOENT");
+    else
+        psutil_oserror();
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_exe(PyObject *self, PyObject *args) {
+    pid_t pid;
+    char pathname[MAXPATHLEN];
+    int error;
+    int mib[4];
+    int ret;
+    size_t size;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if (pid == 0) {
+        // else returns ENOENT
+        return PyUnicode_FromString("");
+    }
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC_ARGS;
+    mib[2] = pid;
+    mib[3] = KERN_PROC_PATHNAME;
+
+    size = sizeof(pathname);
+    error = sysctl(mib, 4, pathname, &size, NULL, 0);
+    if (error == -1) {
+        return psutil_oserror_wsyscall("sysctl(KERN_PROC_PATHNAME)");
+    }
+
+    if (size == 0 || strlen(pathname) == 0) {
+        ret = psutil_pid_exists(pid);
+        if (ret == -1) {
+            psutil_oserror();
+            return NULL;
+        }
+        else if (ret == 0)
+            return psutil_oserror_nsp("psutil_pid_exists -> 0");
+        else
+            str_copy(pathname, sizeof(pathname), "");
+    }
+
+    return PyUnicode_DecodeFSDefault(pathname);
+}
+
+
+PyObject *
+psutil_proc_num_threads(PyObject *self, PyObject *args) {
+    long pid;
+    struct kinfo_proc2 kp;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if (psutil_kinfo_proc(pid, &kp) == -1)
+        return NULL;
+    return Py_BuildValue("l", (long)kp.p_nlwps);
+}
+
+
+PyObject *
+psutil_proc_threads(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int mib[5];
+    int i, nlwps;
+    ssize_t st;
+    size_t size;
+    struct kinfo_lwp *kl = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_LWP;
+    mib[2] = pid;
+    mib[3] = sizeof(struct kinfo_lwp);
+    mib[4] = 0;
+
+    // first query size
+    st = sysctl(mib, 5, NULL, &size, NULL, 0);
+    if (st == -1) {
+        psutil_oserror();
+        goto error;
+    }
+    if (size == 0) {
+        psutil_oserror_nsp("sysctl (size = 0)");
+        goto error;
+    }
+
+    // set slot count for NetBSD KERN_LWP
+    mib[4] = size / sizeof(size_t);
+
+    if (psutil_sysctl_malloc(mib, __arraycount(mib), (char **)&kl, &size) != 0)
+    {
+        goto error;
+    }
+    if (size == 0) {
+        psutil_oserror_nsp("sysctl (size = 0)");
+        goto error;
+    }
+
+    nlwps = (int)(size / sizeof(struct kinfo_lwp));
+    for (i = 0; i < nlwps; i++) {
+        if (kl[i].l_stat == LSIDL || kl[i].l_stat == LSZOMB)
+            continue;
+        // XXX: return 2 "user" times, no "system" time available
+        if (!pylist_append_fmt(
+                py_retlist,
+                "idd",
+                kl[i].l_lid,
+                PSUTIL_KPT2DOUBLE(kl[i].l_rtime),
+                PSUTIL_KPT2DOUBLE(kl[i].l_rtime)
+            ))
+        {
+            goto error;
+        }
+    }
+
+    free(kl);
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    if (kl != NULL)
+        free(kl);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_cmdline(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int mib[4];
+    int st;
+    int attempt = 0;
+    int max_attempts = 50;
+    size_t len = 0;
+    size_t pos = 0;
+    char *procargs = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC_ARGS;
+    mib[2] = pid;
+    mib[3] = KERN_PROC_ARGV;
+
+    while (1) {
+        if (psutil_sysctl_malloc(
+                mib, __arraycount(mib), (char **)&procargs, &len
+            )
+            != 0)
+        {
+            if (errno == EBUSY) {
+                // Usually happens with TestProcess.test_long_cmdline. See:
+                // https://github.com/giampaolo/psutil/issues/2250
+                // psutil_sysctl_malloc() sets a Python exception before
+                // returning -1; clear it before retrying or returning so we
+                // don't leave a pending exception on a non-NULL return value.
+                PyErr_Clear();
+                attempt += 1;
+                if (attempt < max_attempts) {
+                    psutil_debug("proc %zu cmdline(): retry on EBUSY", pid);
+                    continue;
+                }
+                else {
+                    psutil_debug(
+                        "proc %zu cmdline(): return [] due to EBUSY", pid
+                    );
+                    PyErr_Clear();
+                    return py_retlist;
+                }
+            }
+            goto error;
+        }
+        break;
+    }
+
+    if (len > 0) {
+        while (pos < len) {
+            if (!pylist_append_obj(
+                    py_retlist, PyUnicode_DecodeFSDefault(&procargs[pos])
+                ))
+                goto error;
+            pos = pos + strlen(&procargs[pos]) + 1;
+        }
+    }
+
+    free(procargs);
+    PyErr_Clear();
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    if (procargs != NULL)
+        free(procargs);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_num_fds(PyObject *self, PyObject *args) {
+    long pid;
+    int cnt;
+
+    struct kinfo_file *freep;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    errno = 0;
+    freep = kinfo_getfile(pid, &cnt);
+    if (freep == NULL) {
+        psutil_raise_for_pid(pid, "kinfo_getfile()");
+        return NULL;
+    }
+    free(freep);
+
+    return Py_BuildValue("i", cnt);
+}
diff --git a/psutil/arch/netbsd/socks.c b/psutil/arch/netbsd/socks.c
new file mode 100644
index 0000000000..33ff093923
--- /dev/null
+++ b/psutil/arch/netbsd/socks.c
@@ -0,0 +1,471 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'.
+ * Copyright (c) 2015, Ryo ONODERA.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysctl.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <sys/queue.h>
+#include <sys/un.h>
+
+#include "../../arch/all/init.h"
+
+
+// kinfo_file results
+struct kif {
+    SLIST_ENTRY(kif) kifs;
+    struct kinfo_file *kif;
+    char *buf;
+    int has_buf;
+};
+
+// kinfo_file results list
+SLIST_HEAD(kifhead, kif) kihead = SLIST_HEAD_INITIALIZER(kihead);
+
+
+// kinfo_pcb results
+struct kpcb {
+    SLIST_ENTRY(kpcb) kpcbs;
+    struct kinfo_pcb *kpcb;
+    struct kinfo_pcb *buf;
+    int has_buf;
+};
+
+// kinfo_pcb results list
+SLIST_HEAD(kpcbhead, kpcb) kpcbhead = SLIST_HEAD_INITIALIZER(kpcbhead);
+
+
+// Initialize kinfo_file results list.
+static void
+psutil_kiflist_init(void) {
+    SLIST_INIT(&kihead);
+}
+
+
+// Clear kinfo_file results list.
+static void
+psutil_kiflist_clear(void) {
+    while (!SLIST_EMPTY(&kihead)) {
+        struct kif *kif = SLIST_FIRST(&kihead);
+        if (kif->has_buf == 1)
+            free(kif->buf);
+        free(kif);
+        SLIST_REMOVE_HEAD(&kihead, kifs);
+    }
+}
+
+
+// Initialize kinof_pcb result list.
+static void
+psutil_kpcblist_init(void) {
+    SLIST_INIT(&kpcbhead);
+}
+
+
+// Clear kinof_pcb result list.
+static void
+psutil_kpcblist_clear(void) {
+    while (!SLIST_EMPTY(&kpcbhead)) {
+        struct kpcb *kpcb = SLIST_FIRST(&kpcbhead);
+        if (kpcb->has_buf == 1)
+            free(kpcb->buf);
+        free(kpcb);
+        SLIST_REMOVE_HEAD(&kpcbhead, kpcbs);
+    }
+}
+
+
+// Get all open files including socket.
+static int
+psutil_get_files(void) {
+    size_t len;
+    size_t j;
+    int mib[6];
+    char *buf = NULL;
+    off_t offset;
+    int ret;
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_FILE2;
+    mib[2] = KERN_FILE_BYFILE;
+    mib[3] = 0;
+    mib[4] = sizeof(struct kinfo_file);
+    mib[5] = 0;
+
+    // Walks the whole kernel file table, may take a while.
+    Py_BEGIN_ALLOW_THREADS
+    ret = sysctl(mib, 6, NULL, &len, NULL, 0);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    offset = len % sizeof(off_t);
+    mib[5] = len / sizeof(struct kinfo_file);
+
+    if ((buf = malloc(len + offset)) == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    ret = sysctl(mib, 6, buf + offset, &len, NULL, 0);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    len /= sizeof(struct kinfo_file);
+    struct kinfo_file *ki = (struct kinfo_file *)(buf + offset);
+
+    if (len > 0) {
+        for (j = 0; j < len; j++) {
+            struct kif *kif = malloc(sizeof(struct kif));
+            if (kif == NULL) {
+                PyErr_NoMemory();
+                goto error;
+            }
+            kif->kif = &ki[j];
+            if (j == 0) {
+                kif->has_buf = 1;
+                kif->buf = buf;
+            }
+            else {
+                kif->has_buf = 0;
+                kif->buf = NULL;
+            }
+            SLIST_INSERT_HEAD(&kihead, kif, kifs);
+        }
+    }
+    else {
+        free(buf);
+    }
+
+    return 0;
+
+error:
+    if (buf != NULL)
+        free(buf);
+    return -1;
+}
+
+
+// Get open sockets.
+static int
+psutil_get_sockets(const char *name) {
+    size_t namelen;
+    int mib[8];
+    struct kinfo_pcb *pcb = NULL;
+    size_t len;
+    size_t j;
+    int ret;
+
+    memset(mib, 0, sizeof(mib));
+
+    if (sysctlnametomib(name, mib, &namelen) == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    ret = sysctl(mib, __arraycount(mib), NULL, &len, NULL, 0);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    if ((pcb = malloc(len)) == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+    memset(pcb, 0, len);
+
+    mib[6] = sizeof(*pcb);
+    mib[7] = len / sizeof(*pcb);
+
+    Py_BEGIN_ALLOW_THREADS
+    ret = sysctl(mib, __arraycount(mib), pcb, &len, NULL, 0);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    len /= sizeof(struct kinfo_pcb);
+    struct kinfo_pcb *kp = (struct kinfo_pcb *)pcb;
+
+    if (len > 0) {
+        for (j = 0; j < len; j++) {
+            struct kpcb *kpcb = malloc(sizeof(struct kpcb));
+            if (kpcb == NULL) {
+                PyErr_NoMemory();
+                goto error;
+            }
+            kpcb->kpcb = &kp[j];
+            if (j == 0) {
+                kpcb->has_buf = 1;
+                kpcb->buf = pcb;
+            }
+            else {
+                kpcb->has_buf = 0;
+                kpcb->buf = NULL;
+            }
+            SLIST_INSERT_HEAD(&kpcbhead, kpcb, kpcbs);
+        }
+    }
+    else {
+        free(pcb);
+    }
+
+    return 0;
+
+error:
+    if (pcb != NULL)
+        free(pcb);
+    return -1;
+}
+
+
+// Collect open file and connections.
+static int
+psutil_get_info(char *kind) {
+    if (strcmp(kind, "inet") == 0) {
+        if (psutil_get_sockets("net.inet.tcp.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.inet.udp.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.inet6.tcp6.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.inet6.udp6.pcblist") != 0)
+            return -1;
+    }
+    else if (strcmp(kind, "inet4") == 0) {
+        if (psutil_get_sockets("net.inet.tcp.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.inet.udp.pcblist") != 0)
+            return -1;
+    }
+    else if (strcmp(kind, "inet6") == 0) {
+        if (psutil_get_sockets("net.inet6.tcp6.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.inet6.udp6.pcblist") != 0)
+            return -1;
+    }
+    else if (strcmp(kind, "tcp") == 0) {
+        if (psutil_get_sockets("net.inet.tcp.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.inet6.tcp6.pcblist") != 0)
+            return -1;
+    }
+    else if (strcmp(kind, "tcp4") == 0) {
+        if (psutil_get_sockets("net.inet.tcp.pcblist") != 0)
+            return -1;
+    }
+    else if (strcmp(kind, "tcp6") == 0) {
+        if (psutil_get_sockets("net.inet6.tcp6.pcblist") != 0)
+            return -1;
+    }
+    else if (strcmp(kind, "udp") == 0) {
+        if (psutil_get_sockets("net.inet.udp.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.inet6.udp6.pcblist") != 0)
+            return -1;
+    }
+    else if (strcmp(kind, "udp4") == 0) {
+        if (psutil_get_sockets("net.inet.udp.pcblist") != 0)
+            return -1;
+    }
+    else if (strcmp(kind, "udp6") == 0) {
+        if (psutil_get_sockets("net.inet6.udp6.pcblist") != 0)
+            return -1;
+    }
+    else if (strcmp(kind, "unix") == 0) {
+        if (psutil_get_sockets("net.local.stream.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.local.seqpacket.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.local.dgram.pcblist") != 0)
+            return -1;
+    }
+    else if (strcmp(kind, "all") == 0) {
+        if (psutil_get_sockets("net.inet.tcp.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.inet.udp.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.inet6.tcp6.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.inet6.udp6.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.local.stream.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.local.seqpacket.pcblist") != 0)
+            return -1;
+        if (psutil_get_sockets("net.local.dgram.pcblist") != 0)
+            return -1;
+    }
+    else {
+        PyErr_SetString(PyExc_ValueError, "invalid kind value");
+        return -1;
+    }
+    return 0;
+}
+
+
+/*
+ * Return system-wide connections (unless a pid != -1 is passed).
+ */
+PyObject *
+psutil_net_connections(PyObject *self, PyObject *args) {
+    char laddr[PATH_MAX];
+    char raddr[PATH_MAX];
+    char *kind;
+    int32_t lport;
+    int32_t rport;
+    int32_t status;
+    pid_t pid;
+    PyObject *py_laddr = NULL;
+    PyObject *py_raddr = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "s", &pid, &kind)) {
+        goto error;
+    }
+
+    psutil_kiflist_init();
+    psutil_kpcblist_init();
+
+    if (psutil_get_files() != 0)
+        goto error;
+    if (psutil_get_info(kind) != 0)
+        goto error;
+
+    struct kif *k;
+    SLIST_FOREACH(k, &kihead, kifs) {
+        struct kpcb *kp;
+        if ((pid != -1) && (k->kif->ki_pid != (unsigned int)pid))
+            continue;
+        SLIST_FOREACH(kp, &kpcbhead, kpcbs) {
+            if (k->kif->ki_fdata != kp->kpcb->ki_sockaddr)
+                continue;
+
+            // IPv4 or IPv6
+            if ((kp->kpcb->ki_family == AF_INET)
+                || (kp->kpcb->ki_family == AF_INET6))
+            {
+                if (kp->kpcb->ki_family == AF_INET) {
+                    // IPv4
+                    struct sockaddr_in *sin_src = (struct sockaddr_in *)&kp
+                                                      ->kpcb->ki_src;
+                    struct sockaddr_in *sin_dst = (struct sockaddr_in *)&kp
+                                                      ->kpcb->ki_dst;
+                    // source addr and port
+                    inet_ntop(
+                        AF_INET, &sin_src->sin_addr, laddr, sizeof(laddr)
+                    );
+                    lport = ntohs(sin_src->sin_port);
+                    // remote addr and port
+                    inet_ntop(
+                        AF_INET, &sin_dst->sin_addr, raddr, sizeof(raddr)
+                    );
+                    rport = ntohs(sin_dst->sin_port);
+                }
+                else {
+                    // IPv6
+                    struct sockaddr_in6 *sin6_src = (struct sockaddr_in6 *)&kp
+                                                        ->kpcb->ki_src;
+                    struct sockaddr_in6 *sin6_dst = (struct sockaddr_in6 *)&kp
+                                                        ->kpcb->ki_dst;
+                    // local addr and port
+                    inet_ntop(
+                        AF_INET6, &sin6_src->sin6_addr, laddr, sizeof(laddr)
+                    );
+                    lport = ntohs(sin6_src->sin6_port);
+                    // remote addr and port
+                    inet_ntop(
+                        AF_INET6, &sin6_dst->sin6_addr, raddr, sizeof(raddr)
+                    );
+                    rport = ntohs(sin6_dst->sin6_port);
+                }
+
+                // status
+                if (kp->kpcb->ki_type == SOCK_STREAM)
+                    status = kp->kpcb->ki_tstate;
+                else
+                    status = PSUTIL_CONN_NONE;
+
+                // build addr tuple
+                py_laddr = Py_BuildValue("(si)", laddr, lport);
+                if (!py_laddr)
+                    goto error;
+                if (rport != 0)
+                    py_raddr = Py_BuildValue("(si)", raddr, rport);
+                else
+                    py_raddr = Py_BuildValue("()");
+                if (!py_raddr)
+                    goto error;
+            }
+            else if (kp->kpcb->ki_family == AF_UNIX) {
+                // UNIX sockets
+                struct sockaddr_un *sun_src = (struct sockaddr_un *)&kp->kpcb
+                                                  ->ki_src;
+                struct sockaddr_un *sun_dst = (struct sockaddr_un *)&kp->kpcb
+                                                  ->ki_dst;
+                str_copy(laddr, sizeof(sun_src->sun_path), sun_src->sun_path);
+                str_copy(raddr, sizeof(sun_dst->sun_path), sun_dst->sun_path);
+                status = PSUTIL_CONN_NONE;
+                py_laddr = PyUnicode_DecodeFSDefault(laddr);
+                if (!py_laddr)
+                    goto error;
+                py_raddr = PyUnicode_DecodeFSDefault(raddr);
+                if (!py_raddr)
+                    goto error;
+            }
+            else {
+                continue;
+            }
+
+            // append tuple to list
+            if (!pylist_append_fmt(
+                    py_retlist,
+                    "(iiiOOii)",
+                    k->kif->ki_fd,
+                    kp->kpcb->ki_family,
+                    kp->kpcb->ki_type,
+                    py_laddr,
+                    py_raddr,
+                    status,
+                    k->kif->ki_pid
+                ))
+            {
+                goto error;
+            }
+            Py_DECREF(py_laddr);
+            py_laddr = NULL;
+            Py_DECREF(py_raddr);
+            py_raddr = NULL;
+        }
+    }
+
+    psutil_kiflist_clear();
+    psutil_kpcblist_clear();
+    return py_retlist;
+
+error:
+    psutil_kiflist_clear();
+    psutil_kpcblist_clear();
+    Py_DECREF(py_retlist);
+    Py_XDECREF(py_laddr);
+    Py_XDECREF(py_raddr);
+    return NULL;
+}
diff --git a/psutil/arch/openbsd/cpu.c b/psutil/arch/openbsd/cpu.c
new file mode 100644
index 0000000000..d1906a02ff
--- /dev/null
+++ b/psutil/arch/openbsd/cpu.c
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysctl.h>
+#include <sys/sched.h>  // for CPUSTATES & CP_*
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_cpu_times(PyObject *self, PyObject *args) {
+    // KERN_CPTIME returns times averaged across CPUs, so we sum the
+    // per-CPU counters instead, like the other platforms do.
+    u_int64_t cpu_time[CPUSTATES] = {0};
+    u_int64_t percpu_time[CPUSTATES];
+    int mib[3];
+    int i, j, ncpu;
+
+    mib[0] = CTL_HW;
+    mib[1] = HW_NCPU;
+    if (psutil_sysctl(mib, 2, &ncpu, sizeof(ncpu)) != 0)
+        return NULL;
+
+    for (i = 0; i < ncpu; i++) {
+        mib[0] = CTL_KERN;
+        mib[1] = KERN_CPTIME2;
+        mib[2] = i;
+        if (psutil_sysctl(mib, 3, &percpu_time, sizeof(percpu_time)) != 0)
+            return NULL;
+        for (j = 0; j < CPUSTATES; j++)
+            cpu_time[j] += percpu_time[j];
+    }
+
+    return Py_BuildValue(
+        "(ddddd)",
+        (double)cpu_time[CP_USER] / CLOCKS_PER_SEC,
+        (double)cpu_time[CP_NICE] / CLOCKS_PER_SEC,
+        (double)cpu_time[CP_SYS] / CLOCKS_PER_SEC,
+        (double)cpu_time[CP_IDLE] / CLOCKS_PER_SEC,
+        (double)cpu_time[CP_INTR] / CLOCKS_PER_SEC
+    );
+}
+
+
+PyObject *
+psutil_per_cpu_times(PyObject *self, PyObject *args) {
+    int mib[3];
+    int ncpu;
+    size_t len;
+    int i;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    // retrieve the number of cpus
+    mib[0] = CTL_HW;
+    mib[1] = HW_NCPU;
+    if (psutil_sysctl(mib, 2, &ncpu, sizeof(ncpu)) != 0)
+        goto error;
+
+    uint64_t cpu_time[CPUSTATES];
+
+    for (i = 0; i < ncpu; i++) {
+        mib[0] = CTL_KERN;
+        mib[1] = KERN_CPTIME2;
+        mib[2] = i;
+
+        if (psutil_sysctl(mib, 3, &cpu_time, sizeof(cpu_time)) != 0)
+            goto error;
+
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(ddddd)",
+                (double)cpu_time[CP_USER] / CLOCKS_PER_SEC,
+                (double)cpu_time[CP_NICE] / CLOCKS_PER_SEC,
+                (double)cpu_time[CP_SYS] / CLOCKS_PER_SEC,
+                (double)cpu_time[CP_IDLE] / CLOCKS_PER_SEC,
+                (double)cpu_time[CP_INTR] / CLOCKS_PER_SEC
+            ))
+        {
+            goto error;
+        }
+    }
+
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    return NULL;
+}
+
+
+PyObject *
+psutil_cpu_stats(PyObject *self, PyObject *args) {
+    struct uvmexp uv;
+    int uvmexp_mib[] = {CTL_VM, VM_UVMEXP};
+
+    if (psutil_sysctl(uvmexp_mib, 2, &uv, sizeof(uv)) != 0)
+        return NULL;
+
+    return Py_BuildValue(
+        "IIIIIII",
+        uv.swtch,  // ctx switches
+        uv.intrs,  // interrupts - XXX always 0, will be determined via /proc
+        uv.softs,  // soft interrupts
+        uv.syscalls,  // syscalls - XXX always 0
+        uv.traps,  // traps
+        uv.faults,  // faults
+        uv.forks  // forks
+    );
+}
+
+
+PyObject *
+psutil_cpu_freq(PyObject *self, PyObject *args) {
+    int freq;
+    int mib[2] = {CTL_HW, HW_CPUSPEED};
+
+    // On VirtualBox I get "sysctl hw.cpuspeed=2593" (never changing),
+    // which appears to be expressed in Mhz.
+    if (psutil_sysctl(mib, 2, &freq, sizeof(freq)) != 0)
+        return NULL;
+
+    return Py_BuildValue("i", freq);
+}
diff --git a/psutil/arch/openbsd/disk.c b/psutil/arch/openbsd/disk.c
new file mode 100644
index 0000000000..36d980d70f
--- /dev/null
+++ b/psutil/arch/openbsd/disk.c
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysctl.h>
+#include <sys/disk.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_disk_io_counters(PyObject *self, PyObject *args) {
+    int i, dk_ndrive, mib[3];
+    size_t len;
+    struct diskstats *stats = NULL;
+
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_disk_info = NULL;
+    if (py_retdict == NULL)
+        return NULL;
+
+    mib[0] = CTL_HW;
+    mib[1] = HW_DISKSTATS;
+
+    if (psutil_sysctl_malloc(mib, 2, (char **)&stats, &len) != 0)
+        goto error;
+
+    dk_ndrive = (int)(len / sizeof(struct diskstats));
+
+    for (i = 0; i < dk_ndrive; i++) {
+        py_disk_info = Py_BuildValue(
+            "(KKKK)",
+            stats[i].ds_rxfer,  // num reads
+            stats[i].ds_wxfer,  // num writes
+            stats[i].ds_rbytes,  // read bytes
+            stats[i].ds_wbytes  // write bytes
+        );
+        if (!py_disk_info)
+            goto error;
+        if (PyDict_SetItemString(py_retdict, stats[i].ds_name, py_disk_info))
+            goto error;
+        Py_DECREF(py_disk_info);
+    }
+
+    free(stats);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_disk_info);
+    Py_DECREF(py_retdict);
+    if (stats != NULL)
+        free(stats);
+    return NULL;
+}
diff --git a/psutil/arch/openbsd/init.h b/psutil/arch/openbsd/init.h
new file mode 100644
index 0000000000..8d6879fc0f
--- /dev/null
+++ b/psutil/arch/openbsd/init.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+
+int _psutil_pids(pid_t **pids_array, int *pids_count);
+
+PyObject *psutil_cpu_freq(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_stats(PyObject *self, PyObject *args);
+PyObject *psutil_disk_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_net_connections(PyObject *self, PyObject *args);
+PyObject *psutil_per_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cmdline(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cwd(PyObject *self, PyObject *args);
+PyObject *psutil_proc_num_fds(PyObject *self, PyObject *args);
+PyObject *psutil_proc_threads(PyObject *self, PyObject *args);
+PyObject *psutil_users(PyObject *self, PyObject *args);
+PyObject *psutil_virtual_mem(PyObject *self, PyObject *args);
diff --git a/psutil/arch/openbsd/mem.c b/psutil/arch/openbsd/mem.c
new file mode 100644
index 0000000000..3058862354
--- /dev/null
+++ b/psutil/arch/openbsd/mem.c
@@ -0,0 +1,124 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysctl.h>
+#include <sys/vmmeter.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+
+#include "../../arch/all/init.h"
+
+
+// References
+// ----------
+//
+// top:
+//   https://github.com/openbsd/src/blob/master/usr.bin/top/machine.c
+// zabbix:
+//   https://github.com/zabbix/zabbix/blob/master/src/libs/zbxsysinfo/openbsd/memory.c
+
+PyObject *
+psutil_virtual_mem(PyObject *self, PyObject *args) {
+    int64_t _total;
+    unsigned long long free, active, inactive, wired, cached, shared;
+    unsigned long long total, avail, used, buffers;
+    double percent;
+    int uvmexp_mib[] = {CTL_VM, VM_UVMEXP};
+    int bcstats_mib[] = {CTL_VFS, VFS_GENERIC, VFS_BCACHESTAT};
+    int physmem_mib[] = {CTL_HW, HW_PHYSMEM64};
+    int vmmeter_mib[] = {CTL_VM, VM_METER};
+    struct uvmexp uvmexp;
+    struct bcachestats bcstats;
+    struct vmtotal vmdata;
+    long pagesize = psutil_getpagesize();
+    PyObject *dict = PyDict_New();
+
+    if (dict == NULL)
+        return NULL;
+
+    if (psutil_sysctl(physmem_mib, 2, &_total, sizeof(_total)) != 0)
+        goto error;
+    if (psutil_sysctl(uvmexp_mib, 2, &uvmexp, sizeof(uvmexp)) != 0)
+        goto error;
+    if (psutil_sysctl(bcstats_mib, 3, &bcstats, sizeof(bcstats)) != 0)
+        goto error;
+    if (psutil_sysctl(vmmeter_mib, 2, &vmdata, sizeof(vmdata)) != 0)
+        goto error;
+
+    // psutil uses HW_PHYSMEM64, while "top" uses uvmexp.npages *
+    // pagesize, which is slightly smaller. HW_PHYSMEM64 reflects the
+    // physical (hardware) RAM, so prefer this value. This matches
+    // `sysctl hw.physmem`.
+    total = (unsigned long long)_total;
+
+    // same as 'top' and 'vmstat -s'
+    free = (unsigned long long)uvmexp.free * pagesize;
+
+    // same as 'top' and 'vmstat -s'
+    active = (unsigned long long)uvmexp.active * pagesize;
+
+    // same as 'vmstat -s'
+    inactive = (unsigned long long)uvmexp.inactive * pagesize;
+
+    // same as 'vmstat -s'
+    wired = (unsigned long long)uvmexp.wired * pagesize;
+
+    // Updated by kernel every 5 secs. We have:
+    //   u_int32_t t_vmshr;  /* shared virtual memory */
+    //   u_int32_t t_avmshr; /* active shared virtual memory */
+    //   u_int32_t t_rmshr;  /* shared real memory */
+    // We return `t_rmshr` (real shared). Reason: report physical
+    // resource pressure rather than just kernel bookkeeping.
+    shared = (unsigned long long)vmdata.t_rmshr * pagesize;
+
+    // "top" derives cached memory from `bcstats.numbufpages`, which
+    // technically corresponds to 'buffers' memory:
+    // https://github.com/openbsd/src/blob/master/usr.bin/top/machine.c
+    //
+    // Intuitively, 'cached' memory should instead be
+    // `uvmexp.vnodepages`, described as 'vnode page cache', but it's
+    // always 0, and the struct contains an "XXX" comment, suggesting
+    // that `vnodepages` should probably not be used. This article
+    // suggests that 'buffers' became the primary caching mechanism in
+    // the system:
+    // https://undeadly.org/cgi?action=article;sid=20140908113732
+    //
+    // So, treat 'cached' and 'buffers' as aliases. See:
+    // https://github.com/giampaolo/psutil/issues/2813
+    buffers = (unsigned long long)bcstats.numbufpages * pagesize;
+    cached = buffers;
+
+    // Matches zabbix on FreeBSD (but not on OpenBSD).
+    avail = inactive + cached + free;
+
+    // 'top' calculates this as `total - free`. Zabbix does `active + wired`.
+    // We do `active + wired + cached` (cached memory **is** used memory),
+    // which matches Zabbix on FreeBSD.
+    used = active + wired + cached;
+
+    percent = psutil_usage_percent((double)(total - avail), (double)total, 1);
+
+    if (!(pydict_add(dict, "total", "K", total)
+          | pydict_add(dict, "available", "K", avail)
+          | pydict_add(dict, "percent", "d", percent)
+          | pydict_add(dict, "used", "K", used)
+          | pydict_add(dict, "free", "K", free)
+          | pydict_add(dict, "active", "K", active)
+          | pydict_add(dict, "inactive", "K", inactive)
+          | pydict_add(dict, "buffers", "K", buffers)
+          | pydict_add(dict, "cached", "K", cached)
+          | pydict_add(dict, "shared", "K", shared)
+          | pydict_add(dict, "wired", "K", wired)))
+        goto error;
+
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    return NULL;
+}
diff --git a/psutil/arch/openbsd/pids.c b/psutil/arch/openbsd/pids.c
new file mode 100644
index 0000000000..be7c493fb8
--- /dev/null
+++ b/psutil/arch/openbsd/pids.c
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <stdlib.h>
+#include <kvm.h>
+#include <sys/sysctl.h>
+
+#include "../../arch/all/init.h"
+
+
+int
+_psutil_pids(pid_t **pids_array, int *pids_count) {
+    char errbuf[_POSIX2_LINE_MAX];
+    kvm_t *kd;
+    struct kinfo_proc *proc_list = NULL;
+    struct kinfo_proc *result;
+    int cnt;
+    size_t i;
+
+    *pids_array = NULL;
+    *pids_count = 0;
+
+    kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);
+    if (kd == NULL) {
+        psutil_runtime_error("kvm_openfiles() failed: %s", errbuf);
+        return -1;
+    }
+
+    result = kvm_getprocs(
+        kd, KERN_PROC_ALL, 0, sizeof(struct kinfo_proc), &cnt
+    );
+    if (result == NULL) {
+        psutil_runtime_error("kvm_getproc2() failed");
+        kvm_close(kd);
+        return -1;
+    }
+
+    if (cnt == 0) {
+        psutil_runtime_error("no PIDs found");
+        kvm_close(kd);
+        return -1;
+    }
+
+    *pids_array = malloc(cnt * sizeof(pid_t));
+    if (!*pids_array) {
+        PyErr_NoMemory();
+        kvm_close(kd);
+        return -1;
+    }
+
+    for (i = 0; i < (size_t)cnt; i++) {
+        (*pids_array)[i] = result[i].p_pid;
+    }
+
+    *pids_count = cnt;
+    kvm_close(kd);
+    return 0;
+}
diff --git a/psutil/arch/openbsd/proc.c b/psutil/arch/openbsd/proc.c
new file mode 100644
index 0000000000..e5c5436d96
--- /dev/null
+++ b/psutil/arch/openbsd/proc.c
@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Landry Breuil.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/param.h>
+#include <sys/sysctl.h>
+#include <sys/proc.h>
+#include <kvm.h>
+
+#include "../../arch/all/init.h"
+
+
+// TODO: refactor this (it's clunky)
+PyObject *
+psutil_proc_cmdline(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int mib[4];
+    char *argv_buf = NULL;
+    size_t argv_len = 0;
+    char **argv = NULL;
+    char **p;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC_ARGS;
+    mib[2] = pid;
+    mib[3] = KERN_PROC_ARGV;
+
+    if (psutil_sysctl_malloc(mib, 4, &argv_buf, &argv_len) == -1)
+        goto error;
+
+    argv = (char **)argv_buf;
+
+    for (p = argv; *p != NULL; p++) {
+        if (!pylist_append_obj(py_retlist, PyUnicode_DecodeFSDefault(*p)))
+            goto error;
+    }
+
+    free(argv_buf);
+    return py_retlist;
+
+error:
+    if (argv_buf != NULL)
+        free(argv_buf);
+    Py_DECREF(py_retlist);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_threads(PyObject *self, PyObject *args) {
+    // OpenBSD reference:
+    // https://github.com/janmojzis/pstree/blob/master/proc_kvm.c
+    // Note: this requires root access, else it will fail trying
+    // to access /dev/kmem.
+    pid_t pid;
+    kvm_t *kd = NULL;
+    int nentries, i;
+    char errbuf[4096];
+    struct kinfo_proc *kp;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+
+    // This opens /dev/mem, /dev/kmem and reads the kernel symbol table
+    // off disk, so do it without the GIL.
+    Py_BEGIN_ALLOW_THREADS
+    kd = kvm_openfiles(0, 0, 0, O_RDONLY, errbuf);
+    Py_END_ALLOW_THREADS
+    if (!kd) {
+        // Usually fails due to EPERM against /dev/mem. We retry with
+        // KVM_NO_FILES which apparently has the same effect.
+        // https://stackoverflow.com/questions/22369736/
+        psutil_debug("kvm_openfiles(O_RDONLY) failed");
+        Py_BEGIN_ALLOW_THREADS
+        kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);
+        Py_END_ALLOW_THREADS
+        if (!kd) {
+            convert_kvm_err("kvm_openfiles()", errbuf);
+            goto error;
+        }
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    kp = kvm_getprocs(
+        kd,
+        KERN_PROC_PID | KERN_PROC_SHOW_THREADS | KERN_PROC_KTHREAD,
+        pid,
+        sizeof(*kp),
+        &nentries
+    );
+    Py_END_ALLOW_THREADS
+    if (!kp) {
+        if (strstr(errbuf, "Permission denied") != NULL)
+            psutil_oserror_ad("kvm_getprocs");
+        else
+            psutil_runtime_error("kvm_getprocs() syscall failed");
+        goto error;
+    }
+
+    for (i = 0; i < nentries; i++) {
+        if (kp[i].p_tid < 0)
+            continue;
+        if (kp[i].p_pid == pid) {
+            if (!pylist_append_fmt(
+                    py_retlist,
+                    _Py_PARSE_PID "dd",
+                    kp[i].p_tid,
+                    PSUTIL_KPT2DOUBLE(kp[i].p_uutime),
+                    PSUTIL_KPT2DOUBLE(kp[i].p_ustime)
+                ))
+            {
+                goto error;
+            }
+        }
+    }
+
+    kvm_close(kd);
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    if (kd != NULL)
+        kvm_close(kd);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_num_fds(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int cnt;
+
+    struct kinfo_file *freep;
+    struct kinfo_proc kipp;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    if (psutil_kinfo_proc(pid, &kipp) == -1)
+        return NULL;
+
+    freep = kinfo_getfile(pid, &cnt);
+
+    if (freep == NULL) {
+#if defined(PSUTIL_OPENBSD)
+        if ((pid == 0) && (errno == ESRCH)) {
+            psutil_debug(
+                "num_fds() returned ESRCH for PID 0; forcing `return 0`"
+            );
+            PyErr_Clear();
+            return Py_BuildValue("i", 0);
+        }
+#endif
+        return NULL;
+    }
+
+    free(freep);
+    return Py_BuildValue("i", cnt);
+}
+
+
+PyObject *
+psutil_proc_cwd(PyObject *self, PyObject *args) {
+    // Reference:
+    // https://github.com/openbsd/src/blob/588f7f8c69786211f2d16865c552afb91b1c7cba/bin/ps/print.c#L191
+    pid_t pid;
+    struct kinfo_proc kp;
+    char path[MAXPATHLEN];
+    size_t pathlen = sizeof path;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if (psutil_kinfo_proc(pid, &kp) == -1)
+        return NULL;
+
+    int name[] = {CTL_KERN, KERN_PROC_CWD, pid};
+    if (sysctl(name, 3, path, &pathlen, NULL, 0) != 0) {
+        if (errno == ENOENT) {
+            psutil_debug("sysctl(KERN_PROC_CWD) -> ENOENT converted to ''");
+            return PyUnicode_FromString("");
+        }
+        else {
+            psutil_oserror();
+            return NULL;
+        }
+    }
+    return PyUnicode_DecodeFSDefault(path);
+}
diff --git a/psutil/arch/openbsd/socks.c b/psutil/arch/openbsd/socks.c
new file mode 100644
index 0000000000..435760846b
--- /dev/null
+++ b/psutil/arch/openbsd/socks.c
@@ -0,0 +1,181 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysctl.h>
+#include <sys/socket.h>
+#include <kvm.h>
+#define _KERNEL  // silence compiler warning
+#include <sys/file.h>  // DTYPE_SOCKET
+#include <netdb.h>  // INET6_ADDRSTRLEN, in6_addr
+#undef _KERNEL
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_net_connections(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int i;
+    int cnt;
+    int state;
+    int lport;
+    int rport;
+    char lip[INET6_ADDRSTRLEN];
+    char rip[INET6_ADDRSTRLEN];
+    psutil_conn_filters filters;
+
+    char errbuf[_POSIX2_LINE_MAX];
+    kvm_t *kd = NULL;
+
+    struct kinfo_file *kif;
+    struct kinfo_file *ikf;
+    struct in6_addr laddr6;
+
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_laddr = NULL;
+    PyObject *py_raddr = NULL;
+    PyObject *py_lpath = NULL;
+    PyObject *py_af_filter = NULL;
+    PyObject *py_type_filter = NULL;
+
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(
+            args, _Py_PARSE_PID "OO", &pid, &py_af_filter, &py_type_filter
+        ))
+    {
+        goto error;
+    }
+    if (psutil_parse_conn_filters(py_af_filter, py_type_filter, &filters) != 0)
+        goto error;
+
+    Py_BEGIN_ALLOW_THREADS
+    kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf);
+    Py_END_ALLOW_THREADS
+    if (!kd) {
+        convert_kvm_err("kvm_openfiles", errbuf);
+        goto error;
+    }
+
+    // Walks the whole kernel file table, may take a while.
+    Py_BEGIN_ALLOW_THREADS
+    ikf = kvm_getfiles(kd, KERN_FILE_BYPID, -1, sizeof(*ikf), &cnt);
+    Py_END_ALLOW_THREADS
+    if (!ikf) {
+        psutil_oserror_wsyscall("kvm_getfiles");
+        goto error;
+    }
+
+    for (int i = 0; i < cnt; i++) {
+        const struct kinfo_file *kif = ikf + i;
+        py_laddr = NULL;
+        py_raddr = NULL;
+        py_lpath = NULL;
+
+        // apply filters
+        if (kif->f_type != DTYPE_SOCKET)
+            continue;
+        if (pid != -1 && kif->p_pid != (uint32_t)pid)
+            continue;
+        if (!((kif->so_family == AF_INET && filters.v4)
+              || (kif->so_family == AF_INET6 && filters.v6)
+              || (kif->so_family == AF_UNIX && filters.unix_)))
+        {
+            continue;
+        }
+        if (!((kif->so_type == SOCK_STREAM && filters.tcp)
+              || (kif->so_type == SOCK_DGRAM && filters.udp)))
+        {
+            continue;
+        }
+
+        // IPv4 / IPv6 socket
+        if ((kif->so_family == AF_INET) || (kif->so_family == AF_INET6)) {
+            // status
+            if (kif->so_type == SOCK_STREAM)
+                state = kif->t_state;
+            else
+                state = PSUTIL_CONN_NONE;
+
+            // local & remote port
+            lport = ntohs(kif->inp_lport);
+            rport = ntohs(kif->inp_fport);
+
+            // local addr
+            inet_ntop(kif->so_family, &kif->inp_laddru, lip, sizeof(lip));
+            py_laddr = Py_BuildValue("(si)", lip, lport);
+            if (!py_laddr)
+                goto error;
+
+            // remote addr
+            if (rport != 0) {
+                inet_ntop(kif->so_family, &kif->inp_faddru, rip, sizeof(rip));
+                py_raddr = Py_BuildValue("(si)", rip, rport);
+            }
+            else {
+                py_raddr = Py_BuildValue("()");
+            }
+            if (!py_raddr)
+                goto error;
+
+            // populate tuple and list
+            if (!pylist_append_fmt(
+                    py_retlist,
+                    "(iiiNNil)",
+                    kif->fd_fd,
+                    kif->so_family,
+                    kif->so_type,
+                    py_laddr,
+                    py_raddr,
+                    state,
+                    kif->p_pid
+                ))
+            {
+                goto error;
+            }
+            py_laddr = NULL;
+            py_raddr = NULL;
+        }
+        // UNIX socket
+        else if (kif->so_family == AF_UNIX) {
+            py_lpath = PyUnicode_DecodeFSDefault(kif->unp_path);
+            if (!py_lpath)
+                goto error;
+
+            if (!pylist_append_fmt(
+                    py_retlist,
+                    "(iiiOsil)",
+                    kif->fd_fd,
+                    kif->so_family,
+                    kif->so_type,
+                    py_lpath,
+                    "",  // raddr
+                    PSUTIL_CONN_NONE,
+                    kif->p_pid
+                ))
+            {
+                goto error;
+            }
+            Py_DECREF(py_lpath);
+            py_lpath = NULL;
+        }
+    }
+
+    kvm_close(kd);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_laddr);
+    Py_XDECREF(py_raddr);
+    Py_XDECREF(py_lpath);
+    Py_DECREF(py_retlist);
+    if (kd != NULL)
+        kvm_close(kd);
+    return NULL;
+}
diff --git a/psutil/arch/openbsd/users.c b/psutil/arch/openbsd/users.c
new file mode 100644
index 0000000000..33f8535ed1
--- /dev/null
+++ b/psutil/arch/openbsd/users.c
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'.
+ * All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <utmp.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_users(PyObject *self, PyObject *args) {
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_username = NULL;
+    PyObject *py_tty = NULL;
+    PyObject *py_hostname = NULL;
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    struct utmp ut;
+    FILE *fp;
+    size_t nread;
+
+    Py_BEGIN_ALLOW_THREADS
+    fp = fopen(_PATH_UTMP, "r");
+    Py_END_ALLOW_THREADS
+    if (fp == NULL) {
+        PyErr_SetFromErrnoWithFilename(PyExc_OSError, _PATH_UTMP);
+        goto error;
+    }
+
+    while (1) {
+        Py_BEGIN_ALLOW_THREADS
+        nread = fread(&ut, sizeof(ut), 1, fp);
+        Py_END_ALLOW_THREADS
+        if (nread != 1)
+            break;
+        if (*ut.ut_name == '\0')
+            continue;
+        py_username = PyUnicode_DecodeFSDefault(ut.ut_name);
+        if (!py_username)
+            goto error;
+        py_tty = PyUnicode_DecodeFSDefault(ut.ut_line);
+        if (!py_tty)
+            goto error;
+        py_hostname = PyUnicode_DecodeFSDefault(ut.ut_host);
+        if (!py_hostname)
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(OOOdO)",
+                py_username,  // username
+                py_tty,  // tty
+                py_hostname,  // hostname
+                (double)ut.ut_time,  // start time
+                Py_None  // pid
+            ))
+        {
+            goto error;
+        }
+        Py_CLEAR(py_username);
+        Py_CLEAR(py_tty);
+        Py_CLEAR(py_hostname);
+    }
+
+    fclose(fp);
+    return py_retlist;
+
+error:
+    fclose(fp);
+    Py_XDECREF(py_username);
+    Py_XDECREF(py_tty);
+    Py_XDECREF(py_hostname);
+    Py_DECREF(py_retlist);
+    return NULL;
+}
diff --git a/psutil/arch/osx/cpu.c b/psutil/arch/osx/cpu.c
new file mode 100644
index 0000000000..556e85e374
--- /dev/null
+++ b/psutil/arch/osx/cpu.c
@@ -0,0 +1,442 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// System-wide CPU related functions.
+//
+// Original code was refactored and moved from psutil/_psutil_osx.c in 2020,
+// right before a4c0a0eb0d2a872ab7a45e47fcf37ef1fde5b012.
+//
+// For reference, here's the git history with original implementations:
+// - CPU count logical: 3d291d425b856077e65163e43244050fb188def1
+// - CPU count physical: 4263e354bb4984334bc44adf5dd2f32013d69fba
+// - CPU times: 32488bdf54aed0f8cef90d639c1667ffaa3c31c7
+// - CPU stat: fa00dfb961ef63426c7818899340866ced8d2418
+// - CPU frequency: 6ba1ac4ebfcd8c95fca324b15606ab0ec1412d39
+
+#include <Python.h>
+#include <mach/mach_error.h>
+#include <mach/mach_host.h>
+#include <mach/mach_port.h>
+#include <mach/mach_vm.h>
+#include <sys/sysctl.h>
+#include <sys/vmmeter.h>
+#include <mach/mach.h>
+#if defined(__arm64__) || defined(__aarch64__)
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/IOKitLib.h>
+#endif
+
+#include "../../arch/all/init.h"
+
+// added in macOS 12
+#ifndef kIOMainPortDefault
+#define kIOMainPortDefault 0
+#endif
+
+PyObject *
+psutil_cpu_count_logical(PyObject *self, PyObject *args) {
+    int num;
+
+    if (psutil_sysctlbyname("hw.logicalcpu", &num, sizeof(num)) != 0)
+        Py_RETURN_NONE;
+    return Py_BuildValue("i", num);
+}
+
+
+PyObject *
+psutil_cpu_count_cores(PyObject *self, PyObject *args) {
+    int num;
+
+    if (psutil_sysctlbyname("hw.physicalcpu", &num, sizeof(num)) != 0)
+        Py_RETURN_NONE;
+    return Py_BuildValue("i", num);
+}
+
+
+PyObject *
+psutil_cpu_times(PyObject *self, PyObject *args) {
+    mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
+    kern_return_t error;
+    host_cpu_load_info_data_t r_load;
+    mach_port_t mport = mach_host_self();
+
+    if (mport == MACH_PORT_NULL) {
+        psutil_runtime_error("mach_host_self() returned MACH_PORT_NULL");
+        return NULL;
+    }
+
+    error = host_statistics(
+        mport, HOST_CPU_LOAD_INFO, (host_info_t)&r_load, &count
+    );
+    mach_port_deallocate(mach_task_self(), mport);
+
+    if (error != KERN_SUCCESS) {
+        return psutil_runtime_error(
+            "host_statistics(HOST_CPU_LOAD_INFO) syscall failed: %s",
+            mach_error_string(error)
+        );
+    }
+
+    return Py_BuildValue(
+        "(dddd)",
+        (double)r_load.cpu_ticks[CPU_STATE_USER] / CLK_TCK,
+        (double)r_load.cpu_ticks[CPU_STATE_NICE] / CLK_TCK,
+        (double)r_load.cpu_ticks[CPU_STATE_SYSTEM] / CLK_TCK,
+        (double)r_load.cpu_ticks[CPU_STATE_IDLE] / CLK_TCK
+    );
+}
+
+
+PyObject *
+psutil_cpu_stats(PyObject *self, PyObject *args) {
+    kern_return_t ret;
+    mach_msg_type_number_t count = HOST_VM_INFO_COUNT;
+    mach_port_t mport = mach_host_self();
+    struct vmmeter vmstat;
+
+    if (mport == MACH_PORT_NULL) {
+        psutil_runtime_error("mach_host_self() returned MACH_PORT_NULL");
+        return NULL;
+    }
+
+    ret = host_statistics(mport, HOST_VM_INFO, (host_info_t)&vmstat, &count);
+    mach_port_deallocate(mach_task_self(), mport);
+
+    if (ret != KERN_SUCCESS) {
+        psutil_runtime_error(
+            "host_statistics(HOST_VM_INFO) failed: %s", mach_error_string(ret)
+        );
+        return NULL;
+    }
+
+    return Py_BuildValue(
+        "IIIII",
+        vmstat.v_swtch,
+        vmstat.v_intr,
+        vmstat.v_soft,
+#if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) \
+    && __MAC_OS_X_VERSION_MIN_REQUIRED__ >= 120000
+        0,
+#else
+        vmstat.v_syscall,
+#endif
+        vmstat.v_trap
+    );
+}
+
+
+#if defined(__arm64__) || defined(__aarch64__)
+
+// Helper to locate the 'pmgr' entry in AppleARMIODevice. Returns 0 on
+// failure, nonzero on success, and stores the found entry in
+// *out_entry. Caller is responsible for IOObjectRelease(*out_entry).
+// Needed because on GitHub CI sometimes (but not all the times)
+// "AppleARMIODevice" is not available.
+static int
+psutil_find_pmgr_entry(io_registry_entry_t *out_entry) {
+    kern_return_t status;
+    io_iterator_t iter = IO_OBJECT_NULL;
+    io_registry_entry_t entry = IO_OBJECT_NULL;
+    CFDictionaryRef matching = IOServiceMatching("AppleARMIODevice");
+    int found = 0;
+
+    if (!out_entry || !matching)
+        return 0;
+
+    status = IOServiceGetMatchingServices(kIOMainPortDefault, matching, &iter);
+    if (status != KERN_SUCCESS || iter == IO_OBJECT_NULL)
+        return 0;
+
+    while ((entry = IOIteratorNext(iter)) != IO_OBJECT_NULL) {
+        io_name_t name;
+        if (IORegistryEntryGetName(entry, name) == KERN_SUCCESS
+            && strcmp(name, "pmgr") == 0)
+        {
+            found = 1;
+            break;
+        }
+        IOObjectRelease(entry);
+    }
+
+    IOObjectRelease(iter);
+
+    if (found) {
+        *out_entry = entry;
+        return 1;
+    }
+    return 0;
+}
+
+// Report overall min/max CPU frequency by enumerating every
+// `voltage-states<N>-sram` property on the pmgr entry, instead of
+// reading fixed indexes: Apple renumbered that key space on M5, so
+// any hardcoded index breaks there.
+//
+// Frequencies are Hz on M1-M3 and kHz on M4+. We pick the unit per
+// value by magnitude rather than keying on chip generation: real
+// clocks are ~0.6-4.6 GHz, so Hz values sit well above 1e8 and kHz
+// values well below it.
+//
+// The `-sram` suffix isn't CPU-specific: GPU/NPU/fabric publish
+// -sram DVFS tables too (fmax ~1.4 GHz on M3 Max). A table counts as
+// a CPU cluster only if its fmax is >= 2 GHz, which clears every GPU
+// peak seen so far but stays under the slowest CPU cluster shipped
+// (M1 E-core, 2064 MHz). GPU clocks rise ~5-6%/gen, so revisit this
+// floor if a future chip closes the gap.
+PyObject *
+psutil_cpu_freq(PyObject *self, PyObject *args) {
+    static const char KEY_PREFIX[] = "voltage-states";
+    static const char KEY_SUFFIX[] = "-sram";
+    static const size_t KEY_PREFIX_LEN = sizeof(KEY_PREFIX) - 1;
+    static const size_t KEY_SUFFIX_LEN = sizeof(KEY_SUFFIX) - 1;
+    // Raw frequency values above 10^8 are Hz; below are kHz.
+    static const uint32_t UNIT_THRESHOLD = 100000000U;
+    // Per-value plausibility bounds. Drops terminator zeros and any
+    // junk the enumeration might pick up.
+    static const uint32_t MIN_PLAUSIBLE_MHZ = 500;
+    static const uint32_t MAX_PLAUSIBLE_MHZ = 20000;
+    // Per-table classification: CPU clusters have fmax >= 2 GHz. See
+    // block comment above for justification.
+    static const uint32_t CPU_CLUSTER_MIN_FMAX_MHZ = 2000;
+
+    io_registry_entry_t entry = IO_OBJECT_NULL;
+    CFMutableDictionaryRef props = NULL;
+    const void **keys = NULL;
+    const void **values = NULL;
+    CFIndex count = 0;
+    uint32_t min_mhz = UINT32_MAX;
+    uint32_t max_mhz = 0;
+    int found_any = 0;
+    int found_pmgr;
+    kern_return_t status;
+
+    // No 'pmgr' entry (e.g. virtualized ARM64); frequency is
+    // undeterminable, so return None (see #2382).
+    // Walks the IOKit registry (mach IPC), so no GIL.
+    Py_BEGIN_ALLOW_THREADS
+    found_pmgr = psutil_find_pmgr_entry(&entry);
+    Py_END_ALLOW_THREADS
+    if (!found_pmgr) {
+        psutil_debug("'pmgr' entry not found in AppleARMIODevice");
+        Py_RETURN_NONE;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    status = IORegistryEntryCreateCFProperties(
+        entry, &props, kCFAllocatorDefault, 0
+    );
+    Py_END_ALLOW_THREADS
+    if (status != KERN_SUCCESS || props == NULL) {
+        IOObjectRelease(entry);
+        psutil_debug("IORegistryEntryCreateCFProperties failed");
+        Py_RETURN_NONE;
+    }
+
+    count = CFDictionaryGetCount(props);
+    if (count > 0) {
+        keys = (const void **)malloc(count * sizeof(void *));
+        values = (const void **)malloc(count * sizeof(void *));
+        if (keys == NULL || values == NULL) {
+            free(keys);
+            free(values);
+            CFRelease(props);
+            IOObjectRelease(entry);
+            PyErr_NoMemory();
+            return NULL;
+        }
+        CFDictionaryGetKeysAndValues(props, keys, values);
+    }
+
+    for (CFIndex i = 0; i < count; i++) {
+        CFStringRef key = (CFStringRef)keys[i];
+        CFTypeRef value = (CFTypeRef)values[i];
+        char name[64];
+        size_t name_len;
+        int all_digits;
+
+        // Key must be "voltage-states<N>-sram" where N is one or more digits.
+        if (CFGetTypeID(key) != CFStringGetTypeID())
+            continue;
+        if (!CFStringGetCString(
+                key, name, sizeof(name), kCFStringEncodingUTF8
+            ))
+            continue;
+        name_len = strlen(name);
+        if (name_len < KEY_PREFIX_LEN + 1 + KEY_SUFFIX_LEN)
+            continue;
+        if (strncmp(name, KEY_PREFIX, KEY_PREFIX_LEN) != 0)
+            continue;
+        if (strcmp(name + name_len - KEY_SUFFIX_LEN, KEY_SUFFIX) != 0)
+            continue;
+        all_digits = 1;
+        for (size_t j = KEY_PREFIX_LEN; j < name_len - KEY_SUFFIX_LEN; j++) {
+            if (name[j] < '0' || name[j] > '9') {
+                all_digits = 0;
+                break;
+            }
+        }
+        if (!all_digits)
+            continue;
+
+        if (CFGetTypeID(value) != CFDataGetTypeID())
+            continue;
+
+        // Each DVFS entry is 8 bytes: 4-byte LE freq + 4-byte LE voltage.
+        // Accumulate this table's min/max first; then fold into overall
+        // min/max only if the table's fmax qualifies it as a CPU cluster.
+        uint32_t table_min = UINT32_MAX;
+        uint32_t table_max = 0;
+        int table_has_value = 0;
+        CFIndex blob_len = CFDataGetLength((CFDataRef)value);
+        const UInt8 *bytes = CFDataGetBytePtr((CFDataRef)value);
+        for (CFIndex off = 0; off + 4 <= blob_len; off += 8) {
+            uint32_t raw_freq;
+            uint32_t freq_mhz;
+
+            // ARM64 is little-endian; copy 4 bytes as native uint32.
+            memcpy(&raw_freq, bytes + off, sizeof(raw_freq));
+
+            if (raw_freq > UNIT_THRESHOLD)
+                freq_mhz = raw_freq / 1000U / 1000U;  // Hz -> MHz
+            else
+                freq_mhz = raw_freq / 1000U;  // kHz -> MHz
+
+            if (freq_mhz < MIN_PLAUSIBLE_MHZ || freq_mhz > MAX_PLAUSIBLE_MHZ)
+                continue;
+
+            if (freq_mhz < table_min)
+                table_min = freq_mhz;
+            if (freq_mhz > table_max)
+                table_max = freq_mhz;
+            table_has_value = 1;
+        }
+
+        if (!table_has_value || table_max < CPU_CLUSTER_MIN_FMAX_MHZ)
+            continue;
+
+        if (table_min < min_mhz)
+            min_mhz = table_min;
+        if (table_max > max_mhz)
+            max_mhz = table_max;
+        found_any = 1;
+    }
+
+    free(keys);
+    free(values);
+    CFRelease(props);
+    IOObjectRelease(entry);
+
+    // Data missing or malformed; treat as undeterminable (see #2382).
+    if (!found_any) {
+        psutil_debug(
+            "no valid CPU frequency data found in pmgr voltage-states tables"
+        );
+        Py_RETURN_NONE;
+    }
+
+    // No real current-frequency API on Apple Silicon; report max as current.
+    return Py_BuildValue(
+        "KKK",
+        (unsigned long long)max_mhz,
+        (unsigned long long)min_mhz,
+        (unsigned long long)max_mhz
+    );
+}
+
+#else  // not ARM64 / ARCH64
+
+PyObject *
+psutil_cpu_freq(PyObject *self, PyObject *args) {
+    unsigned int curr;
+    int64_t min = 0, max = 0;
+    int mib[2] = {CTL_HW, HW_CPU_FREQ};
+
+    if (psutil_sysctl(mib, 2, &curr, sizeof(curr)) < 0)
+        return psutil_oserror_wsyscall("sysctl(HW_CPU_FREQ)");
+
+    if (psutil_sysctlbyname("hw.cpufrequency_min", &min, sizeof(min)) != 0) {
+        min = 0;
+        psutil_debug("sysctlbyname('hw.cpufrequency_min') failed (set to 0)");
+    }
+
+    if (psutil_sysctlbyname("hw.cpufrequency_max", &max, sizeof(max)) != 0) {
+        max = 0;
+        psutil_debug("sysctlbyname('hw.cpufrequency_max') failed (set to 0)");
+    }
+
+    return Py_BuildValue(
+        "KKK",
+        (unsigned long long)(curr / 1000 / 1000),
+        (unsigned long long)(min / 1000 / 1000),
+        (unsigned long long)(max / 1000 / 1000)
+    );
+}
+
+#endif  // ARM64
+
+PyObject *
+psutil_per_cpu_times(PyObject *self, PyObject *args) {
+    natural_t cpu_count = 0;
+    mach_msg_type_number_t info_count = 0;
+    processor_cpu_load_info_data_t *cpu_load_info = NULL;
+    processor_info_array_t info_array = NULL;
+    kern_return_t error;
+    mach_port_t mport = mach_host_self();
+    PyObject *py_retlist = PyList_New(0);
+
+    if (!py_retlist)
+        return NULL;
+
+    if (mport == MACH_PORT_NULL) {
+        psutil_runtime_error("mach_host_self() returned NULL");
+        goto error;
+    }
+
+    error = host_processor_info(
+        mport, PROCESSOR_CPU_LOAD_INFO, &cpu_count, &info_array, &info_count
+    );
+    mach_port_deallocate(mach_task_self(), mport);
+
+    if (error != KERN_SUCCESS || !info_array) {
+        psutil_runtime_error(
+            "host_processor_info failed: %s", mach_error_string(error)
+        );
+        goto error;
+    }
+
+    cpu_load_info = (processor_cpu_load_info_data_t *)info_array;
+
+    for (natural_t i = 0; i < cpu_count; i++) {
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(dddd)",
+                (double)cpu_load_info[i].cpu_ticks[CPU_STATE_USER] / CLK_TCK,
+                (double)cpu_load_info[i].cpu_ticks[CPU_STATE_NICE] / CLK_TCK,
+                (double)cpu_load_info[i].cpu_ticks[CPU_STATE_SYSTEM] / CLK_TCK,
+                (double)cpu_load_info[i].cpu_ticks[CPU_STATE_IDLE] / CLK_TCK
+            ))
+        {
+            goto error;
+        }
+    }
+
+    vm_deallocate(
+        mach_task_self(),
+        (vm_address_t)info_array,
+        info_count * sizeof(integer_t)
+    );
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_retlist);
+    if (info_array)
+        vm_deallocate(
+            mach_task_self(),
+            (vm_address_t)info_array,
+            info_count * sizeof(integer_t)
+        );
+    return NULL;
+}
diff --git a/psutil/arch/osx/disk.c b/psutil/arch/osx/disk.c
new file mode 100644
index 0000000000..4e80b17840
--- /dev/null
+++ b/psutil/arch/osx/disk.c
@@ -0,0 +1,401 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Disk related functions. Original code was refactored and moved
+// from psutil/_psutil_osx.c in 2023. This is the GIT blame before the move:
+// https://github.com/giampaolo/psutil/blame/efd7ed3/psutil/_psutil_osx.c
+
+#include <Python.h>
+#include <sys/param.h>
+#include <sys/ucred.h>
+#include <sys/mount.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/storage/IOBlockStorageDriver.h>
+#include <IOKit/storage/IOMedia.h>
+#include <IOKit/IOBSD.h>
+
+#include "../../arch/all/init.h"
+
+#define MAX_DISK_NAME_SIZE 64
+
+
+PyObject *
+psutil_disk_partitions(PyObject *self, PyObject *args) {
+    int num;
+    int i;
+    int len;
+    uint64_t flags;
+    char opts[400];
+    struct statfs *fs = NULL;
+    PyObject *py_dev = NULL;
+    PyObject *py_mountp = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    // get the number of mount points
+    Py_BEGIN_ALLOW_THREADS
+    num = getfsstat(NULL, 0, MNT_NOWAIT);
+    Py_END_ALLOW_THREADS
+    if (num == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    len = sizeof(*fs) * num;
+    fs = malloc(len);
+    if (fs == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    num = getfsstat(fs, len, MNT_NOWAIT);
+    Py_END_ALLOW_THREADS
+    if (num == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (i = 0; i < num; i++) {
+        opts[0] = 0;
+        flags = fs[i].f_flags;
+
+        // see sys/mount.h
+        if (flags & MNT_RDONLY)
+            str_append(opts, sizeof(opts), "ro");
+        else
+            str_append(opts, sizeof(opts), "rw");
+        if (flags & MNT_SYNCHRONOUS)
+            str_append(opts, sizeof(opts), ",sync");
+        if (flags & MNT_NOEXEC)
+            str_append(opts, sizeof(opts), ",noexec");
+        if (flags & MNT_NOSUID)
+            str_append(opts, sizeof(opts), ",nosuid");
+        if (flags & MNT_UNION)
+            str_append(opts, sizeof(opts), ",union");
+        if (flags & MNT_ASYNC)
+            str_append(opts, sizeof(opts), ",async");
+        if (flags & MNT_EXPORTED)
+            str_append(opts, sizeof(opts), ",exported");
+        if (flags & MNT_LOCAL)
+            str_append(opts, sizeof(opts), ",local");
+        if (flags & MNT_QUOTA)
+            str_append(opts, sizeof(opts), ",quota");
+        if (flags & MNT_ROOTFS)
+            str_append(opts, sizeof(opts), ",rootfs");
+        if (flags & MNT_DOVOLFS)
+            str_append(opts, sizeof(opts), ",dovolfs");
+        if (flags & MNT_DONTBROWSE)
+            str_append(opts, sizeof(opts), ",dontbrowse");
+        if (flags & MNT_IGNORE_OWNERSHIP)
+            str_append(opts, sizeof(opts), ",ignore-ownership");
+        if (flags & MNT_AUTOMOUNTED)
+            str_append(opts, sizeof(opts), ",automounted");
+        if (flags & MNT_JOURNALED)
+            str_append(opts, sizeof(opts), ",journaled");
+        if (flags & MNT_NOUSERXATTR)
+            str_append(opts, sizeof(opts), ",nouserxattr");
+        if (flags & MNT_DEFWRITE)
+            str_append(opts, sizeof(opts), ",defwrite");
+        if (flags & MNT_UPDATE)
+            str_append(opts, sizeof(opts), ",update");
+        if (flags & MNT_RELOAD)
+            str_append(opts, sizeof(opts), ",reload");
+        if (flags & MNT_FORCE)
+            str_append(opts, sizeof(opts), ",force");
+        if (flags & MNT_CMDFLAGS)
+            str_append(opts, sizeof(opts), ",cmdflags");
+            // requires macOS >= 10.5
+#ifdef MNT_QUARANTINE
+        if (flags & MNT_QUARANTINE)
+            str_append(opts, sizeof(opts), ",quarantine");
+#endif
+#ifdef MNT_MULTILABEL
+        if (flags & MNT_MULTILABEL)
+            str_append(opts, sizeof(opts), ",multilabel");
+#endif
+#ifdef MNT_NOATIME
+        if (flags & MNT_NOATIME)
+            str_append(opts, sizeof(opts), ",noatime");
+#endif
+        py_dev = PyUnicode_DecodeFSDefault(fs[i].f_mntfromname);
+        if (!py_dev)
+            goto error;
+        py_mountp = PyUnicode_DecodeFSDefault(fs[i].f_mntonname);
+        if (!py_mountp)
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(OOss)",
+                py_dev,  // device
+                py_mountp,  // mount point
+                fs[i].f_fstypename,  // fs type
+                opts  // options
+            ))
+        {
+            goto error;
+        }
+        Py_CLEAR(py_dev);
+        Py_CLEAR(py_mountp);
+    }
+
+    free(fs);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_dev);
+    Py_XDECREF(py_mountp);
+    Py_DECREF(py_retlist);
+    if (fs != NULL)
+        free(fs);
+    return NULL;
+}
+
+
+PyObject *
+psutil_disk_usage_used(PyObject *self, PyObject *args) {
+    PyObject *py_default_value;
+    PyObject *py_mount_point_bytes = NULL;
+    char *mount_point;
+
+    if (!PyArg_ParseTuple(
+            args,
+            "O&O",
+            PyUnicode_FSConverter,
+            &py_mount_point_bytes,
+            &py_default_value
+        ))
+    {
+        return NULL;
+    }
+    mount_point = PyBytes_AsString(py_mount_point_bytes);
+    if (NULL == mount_point) {
+        Py_XDECREF(py_mount_point_bytes);
+        return NULL;
+    }
+
+#ifdef ATTR_VOL_SPACEUSED
+    // Call getattrlist(ATTR_VOL_SPACEUSED) to get used space info.
+    int ret;
+    struct {
+        uint32_t size;
+        uint64_t spaceused;
+    } __attribute__((aligned(4), packed)) attrbuf = {0};
+    struct attrlist attrs = {0};
+
+    attrs.bitmapcount = ATTR_BIT_MAP_COUNT;
+    attrs.volattr = ATTR_VOL_INFO | ATTR_VOL_SPACEUSED;
+    attrbuf.size = sizeof(attrbuf);
+
+    Py_BEGIN_ALLOW_THREADS
+    ret = getattrlist(mount_point, &attrs, &attrbuf, sizeof(attrbuf), 0);
+    Py_END_ALLOW_THREADS
+    if (ret == 0) {
+        Py_XDECREF(py_mount_point_bytes);
+        return PyLong_FromUnsignedLongLong(attrbuf.spaceused);
+    }
+    psutil_debug(
+        "getattrlist(ATTR_VOL_SPACEUSED) failed, fall-back to default value"
+    );
+#endif
+    Py_XDECREF(py_mount_point_bytes);
+    Py_INCREF(py_default_value);
+    return py_default_value;
+}
+
+
+PyObject *
+psutil_disk_io_counters(PyObject *self, PyObject *args) {
+    CFDictionaryRef parent_dict = NULL;
+    CFDictionaryRef props_dict = NULL;
+    CFDictionaryRef stats_dict = NULL;
+    io_registry_entry_t parent = IO_OBJECT_NULL;
+    io_registry_entry_t disk = IO_OBJECT_NULL;
+    io_iterator_t disk_list = IO_OBJECT_NULL;
+    kern_return_t ret;
+    PyObject *py_disk_info = NULL;
+    PyObject *py_retdict = PyDict_New();
+
+    if (py_retdict == NULL)
+        return NULL;
+
+    // IOKit queries are mach IPC round trips into the kernel's
+    // registry, so run them without the GIL.
+    Py_BEGIN_ALLOW_THREADS
+    ret = IOServiceGetMatchingServices(
+        kIOMasterPortDefault, IOServiceMatching(kIOMediaClass), &disk_list
+    );
+    Py_END_ALLOW_THREADS
+    if (ret != kIOReturnSuccess) {
+        psutil_runtime_error("unable to get the list of disks");
+        goto error;
+    }
+
+    while (1) {
+        Py_BEGIN_ALLOW_THREADS
+        disk = IOIteratorNext(disk_list);
+        Py_END_ALLOW_THREADS
+        if (disk == 0)
+            break;
+        py_disk_info = NULL;
+        parent_dict = NULL;
+        props_dict = NULL;
+        stats_dict = NULL;
+        parent = IO_OBJECT_NULL;
+
+        Py_BEGIN_ALLOW_THREADS
+        ret = IORegistryEntryGetParentEntry(disk, kIOServicePlane, &parent);
+        Py_END_ALLOW_THREADS
+        if (ret != kIOReturnSuccess) {
+            psutil_runtime_error("unable to get the disk's parent");
+            goto error;
+        }
+
+        if (!IOObjectConformsTo(parent, "IOBlockStorageDriver")) {
+            IOObjectRelease(parent);
+            IOObjectRelease(disk);
+            continue;
+        }
+
+        Py_BEGIN_ALLOW_THREADS
+        ret = IORegistryEntryCreateCFProperties(
+            disk,
+            (CFMutableDictionaryRef *)&parent_dict,
+            kCFAllocatorDefault,
+            kNilOptions
+        );
+        Py_END_ALLOW_THREADS
+        if (ret != kIOReturnSuccess) {
+            psutil_runtime_error("unable to get the parent's properties");
+            goto error;
+        }
+
+        Py_BEGIN_ALLOW_THREADS
+        ret = IORegistryEntryCreateCFProperties(
+            parent,
+            (CFMutableDictionaryRef *)&props_dict,
+            kCFAllocatorDefault,
+            kNilOptions
+        );
+        Py_END_ALLOW_THREADS
+        if (ret != kIOReturnSuccess) {
+            psutil_runtime_error("unable to get the disk properties");
+            goto error;
+        }
+
+        CFStringRef disk_name_ref = (CFStringRef
+        )CFDictionaryGetValue(parent_dict, CFSTR(kIOBSDNameKey));
+        if (disk_name_ref == NULL) {
+            psutil_runtime_error("unable to get disk name");
+            goto error;
+        }
+
+        char disk_name[MAX_DISK_NAME_SIZE];
+        if (!CFStringGetCString(
+                disk_name_ref,
+                disk_name,
+                sizeof(disk_name),
+                CFStringGetSystemEncoding()
+            ))
+        {
+            psutil_runtime_error("unable to convert disk name to C string");
+            goto error;
+        }
+
+        stats_dict = (CFDictionaryRef)CFDictionaryGetValue(
+            props_dict, CFSTR(kIOBlockStorageDriverStatisticsKey)
+        );
+        if (stats_dict == NULL) {
+            psutil_runtime_error("unable to get disk stats");
+            goto error;
+        }
+
+        CFNumberRef number;
+        int64_t reads = 0, writes = 0, read_bytes = 0, write_bytes = 0;
+        int64_t read_time = 0, write_time = 0;
+
+        if ((number = (CFNumberRef)CFDictionaryGetValue(
+                 stats_dict, CFSTR(kIOBlockStorageDriverStatisticsReadsKey)
+             )))
+            CFNumberGetValue(number, kCFNumberSInt64Type, &reads);
+
+        if ((number = (CFNumberRef)CFDictionaryGetValue(
+                 stats_dict, CFSTR(kIOBlockStorageDriverStatisticsWritesKey)
+             )))
+            CFNumberGetValue(number, kCFNumberSInt64Type, &writes);
+
+        if ((number = (CFNumberRef)CFDictionaryGetValue(
+                 stats_dict, CFSTR(kIOBlockStorageDriverStatisticsBytesReadKey)
+             )))
+            CFNumberGetValue(number, kCFNumberSInt64Type, &read_bytes);
+
+        if ((number = (CFNumberRef)CFDictionaryGetValue(
+                 stats_dict,
+                 CFSTR(kIOBlockStorageDriverStatisticsBytesWrittenKey)
+             )))
+            CFNumberGetValue(number, kCFNumberSInt64Type, &write_bytes);
+
+        if ((number = (CFNumberRef)CFDictionaryGetValue(
+                 stats_dict,
+                 CFSTR(kIOBlockStorageDriverStatisticsTotalReadTimeKey)
+             )))
+            CFNumberGetValue(number, kCFNumberSInt64Type, &read_time);
+
+        if ((number = (CFNumberRef)CFDictionaryGetValue(
+                 stats_dict,
+                 CFSTR(kIOBlockStorageDriverStatisticsTotalWriteTimeKey)
+             )))
+            CFNumberGetValue(number, kCFNumberSInt64Type, &write_time);
+
+        py_disk_info = Py_BuildValue(
+            "(KKKKKK)",
+            (unsigned long long)reads,
+            (unsigned long long)writes,
+            (unsigned long long)read_bytes,
+            (unsigned long long)write_bytes,
+            (unsigned long long)(read_time / 1000 / 1000),
+            (unsigned long long)(write_time / 1000 / 1000)
+        );
+
+        if (!py_disk_info)
+            goto error;
+
+        if (PyDict_SetItemString(py_retdict, disk_name, py_disk_info)) {
+            Py_CLEAR(py_disk_info);
+            goto error;
+        }
+
+        Py_CLEAR(py_disk_info);
+
+        if (parent_dict)
+            CFRelease(parent_dict);
+        if (props_dict)
+            CFRelease(props_dict);
+        IOObjectRelease(parent);
+        IOObjectRelease(disk);
+    }
+
+    IOObjectRelease(disk_list);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_disk_info);
+    Py_DECREF(py_retdict);
+    if (parent_dict)
+        CFRelease(parent_dict);
+    if (props_dict)
+        CFRelease(props_dict);
+    if (parent != IO_OBJECT_NULL)
+        IOObjectRelease(parent);
+    if (disk != IO_OBJECT_NULL)
+        IOObjectRelease(disk);
+    if (disk_list != IO_OBJECT_NULL)
+        IOObjectRelease(disk_list);
+    return NULL;
+}
diff --git a/psutil/arch/osx/heap.c b/psutil/arch/osx/heap.c
new file mode 100644
index 0000000000..0ab2a8c9ec
--- /dev/null
+++ b/psutil/arch/osx/heap.c
@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <malloc/malloc.h>
+#include <mach/mach.h>
+#include <mach/vm_map.h>
+#include <AvailabilityMacros.h>
+
+#include "../../arch/all/init.h"
+
+
+static int
+get_zones(malloc_zone_t ***out_zones, unsigned int *out_count) {
+    vm_address_t *raw = NULL;
+    unsigned int count = 0;
+    kern_return_t kr;
+    malloc_zone_t **zones;
+    malloc_zone_t *zone;
+
+    *out_zones = NULL;
+    *out_count = 0;
+
+    kr = malloc_get_all_zones(mach_task_self(), NULL, &raw, &count);
+    if (kr == KERN_SUCCESS && raw != NULL && count > 0) {
+        *out_zones = (malloc_zone_t **)raw;
+        *out_count = count;
+        return 1;  // success
+    }
+
+    psutil_debug("malloc_get_all_zones() failed; using malloc_default_zone()");
+
+    zones = (malloc_zone_t **)malloc(sizeof(malloc_zone_t *));
+    if (!zones) {
+        PyErr_NoMemory();
+        return -1;
+    }
+
+    zone = malloc_default_zone();
+    if (!zone) {
+        free(zones);
+        psutil_runtime_error("malloc_default_zone() failed");
+        return -1;
+    }
+
+    zones[0] = zone;
+    *out_zones = zones;
+    *out_count = 1;
+    return 0;  // fallback, caller must free()
+}
+
+
+// psutil_heap_info() -> (heap_used, mmap_used)
+//
+// Return libmalloc heap stats via `malloc_zone_statistics()`.
+// Compatible with macOS 10.6+ (Sierra and earlier).
+//
+// Mapping:
+// - heap_used  ~ size_in_use          (live allocated bytes)
+// - mmap_used  ~ 0                    (no direct stat)
+PyObject *
+psutil_heap_info(PyObject *self, PyObject *args) {
+    malloc_zone_t **zones = NULL;
+    unsigned int count = 0;
+    uint64_t heap_used = 0;
+    uint64_t mmap_used = 0;
+    int ok;
+
+    ok = get_zones(&zones, &count);
+    if (ok == -1)
+        return NULL;
+
+    for (unsigned int i = 0; i < count; i++) {
+        malloc_statistics_t stats = {0};
+        malloc_zone_statistics(zones[i], &stats);
+        heap_used += (uint64_t)stats.size_in_use;
+    }
+
+    if (!ok)
+        free(zones);
+
+    return Py_BuildValue("KK", heap_used, mmap_used);
+}
+
+
+// Return unused heap memory back to the OS.
+PyObject *
+psutil_heap_trim(PyObject *self, PyObject *args) {
+    malloc_zone_t **zones = NULL;
+    unsigned int count = 0;
+    int ok;
+
+    ok = get_zones(&zones, &count);
+    if (ok == -1)
+        return NULL;
+
+// malloc_zone_pressure_relief added in macOS 10.7.
+#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1070
+    for (unsigned int i = 0; i < count; i++)
+        malloc_zone_pressure_relief(zones[i], 0);
+#endif
+
+    if (!ok)
+        free(zones);
+
+    Py_RETURN_NONE;
+}
diff --git a/psutil/arch/osx/init.c b/psutil/arch/osx/init.c
new file mode 100644
index 0000000000..1d9621160b
--- /dev/null
+++ b/psutil/arch/osx/init.c
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/sysctl.h>
+
+#include "../../arch/all/init.h"
+#include "init.h"
+
+
+uint64_t PSUTIL_HW_TBFREQUENCY;
+
+// Called on module import.
+int
+psutil_setup_osx(void) {
+    size_t size = sizeof(PSUTIL_HW_TBFREQUENCY);
+
+    // hw.tbfrequency gives the real hardware timer frequency regardless of
+    // whether we are running under Rosetta 2 (x86_64 on Apple Silicon).
+    // mach_timebase_info() is intercepted by Rosetta and returns numer=1,
+    // denom=1 for x86_64 processes, but proc_pidinfo() returns raw ARM Mach
+    // ticks, so mach_timebase_info gives a wrong conversion factor there.
+    if (sysctlbyname("hw.tbfrequency", &PSUTIL_HW_TBFREQUENCY, &size, NULL, 0)
+        != 0)
+    {
+        psutil_oserror_wsyscall("sysctlbyname('hw.tbfrequency')");
+        return -1;
+    }
+    return 0;
+}
diff --git a/psutil/arch/osx/init.h b/psutil/arch/osx/init.h
new file mode 100644
index 0000000000..bcc7f91d54
--- /dev/null
+++ b/psutil/arch/osx/init.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/user.h>
+#include <sys/types.h>
+#include <libproc.h>
+#include <mach/mach_time.h>
+
+extern uint64_t PSUTIL_HW_TBFREQUENCY;
+
+int psutil_setup_osx(void);
+int _psutil_pids(pid_t **pids_array, int *pids_count);
+int is_zombie(size_t pid);
+
+int psutil_get_kinfo_proc(pid_t pid, struct kinfo_proc *kp);
+int psutil_sysctl_procargs(pid_t pid, char *procargs, size_t *argmax);
+int psutil_proc_pidinfo(
+    pid_t pid, int flavor, uint64_t arg, void *pti, int size
+);
+struct proc_fdinfo *psutil_proc_list_fds(pid_t pid, int *num_fds);
+
+PyObject *psutil_boot_time(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_count_cores(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_count_logical(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_freq(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_stats(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_disk_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_disk_partitions(PyObject *self, PyObject *args);
+PyObject *psutil_disk_usage_used(PyObject *self, PyObject *args);
+PyObject *psutil_heap_info(PyObject *self, PyObject *args);
+PyObject *psutil_heap_trim(PyObject *self, PyObject *args);
+PyObject *psutil_net_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_per_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cmdline(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cwd(PyObject *self, PyObject *args);
+PyObject *psutil_proc_environ(PyObject *self, PyObject *args);
+PyObject *psutil_proc_exe(PyObject *self, PyObject *args);
+PyObject *psutil_proc_memory_extras(PyObject *self, PyObject *args);
+PyObject *psutil_proc_memory_uss(PyObject *self, PyObject *args);
+PyObject *psutil_proc_name(PyObject *self, PyObject *args);
+PyObject *psutil_proc_net_connections(PyObject *self, PyObject *args);
+PyObject *psutil_proc_num_fds(PyObject *self, PyObject *args);
+PyObject *psutil_proc_oneshot_kinfo(PyObject *self, PyObject *args);
+PyObject *psutil_proc_oneshot_pidtaskinfo(PyObject *self, PyObject *args);
+PyObject *psutil_proc_open_files(PyObject *self, PyObject *args);
+PyObject *psutil_proc_threads(PyObject *self, PyObject *args);
+PyObject *psutil_sensors_battery(PyObject *self, PyObject *args);
+PyObject *psutil_swap_mem(PyObject *self, PyObject *args);
+PyObject *psutil_virtual_mem(PyObject *self, PyObject *args);
diff --git a/psutil/arch/osx/mem.c b/psutil/arch/osx/mem.c
new file mode 100644
index 0000000000..3c2b48771f
--- /dev/null
+++ b/psutil/arch/osx/mem.c
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// System memory related functions. Original code was refactored and moved
+// from psutil/_psutil_osx.c in 2023. This is the GIT blame before the move:
+// https://github.com/giampaolo/psutil/blame/efd7ed3/psutil/_psutil_osx.c
+// See:
+// https://github.com/apple-open-source/macos/blob/master/system_cmds/vm_stat/vm_stat.c
+
+#include <Python.h>
+#include <mach/host_info.h>
+#include <sys/sysctl.h>
+#include <mach/mach.h>
+
+#include "../../arch/all/init.h"
+
+
+static int
+psutil_sys_vminfo(vm_statistics64_t vmstat) {
+    kern_return_t ret;
+    integer_t buf[HOST_INFO_MAX];
+    mach_msg_type_number_t count = HOST_INFO_MAX;
+    mach_port_t mport;
+    size_t nbytes;
+
+    mport = mach_host_self();
+    if (mport == MACH_PORT_NULL) {
+        psutil_runtime_error("mach_host_self() returned MACH_PORT_NULL");
+        return -1;
+    }
+
+    ret = host_statistics64(mport, HOST_VM_INFO64, (host_info64_t)buf, &count);
+    mach_port_deallocate(mach_task_self(), mport);
+    if (ret != KERN_SUCCESS) {
+        psutil_runtime_error(
+            "host_statistics64(HOST_VM_INFO64) syscall failed: %s",
+            mach_error_string(ret)
+        );
+        return -1;
+    }
+
+    nbytes = (size_t)count * sizeof(integer_t);
+    if (nbytes > sizeof(*vmstat))
+        nbytes = sizeof(*vmstat);
+    memset(vmstat, 0, sizeof(*vmstat));
+    memcpy(vmstat, buf, nbytes);
+    return 0;
+}
+
+
+// Return system virtual memory stats. See:
+// https://opensource.apple.com/source/system_cmds/system_cmds-790/vm_stat.tproj/vm_stat.c.auto.html
+PyObject *
+psutil_virtual_mem(PyObject *self, PyObject *args) {
+    uint64_t total;
+    unsigned long long active, inactive, wired, free, _speculative;
+    unsigned long long available, used;
+    int mib[2] = {CTL_HW, HW_MEMSIZE};
+    vm_statistics64_data_t vm;
+    long pagesize = psutil_getpagesize();
+    PyObject *dict = PyDict_New();
+
+    if (dict == NULL)
+        return NULL;
+
+    // This is also available as sysctlbyname("hw.memsize").
+    if (psutil_sysctl(mib, 2, &total, sizeof(total)) != 0)
+        goto error;
+    if (psutil_sys_vminfo(&vm) != 0)
+        goto error;
+
+    active = (unsigned long long)vm.active_count * pagesize;
+    inactive = (unsigned long long)vm.inactive_count * pagesize;
+    wired = (unsigned long long)vm.wire_count * pagesize;
+    free = (unsigned long long)vm.free_count * pagesize;
+    _speculative = (unsigned long long)vm.speculative_count * pagesize;
+
+    // This is how Zabbix calculates avail and used mem:
+    // https://github.com/zabbix/zabbix/blob/master/src/libs/zbxsysinfo/osx/memory.c
+    // Also see: https://github.com/giampaolo/psutil/issues/1277
+    available = inactive + free;
+    used = active + wired;
+
+    // This is NOT how Zabbix calculates free mem but it matches "free"
+    // CLI utility.
+    free -= _speculative;
+
+    if (!(pydict_add(dict, "total", "K", (unsigned long long)total)
+          | pydict_add(dict, "available", "K", available)
+          | pydict_add(dict, "used", "K", used)
+          | pydict_add(dict, "free", "K", free)
+          | pydict_add(dict, "active", "K", active)
+          | pydict_add(dict, "inactive", "K", inactive)
+          | pydict_add(dict, "wired", "K", wired)))
+        goto error;
+
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    return NULL;
+}
+
+
+PyObject *
+psutil_swap_mem(PyObject *self, PyObject *args) {
+    struct xsw_usage totals;
+    vm_statistics64_data_t vmstat;
+    long pagesize = psutil_getpagesize();
+    int mib[2] = {CTL_VM, VM_SWAPUSAGE};
+    PyObject *dict = PyDict_New();
+
+    if (dict == NULL)
+        return NULL;
+
+    if (psutil_sysctl(mib, 2, &totals, sizeof(totals)) != 0)
+        goto error;
+    if (psutil_sys_vminfo(&vmstat) != 0)
+        goto error;
+
+    // clang-format off
+    if (!pydict_add(dict, "total", "K", (unsigned long long)totals.xsu_total)) goto error;
+    if (!pydict_add(dict, "used", "K", (unsigned long long)totals.xsu_used)) goto error;
+    if (!pydict_add(dict, "free", "K", (unsigned long long)totals.xsu_avail)) goto error;
+    if (!pydict_add(dict, "sin", "K", (unsigned long long)vmstat.pageins * pagesize)) goto error;
+    if (!pydict_add(dict, "sout", "K", (unsigned long long)vmstat.pageouts * pagesize)) goto error;
+    // clang-format on
+
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    return NULL;
+}
diff --git a/psutil/arch/osx/net.c b/psutil/arch/osx/net.c
new file mode 100644
index 0000000000..54b5f29174
--- /dev/null
+++ b/psutil/arch/osx/net.c
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Networks related functions. Original code was refactored and moved
+// from psutil/_psutil_osx.c in 2023. This is the GIT blame before the move:
+// https://github.com/giampaolo/psutil/blame/efd7ed3/psutil/_psutil_osx.c
+
+#include <Python.h>
+#include <stddef.h>
+#include <sys/socket.h>
+#include <sys/sysctl.h>
+#include <net/if.h>
+#include <net/if_dl.h>
+#include <net/route.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_net_io_counters(PyObject *self, PyObject *args) {
+    char *buf = NULL, *lim, *next;
+    struct if_msghdr *ifm;
+    int mib[6];
+    size_t len = 0;
+    PyObject *py_ifc_info = NULL;
+    PyObject *py_retdict = PyDict_New();
+
+    if (py_retdict == NULL)
+        return NULL;
+
+    mib[0] = CTL_NET;  // networking subsystem
+    mib[1] = PF_ROUTE;  // type of information
+    mib[2] = 0;  // protocol (IPPROTO_xxx)
+    mib[3] = 0;  // address family
+    mib[4] = NET_RT_IFLIST2;  // operation
+    mib[5] = 0;
+
+    if (psutil_sysctl_malloc(mib, 6, &buf, &len) != 0)
+        goto error;
+
+    lim = buf + len;
+
+    for (next = buf; next < lim;) {
+        if ((size_t)(lim - next) < offsetof(struct if_msghdr, ifm_addrs)) {
+            psutil_warn("truncated route message (skip remaining)");
+            break;
+        }
+
+        ifm = (struct if_msghdr *)next;
+
+        if (ifm->ifm_msglen == 0 || next + ifm->ifm_msglen > lim) {
+            psutil_warn("ifm_msglen size mismatch (skip entry)");
+            break;
+        }
+
+        next += ifm->ifm_msglen;
+
+        if (ifm->ifm_type == RTM_IFINFO2) {
+            py_ifc_info = NULL;
+            struct if_msghdr2 *if2m = (struct if_msghdr2 *)ifm;
+
+            if ((char *)if2m + sizeof(struct if_msghdr2) > lim) {
+                psutil_warn("if_msghdr2 + sockaddr_dl mismatch (skip entry)");
+                continue;
+            }
+
+            struct sockaddr_dl *sdl = (struct sockaddr_dl *)(if2m + 1);
+
+            if ((char *)sdl + sizeof(struct sockaddr_dl) > lim) {
+                psutil_warn("not enough buffer for sockaddr_dl (skip entry)");
+                continue;
+            }
+
+            char ifc_name[IFNAMSIZ];
+            size_t namelen = sdl->sdl_nlen;
+            if (namelen >= IFNAMSIZ)
+                namelen = IFNAMSIZ - 1;
+
+            memcpy(ifc_name, sdl->sdl_data, namelen);
+            ifc_name[namelen] = '\0';
+
+            py_ifc_info = Py_BuildValue(
+                "(KKKKKKKi)",
+                (unsigned long long)if2m->ifm_data.ifi_obytes,
+                (unsigned long long)if2m->ifm_data.ifi_ibytes,
+                (unsigned long long)if2m->ifm_data.ifi_opackets,
+                (unsigned long long)if2m->ifm_data.ifi_ipackets,
+                (unsigned long long)if2m->ifm_data.ifi_ierrors,
+                (unsigned long long)if2m->ifm_data.ifi_oerrors,
+                (unsigned long long)if2m->ifm_data.ifi_iqdrops,
+                0
+            );  // dropout not supported
+
+            if (!py_ifc_info)
+                goto error;
+
+            if (PyDict_SetItemString(py_retdict, ifc_name, py_ifc_info)) {
+                Py_CLEAR(py_ifc_info);
+                goto error;
+            }
+
+            Py_CLEAR(py_ifc_info);
+        }
+    }
+
+    free(buf);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_ifc_info);
+    Py_DECREF(py_retdict);
+    if (buf != NULL)
+        free(buf);
+    return NULL;
+}
diff --git a/psutil/arch/osx/pids.c b/psutil/arch/osx/pids.c
new file mode 100644
index 0000000000..debd8af4d6
--- /dev/null
+++ b/psutil/arch/osx/pids.c
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/user.h>
+
+#include "../../arch/all/init.h"
+
+
+int
+_psutil_pids(pid_t **pids_array, int *pids_count) {
+    int mib[3] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL};
+    size_t len = 0;
+    char *buf = NULL;
+    struct kinfo_proc *proc_list = NULL;
+    size_t num_procs = 0;
+
+    *pids_array = NULL;
+    *pids_count = 0;
+
+    if (psutil_sysctl_malloc(mib, 3, &buf, &len) != 0)
+        return -1;
+
+    if (len == 0) {
+        psutil_runtime_error("no PIDs found");
+        goto error;
+    }
+
+    proc_list = (struct kinfo_proc *)buf;
+    num_procs = len / sizeof(struct kinfo_proc);
+
+    *pids_array = malloc(num_procs * sizeof(pid_t));
+    if (!*pids_array) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    for (size_t i = 0; i < num_procs; i++) {
+        (*pids_array)[i] = proc_list[i].kp_proc.p_pid;
+    }
+
+    *pids_count = (int)num_procs;
+    free(buf);
+    return 0;
+
+error:
+    if (buf != NULL)
+        free(buf);
+    return -1;
+}
diff --git a/psutil/arch/osx/proc.c b/psutil/arch/osx/proc.c
new file mode 100644
index 0000000000..17d06fa47c
--- /dev/null
+++ b/psutil/arch/osx/proc.c
@@ -0,0 +1,1038 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Process related functions. Original code was moved in here from
+// psutil/_psutil_osx.c and psutil/arc/osx/process_info.c in 2023.
+// For reference, here's the GIT blame history before the move:
+// https://github.com/giampaolo/psutil/blame/59504a5/psutil/_psutil_osx.c
+// https://github.com/giampaolo/psutil/blame/efd7ed3/psutil/arch/osx/process_info.c
+
+#include <Python.h>
+#include <AvailabilityMacros.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/sysctl.h>
+#include <libproc.h>
+#include <sys/proc_info.h>
+#include <sys/resource.h>
+#include <sys/sysctl.h>
+#include <netinet/tcp_fsm.h>
+#include <arpa/inet.h>
+#include <pwd.h>
+#include <unistd.h>
+#include <mach/mach.h>
+#include <mach/mach_vm.h>
+#include <mach/shared_region.h>
+#include <mach-o/loader.h>
+
+#include "../../arch/all/init.h"
+
+
+// macOS is apparently the only UNIX where the process "base" status
+// (running, idle, etc.) is unreliable and must be guessed from flags:
+// https://github.com/giampaolo/psutil/issues/2675
+static int
+convert_status(struct extern_proc *p, struct eproc *e) {
+    int flag = p->p_flag;
+    int eflag = e->e_flag;
+
+    // zombies and stopped
+    if (p->p_stat == SZOMB)
+        return SZOMB;
+    if (p->p_stat == SSTOP)
+        return SSTOP;
+
+    if (flag & P_SYSTEM)
+        return SIDL;  // system idle
+    if (flag & P_WEXIT)
+        return SIDL;  // waiting to exit
+    if (flag & P_PPWAIT)
+        return SIDL;  // parent waiting
+    if (eflag & EPROC_SLEADER)
+        return SSLEEP;  // session leader treated as sleeping
+
+    // Default: 99% is SRUN (running)
+    return p->p_stat;
+}
+
+
+// Return multiple process info as a Python dict in one shot by using
+// `sysctl()` and filling up a `kinfo_proc` struct. It should be
+// possible to do this for all processes without incurring into
+// permission (EPERM) errors. This will also succeed for zombie
+// processes returning correct information.
+PyObject *
+psutil_proc_oneshot_kinfo(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int status;
+    struct kinfo_proc kp;
+    PyObject *py_name = NULL;
+    PyObject *dict = PyDict_New();
+
+    if (!dict)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+    if (psutil_get_kinfo_proc(pid, &kp) == -1)
+        goto error;
+
+    py_name = PyUnicode_DecodeFSDefault(kp.kp_proc.p_comm);
+    if (!py_name) {
+        // Likely a decoding error. We don't want to fail the whole
+        // operation. The python module may retry with proc_name().
+        PyErr_Clear();
+        Py_INCREF(Py_None);
+        py_name = Py_None;
+    }
+
+    status = convert_status(&kp.kp_proc, &kp.kp_eproc);
+
+    // clang-format off
+    if (!pydict_add(dict, "ppid", _Py_PARSE_PID, kp.kp_eproc.e_ppid)) goto error;
+    if (!pydict_add(dict, "ruid", "l", (long)kp.kp_eproc.e_pcred.p_ruid)) goto error;
+    if (!pydict_add(dict, "euid", "l", (long)kp.kp_eproc.e_ucred.cr_uid)) goto error;
+    if (!pydict_add(dict, "suid", "l", (long)kp.kp_eproc.e_pcred.p_svuid)) goto error;
+    if (!pydict_add(dict, "rgid", "l", (long)kp.kp_eproc.e_pcred.p_rgid)) goto error;
+    if (!pydict_add(dict, "egid", "l", (long)kp.kp_eproc.e_ucred.cr_groups[0])) goto error;
+    if (!pydict_add(dict, "sgid", "l", (long)kp.kp_eproc.e_pcred.p_svgid)) goto error;
+    if (!pydict_add(dict, "ttynr", "l", (long)kp.kp_eproc.e_tdev)) goto error;
+    if (!pydict_add(dict, "ctime", "d", PSUTIL_TV2DOUBLE(kp.kp_proc.p_starttime))) goto error;
+    if (!pydict_add(dict, "status", "i", status)) goto error;
+    if (!pydict_add(dict, "name", "O", py_name)) goto error;
+    // clang-format on
+
+    Py_DECREF(py_name);
+    return dict;
+
+error:
+    Py_XDECREF(py_name);
+    Py_DECREF(dict);
+    return NULL;
+}
+
+
+// Return multiple process info as a Python dict in one shot by
+// using `proc_pidinfo(PROC_PIDTASKINFO)` and filling a proc_taskinfo
+// struct.
+// Contrarily from `proc_kinfo` above this function will fail with
+// EACCES for PIDs owned by another user and with ESRCH for zombie
+// processes.
+PyObject *
+psutil_proc_oneshot_pidtaskinfo(PyObject *self, PyObject *args) {
+    pid_t pid;
+    struct proc_taskinfo pti;
+    unsigned long maj_faults;
+    unsigned long min_faults;
+    PyObject *dict = PyDict_New();
+
+    if (!dict)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+    if (psutil_proc_pidinfo(pid, PROC_PIDTASKINFO, 0, &pti, sizeof(pti)) != 0)
+        goto error;
+
+    // Match getrusage() ru_majflt and ru_minflt. getrusage() source:
+    // https://github.com/apple/darwin-xnu/blob/2ff845c2e033/bsd/kern/kern_resource.c#L1263-L1265
+    maj_faults = (unsigned long)pti.pti_pageins;
+    min_faults = (unsigned long)pti.pti_faults - maj_faults;
+
+    // clang-format off
+    // pti_total_user/system are in Mach ticks; hw.tbfrequency gives
+    // ticks/second and is not intercepted by Rosetta 2, unlike
+    // mach_timebase_info() which returns numer=1/denom=1 for x86_64
+    // processes on Apple Silicon, causing a 41.67x undercount there.
+    if (!pydict_add(dict, "cpu_utime", "d", (double)pti.pti_total_user / PSUTIL_HW_TBFREQUENCY)) goto error;
+    if (!pydict_add(dict, "cpu_stime", "d", (double)pti.pti_total_system / PSUTIL_HW_TBFREQUENCY)) goto error;
+    // Note about memory: determining other mem stats on macOS is a mess:
+    // http://www.opensource.apple.com/source/top/top-67/libtop.c?txt
+    // I just give up.
+    if (!pydict_add(dict, "rss", "K", pti.pti_resident_size)) goto error;
+    if (!pydict_add(dict, "vms", "K", pti.pti_virtual_size)) goto error;
+    if (!pydict_add(dict, "minor_faults", "k", min_faults)) goto error;
+    if (!pydict_add(dict, "major_faults", "k", maj_faults)) goto error;
+    if (!pydict_add(dict, "num_threads", "k", (unsigned long)pti.pti_threadnum)) goto error;
+    // Unvoluntary not available on macOS. `pti_csw` refers to the
+    // sum of voluntary + involuntary. getrusage() numbers confirm
+    // this theory.
+    if (!pydict_add(dict, "volctxsw", "k", (unsigned long)pti.pti_csw)) goto error;
+    // clang-format on
+
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_name(PyObject *self, PyObject *args) {
+    pid_t pid;
+    struct kinfo_proc kp;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if (psutil_get_kinfo_proc(pid, &kp) == -1)
+        return NULL;
+
+    return PyUnicode_DecodeFSDefault(kp.kp_proc.p_comm);
+}
+
+
+PyObject *
+psutil_proc_cwd(PyObject *self, PyObject *args) {
+    pid_t pid;
+    struct proc_vnodepathinfo pathinfo;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    if (psutil_proc_pidinfo(
+            pid, PROC_PIDVNODEPATHINFO, 0, &pathinfo, sizeof(pathinfo)
+        )
+        != 0)
+    {
+        return NULL;
+    }
+
+    return PyUnicode_DecodeFSDefault(pathinfo.pvi_cdir.vip_path);
+}
+
+
+PyObject *
+psutil_proc_exe(PyObject *self, PyObject *args) {
+    pid_t pid;
+    char buf[PATH_MAX];
+    int ret;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    errno = 0;
+    ret = proc_pidpath(pid, &buf, sizeof(buf));
+    if (ret == 0) {
+        if (pid == 0) {
+            psutil_oserror_ad("automatically set for PID 0");
+            return NULL;
+        }
+        else if (errno == ENOENT) {
+            // It may happen (file not found error) if the process is
+            // still alive but the executable which launched it got
+            // deleted, see:
+            // https://github.com/giampaolo/psutil/issues/1738
+            return PyUnicode_FromString("");
+        }
+        else {
+            psutil_raise_for_pid(pid, "proc_pidpath()");
+            return NULL;
+        }
+    }
+    return PyUnicode_DecodeFSDefault(buf);
+}
+
+
+// Return true if the given virtual address on the given architecture
+// is in the shared VM region.
+static bool
+psutil_in_shared_region(mach_vm_address_t addr, cpu_type_t type) {
+    mach_vm_address_t base;
+    mach_vm_address_t size;
+
+    switch (type) {
+        case CPU_TYPE_ARM:
+            base = SHARED_REGION_BASE_ARM;
+            size = SHARED_REGION_SIZE_ARM;
+            break;
+        case CPU_TYPE_I386:
+            base = SHARED_REGION_BASE_I386;
+            size = SHARED_REGION_SIZE_I386;
+            break;
+        case CPU_TYPE_X86_64:
+            base = SHARED_REGION_BASE_X86_64;
+            size = SHARED_REGION_SIZE_X86_64;
+            break;
+        default:
+            return false;
+    }
+
+    return base <= addr && addr < (base + size);
+}
+
+
+PyObject *
+psutil_proc_memory_extras(PyObject *self, PyObject *args) {
+#if MAC_OS_X_VERSION_MIN_REQUIRED < 1090
+    // proc_pid_rusage() is weak-linked below 10.9: calling it would
+    // jump to NULL instead of failing.
+    PyErr_SetString(
+        PyExc_NotImplementedError, "proc_pid_rusage() requires macOS 10.9+"
+    );
+    return NULL;
+#else
+    pid_t pid;
+    uint64_t phys_footprint = 0;
+    uint64_t peak_footprint = 0;
+    int fetched = 0;
+    struct rusage_info_v0 ri0;
+#ifdef RUSAGE_INFO_V4
+    struct rusage_info_v4 ri4;
+#endif
+    PyObject *dict = NULL;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+#ifdef RUSAGE_INFO_V4
+    // ri_lifetime_max_phys_footprint requires RUSAGE_INFO_V4 (macOS
+    // 10.13). Before that only phys_footprint is available and
+    // peak_footprint stays 0.
+    if (proc_pid_rusage(pid, RUSAGE_INFO_V4, (rusage_info_t *)&ri4) == 0) {
+        phys_footprint = ri4.ri_phys_footprint;
+        peak_footprint = ri4.ri_lifetime_max_phys_footprint;
+        fetched = 1;
+    }
+    else if (errno != EINVAL) {
+        psutil_raise_for_pid(pid, "proc_pid_rusage()");
+        return NULL;
+    }
+    else {
+        psutil_debug("proc_pid_rusage(V4) -> EINVAL; falling back to V0");
+    }
+#endif
+
+    if (!fetched) {
+        if (proc_pid_rusage(pid, RUSAGE_INFO_V0, (rusage_info_t *)&ri0) != 0) {
+            psutil_raise_for_pid(pid, "proc_pid_rusage()");
+            return NULL;
+        }
+        phys_footprint = ri0.ri_phys_footprint;
+    }
+
+    dict = PyDict_New();
+    if (!dict)
+        return NULL;
+
+    // clang-format off
+    if (!pydict_add(dict, "phys_footprint", "K", (unsigned long long)phys_footprint)) goto error;
+    if (!pydict_add(dict, "peak_footprint", "K", (unsigned long long)peak_footprint)) goto error;
+    // clang-format on
+
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    return NULL;
+#endif
+}
+
+
+// Return process USS (unique set size) memory. Reference:
+// https://dxr.mozilla.org/mozilla-central/source/xpcom/base/nsMemoryReporterManager.cpp
+PyObject *
+psutil_proc_memory_uss(PyObject *self, PyObject *args) {
+    pid_t pid;
+    cpu_type_t cpu_type;
+    size_t private_pages = 0;
+    long pagesize = psutil_getpagesize();
+    uint64_t addr = 0;
+    uint64_t next_addr;
+    int ret;
+    int nregions = 0;
+    char *errmsg = NULL;
+    struct proc_regioninfo ri;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    if (psutil_sysctlbyname("sysctl.proc_cputype", &cpu_type, sizeof(cpu_type))
+        != 0)
+    {
+        return NULL;
+    }
+
+    // Sum up process private (unique) resident pages by walking its VM
+    // regions. Roughly based on libtop_update_vm_regions in:
+    // http://www.opensource.apple.com/source/top/top-100.1.2/libtop.c
+    // The walk can take a long time (or hang) on a process we don't own,
+    // see https://github.com/giampaolo/psutil/issues/2885, so run it
+    // without the GIL. Exceptions are raised further below.
+    Py_BEGIN_ALLOW_THREADS
+    while (1) {
+        errno = 0;
+        ret = proc_pidinfo(pid, PROC_PIDREGIONINFO, addr, &ri, sizeof(ri));
+
+        if (ret <= 0) {
+            // A failure on the first region means the process is gone or
+            // not accessible; past that it just means we reached the end
+            // of the address space.
+            if (nregions == 0)
+                errmsg = "proc_pidinfo(PROC_PIDREGIONINFO)";
+            break;
+        }
+        if (ret != sizeof(ri)) {
+            errmsg = "proc_pidinfo(PROC_PIDREGIONINFO) truncated";
+            break;
+        }
+        nregions += 1;
+
+        if (!(psutil_in_shared_region(ri.pri_address, cpu_type)
+              && ri.pri_share_mode != SM_PRIVATE))
+        {
+            switch (ri.pri_share_mode) {
+#ifdef SM_LARGE_PAGE
+                case SM_LARGE_PAGE:
+                    // NB: Large pages are not shareable and always resident.
+#endif
+                case SM_PRIVATE:
+                    private_pages += ri.pri_private_pages_resident;
+                    private_pages += ri.pri_shared_pages_resident;
+                    break;
+                case SM_COW:
+                    private_pages += ri.pri_private_pages_resident;
+                    if (ri.pri_ref_count == 1) {
+                        // Treat copy-on-write pages as private if they
+                        // only have one reference.
+                        private_pages += ri.pri_shared_pages_resident;
+                    }
+                    break;
+                case SM_SHARED:
+                default:
+                    break;
+            }
+        }
+
+        next_addr = ri.pri_address + ri.pri_size;
+        if (ri.pri_size == 0 || next_addr <= addr) {
+            psutil_warn("VM region walk not advancing; stopped early");
+            break;
+        }
+        addr = next_addr;
+    }
+    Py_END_ALLOW_THREADS
+
+    if (errmsg != NULL)
+        return psutil_raise_for_pid(pid, errmsg);
+
+    return Py_BuildValue("K", (unsigned long long)private_pages * pagesize);
+}
+
+
+PyObject *
+psutil_proc_threads(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int ret;
+    int buf_size;
+    int num_threads;
+    int i;
+    uint64_t *tids = NULL;
+    struct proc_taskinfo pti;
+    struct proc_threadinfo ti;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+
+    // Get size.
+    if (psutil_proc_pidinfo(pid, PROC_PIDTASKINFO, 0, &pti, sizeof(pti)) != 0)
+        goto error;
+    buf_size = (int)((pti.pti_threadnum + 32) * sizeof(uint64_t));
+    tids = malloc(buf_size);
+    if (tids == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    errno = 0;
+    ret = proc_pidinfo(pid, PROC_PIDLISTTHREADS, 0, tids, buf_size);
+    if (ret <= 0) {
+        psutil_raise_for_pid(pid, "proc_pidinfo(PROC_PIDLISTTHREADS)");
+        goto error;
+    }
+    num_threads = ret / (int)sizeof(uint64_t);
+
+    for (i = 0; i < num_threads; i++) {
+        if (psutil_proc_pidinfo(
+                pid, PROC_PIDTHREADINFO, tids[i], &ti, sizeof(ti)
+            )
+            != 0)
+        {
+            // Thread vanished between listing and query; skip it.
+            PyErr_Clear();
+            psutil_debug("PROC_PIDTHREADINFO failed; thread gone");
+            continue;
+        }
+
+        // Unlike PROC_PIDTASKINFO's Mach-tick totals, pth_user_time and
+        // pth_system_time are already in nanoseconds.
+        if (!pylist_append_fmt(
+                py_retlist,
+                "Kdd",
+                (unsigned long long)tids[i],
+                (double)ti.pth_user_time / 1000000000.0,
+                (double)ti.pth_system_time / 1000000000.0
+            ))
+        {
+            goto error;
+        }
+    }
+
+    free(tids);
+    return py_retlist;
+
+error:
+    if (tids != NULL)
+        free(tids);
+    Py_XDECREF(py_retlist);
+    return NULL;
+}
+
+
+// Return process open files as a Python tuple.
+// See lsof source code:
+// https://github.com/apple-opensource/lsof/blob/28/lsof/dialects/darwin/libproc/dproc.c#L342
+// ...and /usr/include/sys/proc_info.h
+PyObject *
+psutil_proc_open_files(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int num_fds;
+    int i;
+    unsigned long nb;
+    struct proc_fdinfo *fds_pointer = NULL;
+    struct proc_fdinfo *fdp_pointer;
+    struct vnode_fdinfowithpath vi;
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_path = NULL;
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+
+    // see: https://github.com/giampaolo/psutil/issues/2116
+    if (pid == 0)
+        return py_retlist;
+
+    fds_pointer = psutil_proc_list_fds(pid, &num_fds);
+    if (fds_pointer == NULL)
+        goto error;
+
+    for (i = 0; i < num_fds; i++) {
+        fdp_pointer = &fds_pointer[i];
+
+        if (fdp_pointer->proc_fdtype == PROX_FDTYPE_VNODE) {
+            errno = 0;
+            nb = proc_pidfdinfo(
+                (pid_t)pid,
+                fdp_pointer->proc_fd,
+                PROC_PIDFDVNODEPATHINFO,
+                &vi,
+                sizeof(vi)
+            );
+
+            // --- errors checking
+            if ((nb <= 0) || nb < sizeof(vi)) {
+                if ((errno == ENOENT) || (errno == EBADF)) {
+                    // no such file or directory or bad file descriptor;
+                    // let's assume the file has been closed or removed
+                    continue;
+                }
+                else {
+                    psutil_raise_for_pid(
+                        pid, "proc_pidinfo(PROC_PIDFDVNODEPATHINFO)"
+                    );
+                    goto error;
+                }
+            }
+            // --- /errors checking
+
+            // --- construct python list
+            py_path = PyUnicode_DecodeFSDefault(vi.pvip.vip_path);
+            if (!py_path)
+                goto error;
+            if (!pylist_append_fmt(
+                    py_retlist, "(Oi)", py_path, (int)fdp_pointer->proc_fd
+                ))
+            {
+                goto error;
+            }
+            Py_CLEAR(py_path);
+            // --- /construct python list
+        }
+    }
+
+    free(fds_pointer);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_path);
+    Py_DECREF(py_retlist);
+    if (fds_pointer != NULL)
+        free(fds_pointer);
+    return NULL;  // exception has already been set earlier
+}
+
+
+// Return process TCP and UDP connections as a list of tuples.
+// See lsof source code:
+// https://github.com/apple-opensource/lsof/blob/28/lsof/dialects/darwin/libproc/dproc.c#L342
+// ...and /usr/include/sys/proc_info.h
+PyObject *
+psutil_proc_net_connections(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int num_fds;
+    int i;
+    psutil_conn_filters filters;
+    unsigned long nb;
+    struct proc_fdinfo *fds_pointer = NULL;
+    struct proc_fdinfo *fdp_pointer;
+    struct socket_fdinfo si;
+    const char *ntopret;
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_laddr = NULL;
+    PyObject *py_raddr = NULL;
+    PyObject *py_af_filter = NULL;
+    PyObject *py_type_filter = NULL;
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    if (!PyArg_ParseTuple(
+            args, _Py_PARSE_PID "OO", &pid, &py_af_filter, &py_type_filter
+        ))
+    {
+        goto error;
+    }
+
+    // see: https://github.com/giampaolo/psutil/issues/2116
+    if (pid == 0)
+        return py_retlist;
+
+    if (psutil_parse_conn_filters(py_af_filter, py_type_filter, &filters) != 0)
+        goto error;
+
+    fds_pointer = psutil_proc_list_fds(pid, &num_fds);
+    if (fds_pointer == NULL)
+        goto error;
+
+    for (i = 0; i < num_fds; i++) {
+        py_laddr = NULL;
+        py_raddr = NULL;
+        fdp_pointer = &fds_pointer[i];
+
+        if (fdp_pointer->proc_fdtype == PROX_FDTYPE_SOCKET) {
+            nb = proc_pidfdinfo(
+                pid,
+                fdp_pointer->proc_fd,
+                PROC_PIDFDSOCKETINFO,
+                &si,
+                sizeof(si)
+            );
+
+            // --- errors checking
+            if ((nb <= 0) || (nb < sizeof(si))) {
+                if (errno == EBADF) {
+                    // let's assume socket has been closed
+                    psutil_debug(
+                        "proc_pidfdinfo(PROC_PIDFDSOCKETINFO) -> "
+                        "EBADF (ignored)"
+                    );
+                    continue;
+                }
+                else if (errno == EOPNOTSUPP) {
+                    // may happen sometimes, see:
+                    // https://github.com/giampaolo/psutil/issues/1512
+                    psutil_debug(
+                        "proc_pidfdinfo(PROC_PIDFDSOCKETINFO) -> "
+                        "EOPNOTSUPP (ignored)"
+                    );
+                    continue;
+                }
+                else {
+                    psutil_raise_for_pid(
+                        pid, "proc_pidinfo(PROC_PIDFDSOCKETINFO)"
+                    );
+                    goto error;
+                }
+            }
+            // --- /errors checking
+
+            //
+            int fd, family, type, lport, rport, state;
+            char lip[INET6_ADDRSTRLEN], rip[INET6_ADDRSTRLEN];
+
+            fd = (int)fdp_pointer->proc_fd;
+            family = si.psi.soi_family;
+            type = si.psi.soi_type;
+
+            // apply filters
+            if (!((family == AF_INET && filters.v4)
+                  || (family == AF_INET6 && filters.v6)
+                  || (family == AF_UNIX && filters.unix_)))
+            {
+                continue;
+            }
+            if (!((type == SOCK_STREAM && filters.tcp)
+                  || (type == SOCK_DGRAM && filters.udp)))
+            {
+                continue;
+            }
+
+            if ((family == AF_INET) || (family == AF_INET6)) {
+                if (family == AF_INET) {
+                    ntopret = inet_ntop(
+                        AF_INET,
+                        &si.psi.soi_proto.pri_tcp.tcpsi_ini.insi_laddr.ina_46
+                             .i46a_addr4,
+                        lip,
+                        sizeof(lip)
+                    );
+                    if (!ntopret) {
+                        psutil_oserror_wsyscall("inet_ntop()");
+                        goto error;
+                    }
+                    ntopret = inet_ntop(
+                        AF_INET,
+                        &si.psi.soi_proto.pri_tcp.tcpsi_ini.insi_faddr.ina_46
+                             .i46a_addr4,
+                        rip,
+                        sizeof(rip)
+                    );
+                    if (!ntopret) {
+                        psutil_oserror_wsyscall("inet_ntop()");
+                        goto error;
+                    }
+                }
+                else {
+                    ntopret = inet_ntop(
+                        AF_INET6,
+                        &si.psi.soi_proto.pri_tcp.tcpsi_ini.insi_laddr.ina_6,
+                        lip,
+                        sizeof(lip)
+                    );
+                    if (!ntopret) {
+                        psutil_oserror_wsyscall("inet_ntop()");
+                        goto error;
+                    }
+                    ntopret = inet_ntop(
+                        AF_INET6,
+                        &si.psi.soi_proto.pri_tcp.tcpsi_ini.insi_faddr.ina_6,
+                        rip,
+                        sizeof(rip)
+                    );
+                    if (!ntopret) {
+                        psutil_oserror_wsyscall("inet_ntop()");
+                        goto error;
+                    }
+                }
+
+                lport = ntohs(si.psi.soi_proto.pri_tcp.tcpsi_ini.insi_lport);
+                rport = ntohs(si.psi.soi_proto.pri_tcp.tcpsi_ini.insi_fport);
+                if (type == SOCK_STREAM)
+                    state = (int)si.psi.soi_proto.pri_tcp.tcpsi_state;
+                else
+                    state = PSUTIL_CONN_NONE;
+
+                py_laddr = Py_BuildValue("(si)", lip, lport);
+                if (!py_laddr)
+                    goto error;
+                if (rport != 0)
+                    py_raddr = Py_BuildValue("(si)", rip, rport);
+                else
+                    py_raddr = Py_BuildValue("()");
+                if (!py_raddr)
+                    goto error;
+
+                if (!pylist_append_fmt(
+                        py_retlist,
+                        "(iiiNNi)",
+                        fd,
+                        family,
+                        type,
+                        py_laddr,
+                        py_raddr,
+                        state
+                    ))
+                {
+                    goto error;
+                }
+                py_laddr = NULL;
+                py_raddr = NULL;
+            }
+            else if (family == AF_UNIX) {
+                py_laddr = PyUnicode_DecodeFSDefault(
+                    si.psi.soi_proto.pri_un.unsi_addr.ua_sun.sun_path
+                );
+                if (!py_laddr)
+                    goto error;
+                py_raddr = PyUnicode_DecodeFSDefault(
+                    si.psi.soi_proto.pri_un.unsi_caddr.ua_sun.sun_path
+                );
+                if (!py_raddr)
+                    goto error;
+
+                if (!pylist_append_fmt(
+                        py_retlist,
+                        "(iiiOOi)",
+                        fd,
+                        family,
+                        type,
+                        py_laddr,
+                        py_raddr,
+                        PSUTIL_CONN_NONE
+                    ))
+                {
+                    goto error;
+                }
+                Py_CLEAR(py_laddr);
+                Py_CLEAR(py_raddr);
+            }
+        }
+    }
+
+    free(fds_pointer);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_laddr);
+    Py_XDECREF(py_raddr);
+    Py_DECREF(py_retlist);
+    if (fds_pointer != NULL)
+        free(fds_pointer);
+    return NULL;
+}
+
+
+/*
+ * Return number of file descriptors opened by process.
+ * Raises NSP in case of zombie process.
+ */
+PyObject *
+psutil_proc_num_fds(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int num_fds;
+    struct proc_fdinfo *fds_pointer;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    fds_pointer = psutil_proc_list_fds(pid, &num_fds);
+    if (fds_pointer == NULL)
+        return NULL;
+
+    free(fds_pointer);
+    return Py_BuildValue("i", num_fds);
+}
+
+
+PyObject *
+psutil_proc_cmdline(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int nargs;
+    size_t len;
+    char *procargs = NULL;
+    char *arg_ptr;
+    char *arg_end;
+    char *curr_arg;
+    size_t argmax;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+
+    // special case for PID 0 (kernel_task) where cmdline cannot be fetched
+    if (pid == 0)
+        return py_retlist;
+
+    // read argmax and allocate memory for argument space.
+    argmax = psutil_sysctl_argmax();
+    if (argmax == 0)
+        goto error;
+
+    procargs = (char *)malloc(argmax);
+    if (NULL == procargs) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    if (psutil_sysctl_procargs(pid, procargs, &argmax) != 0)
+        goto error;
+
+    arg_end = &procargs[argmax];
+    // copy the number of arguments to nargs
+    memcpy(&nargs, procargs, sizeof(nargs));
+
+    arg_ptr = procargs + sizeof(nargs);
+    len = strlen(arg_ptr);
+    arg_ptr += len + 1;
+
+    if (arg_ptr == arg_end) {
+        free(procargs);
+        return py_retlist;
+    }
+
+    // skip ahead to the first argument
+    for (; arg_ptr < arg_end; arg_ptr++) {
+        if (*arg_ptr != '\0')
+            break;
+    }
+
+    // iterate through arguments
+    curr_arg = arg_ptr;
+    while (arg_ptr < arg_end && nargs > 0) {
+        if (*arg_ptr++ == '\0') {
+            if (!pylist_append_obj(
+                    py_retlist, PyUnicode_DecodeFSDefault(curr_arg)
+                ))
+                goto error;
+            // iterate to next arg and decrement # of args
+            curr_arg = arg_ptr;
+            nargs--;
+        }
+    }
+
+    free(procargs);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_retlist);
+    if (procargs != NULL)
+        free(procargs);
+    return NULL;
+}
+
+
+// Return process environment as a python string.
+// On Big Sur this function returns an empty string unless:
+// * kernel is DEVELOPMENT || DEBUG
+// * target process is same as current_proc()
+// * target process is not cs_restricted
+// * SIP is off
+// * caller has an entitlement
+// See:
+// https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/kern/kern_sysctl.c#L1315-L1321
+PyObject *
+psutil_proc_environ(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int nargs;
+    char *procargs = NULL;
+    char *procenv = NULL;
+    char *arg_ptr;
+    char *arg_end;
+    char *env_start;
+    size_t argmax;
+    size_t env_len;
+    PyObject *py_ret = NULL;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    // PID 0 (kernel_task) has no cmdline.
+    if (pid == 0)
+        goto empty;
+
+    // Allocate buffer for process args.
+    argmax = psutil_sysctl_argmax();
+    if (argmax == 0)
+        goto error;
+
+    procargs = (char *)malloc(argmax);
+    if (procargs == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    if (psutil_sysctl_procargs(pid, procargs, &argmax) != 0)
+        goto error;
+
+    arg_end = procargs + argmax;
+
+    // Copy nargs.
+    memcpy(&nargs, procargs, sizeof(nargs));
+
+    // skip executable path
+    arg_ptr = procargs + sizeof(nargs);
+    arg_ptr = memchr(arg_ptr, '\0', arg_end - arg_ptr);
+    if (arg_ptr == NULL || arg_ptr >= arg_end)
+        goto empty;
+
+    // Skip null bytes until first argument.
+    while (arg_ptr < arg_end && *arg_ptr == '\0')
+        arg_ptr++;
+
+    // Skip arguments.
+    while (arg_ptr < arg_end && nargs > 0) {
+        if (*arg_ptr++ == '\0')
+            nargs--;
+    }
+
+    if (arg_ptr >= arg_end)
+        goto empty;
+
+    env_start = arg_ptr;
+
+    // Compute maximum possible environment length.
+    env_len = (size_t)(arg_end - env_start);
+    if (env_len == 0)
+        goto empty;
+
+    procenv = (char *)calloc(1, env_len);
+    if (procenv == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    while (arg_ptr < arg_end && *arg_ptr != '\0') {
+        // Find the next NUL terminator.
+        size_t rem = (size_t)(arg_end - arg_ptr);
+        char *s = memchr(arg_ptr, '\0', rem);
+        if (s == NULL)
+            break;
+
+        size_t copy_len = (size_t)(s - arg_ptr);
+        size_t offset = (size_t)(arg_ptr - env_start);
+        if (offset + copy_len >= env_len)
+            break;  // prevent overflow.
+
+        memcpy(procenv + offset, arg_ptr, copy_len);
+        arg_ptr = s + 1;
+    }
+
+    size_t used = (size_t)(arg_ptr - env_start);
+    if (used >= env_len)
+        used = env_len - 1;
+
+    py_ret = PyUnicode_DecodeFSDefaultAndSize(procenv, (Py_ssize_t)used);
+    if (py_ret == NULL) {
+        procargs = NULL;  // don't double free; see psutil issue #926.
+        goto error;
+    }
+
+    free(procargs);
+    free(procenv);
+    return py_ret;
+
+empty:
+    psutil_debug("set environ to empty");
+    if (procargs != NULL)
+        free(procargs);
+    return PyUnicode_FromString("");
+
+error:
+    Py_XDECREF(py_ret);
+    if (procargs != NULL)
+        free(procargs);
+    if (procenv != NULL)
+        free(procenv);
+    return NULL;
+}
diff --git a/psutil/arch/osx/proc_utils.c b/psutil/arch/osx/proc_utils.c
new file mode 100644
index 0000000000..3b09b2ea91
--- /dev/null
+++ b/psutil/arch/osx/proc_utils.c
@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <sys/user.h>
+#include <unistd.h>
+#include <mach/mach.h>
+#include <libproc.h>
+#include <stdint.h>
+#include <stdbool.h>
+
+#include "../../arch/all/init.h"
+
+
+int
+psutil_get_kinfo_proc(pid_t pid, struct kinfo_proc *kp) {
+    int mib[4];
+    size_t len;
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROC;
+    mib[2] = KERN_PROC_PID;
+    mib[3] = pid;
+
+    if (pid < 0 || !kp)
+        return psutil_badargs("psutil_get_kinfo_proc");
+
+    len = sizeof(struct kinfo_proc);
+
+    if (sysctl(mib, 4, kp, &len, NULL, 0) == -1) {
+        // raise an exception and throw errno as the error
+        psutil_oserror_wsyscall("sysctl");
+        return -1;
+    }
+
+    // sysctl succeeds but len is zero, happens when process has gone away
+    if (len == 0) {
+        psutil_oserror_nsp("sysctl(kinfo_proc), len == 0");
+        return -1;
+    }
+    return 0;
+}
+
+
+// Return 1 if PID a zombie, else 0 (including on error).
+int
+is_zombie(size_t pid) {
+    struct kinfo_proc kp;
+
+    if (psutil_get_kinfo_proc(pid, &kp) == -1) {
+        errno = 0;
+        PyErr_Clear();
+        return 0;
+    }
+    return kp.kp_proc.p_stat == SZOMB;
+}
+
+
+// Read process argument space.
+int
+psutil_sysctl_procargs(pid_t pid, char *procargs, size_t *argmax) {
+    int mib[3];
+
+    mib[0] = CTL_KERN;
+    mib[1] = KERN_PROCARGS2;
+    mib[2] = pid;
+
+    if (pid < 0 || !procargs || !argmax || *argmax == 0)
+        return psutil_badargs("psutil_sysctl_procargs");
+
+    if (sysctl(mib, 3, procargs, argmax, NULL, 0) < 0) {
+        if (psutil_pid_exists(pid) == 0) {
+            psutil_oserror_nsp("psutil_pid_exists -> 0");
+            return -1;
+        }
+
+        if (is_zombie(pid) == 1) {
+            PyErr_SetString(ZombieProcessError, "");
+            return -1;
+        }
+
+        if (errno == EINVAL) {
+            psutil_debug("sysctl(KERN_PROCARGS2) -> EINVAL translated to AD");
+            psutil_oserror_ad("sysctl(KERN_PROCARGS2) -> EINVAL");
+            return -1;
+        }
+
+        if (errno == EIO) {
+            psutil_debug("sysctl(KERN_PROCARGS2) -> EIO translated to AD");
+            psutil_oserror_ad("sysctl(KERN_PROCARGS2) -> EIO");
+            return -1;
+        }
+        if (errno == 0) {
+            // see: https://github.com/giampaolo/psutil/issues/2708
+            psutil_debug("sysctl(KERN_PROCARGS2) -> errno 0");
+            psutil_oserror_ad("sysctl(KERN_PROCARGS2) -> errno 0");
+            return -1;
+        }
+        psutil_oserror_wsyscall("sysctl(KERN_PROCARGS2)");
+        return -1;
+    }
+    return 0;
+}
+
+
+// A wrapper around proc_pidinfo().
+// https://opensource.apple.com/source/xnu/xnu-2050.7.9/bsd/kern/proc_info.c
+// Returns 0 on failure.
+int
+psutil_proc_pidinfo(pid_t pid, int flavor, uint64_t arg, void *pti, int size) {
+    int ret;
+
+    if (pid < 0 || !pti || size <= 0)
+        return psutil_badargs("psutil_proc_pidinfo");
+
+    errno = 0;
+    ret = proc_pidinfo(pid, flavor, arg, pti, size);
+    if (ret <= 0) {
+        psutil_raise_for_pid(pid, "proc_pidinfo()");
+        return -1;
+    }
+
+    // check for truncated return size
+    if (ret < size) {
+        psutil_raise_for_pid(
+            pid, "proc_pidinfo() returned less data than requested buffer size"
+        );
+        return -1;
+    }
+
+    return 0;
+}
+
+
+// A wrapper around proc_pidinfo(PROC_PIDLISTFDS), which dynamically sets
+// the buffer size.
+struct proc_fdinfo *
+psutil_proc_list_fds(pid_t pid, int *num_fds) {
+    int ret;
+    int fds_size = 0;
+    int max_size = 24 * 1024 * 1024;  // 24M
+    struct proc_fdinfo *fds_pointer = NULL;
+
+    if (pid < 0 || num_fds == NULL) {
+        psutil_badargs("psutil_proc_list_fds");
+        return NULL;
+    }
+
+    errno = 0;
+    ret = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, NULL, 0);
+    if (ret <= 0) {
+        psutil_raise_for_pid(pid, "proc_pidinfo(PROC_PIDLISTFDS) 1/2");
+        goto error;
+    }
+
+    while (1) {
+        if (ret > fds_size) {
+            while (ret > fds_size) {
+                fds_size += PROC_PIDLISTFD_SIZE * 32;
+                if (fds_size > max_size) {
+                    psutil_runtime_error("prevent malloc() to allocate > 24M");
+                    goto error;
+                }
+            }
+
+            if (fds_pointer != NULL) {
+                free(fds_pointer);
+            }
+            fds_pointer = malloc(fds_size);
+
+            if (fds_pointer == NULL) {
+                PyErr_NoMemory();
+                goto error;
+            }
+        }
+
+        errno = 0;
+        ret = proc_pidinfo(pid, PROC_PIDLISTFDS, 0, fds_pointer, fds_size);
+        if (ret <= 0) {
+            psutil_raise_for_pid(pid, "proc_pidinfo(PROC_PIDLISTFDS) 2/2");
+            goto error;
+        }
+
+        if (ret + (int)PROC_PIDLISTFD_SIZE >= fds_size) {
+            psutil_debug("PROC_PIDLISTFDS: make room for 1 extra fd");
+            ret = fds_size + (int)PROC_PIDLISTFD_SIZE;
+            continue;
+        }
+
+        break;
+    }
+
+    *num_fds = (ret / (int)PROC_PIDLISTFD_SIZE);
+    return fds_pointer;
+
+error:
+    if (fds_pointer != NULL)
+        free(fds_pointer);
+    return NULL;
+}
diff --git a/psutil/arch/osx/process_info.c b/psutil/arch/osx/process_info.c
deleted file mode 100644
index 4c4ec88d10..0000000000
--- a/psutil/arch/osx/process_info.c
+++ /dev/null
@@ -1,410 +0,0 @@
-/*
- * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Helper functions related to fetching process information.
- * Used by _psutil_osx module methods.
- */
-
-
-#include <Python.h>
-#include <assert.h>
-#include <errno.h>
-#include <limits.h>  // for INT_MAX
-#include <stdbool.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <signal.h>
-#include <sys/sysctl.h>
-#include <libproc.h>
-
-#include "process_info.h"
-#include "../../_psutil_common.h"
-
-
-/*
- * Return 1 if PID exists in the current process list, else 0, -1
- * on error.
- * TODO: this should live in _psutil_posix.c but for some reason if I
- * move it there I get a "include undefined symbol" error.
- */
-int
-psutil_pid_exists(long pid) {
-    int ret;
-    if (pid < 0)
-        return 0;
-    ret = kill(pid , 0);
-    if (ret == 0)
-        return 1;
-    else {
-        return 0;
-        /*
-        // This is how it is handled on other POSIX systems but it causes
-        // test_halfway_terminated test to fail with AccessDenied.
-        if (ret == ESRCH)
-            return 0;
-        else if (ret == EPERM)
-            return 1;
-        else {
-            PyErr_SetFromErrno(PyExc_OSError);
-            return -1;
-        }
-        */
-    }
-}
-
-
-/*
- * Returns a list of all BSD processes on the system.  This routine
- * allocates the list and puts it in *procList and a count of the
- * number of entries in *procCount.  You are responsible for freeing
- * this list (use "free" from System framework).
- * On success, the function returns 0.
- * On error, the function returns a BSD errno value.
- */
-int
-psutil_get_proc_list(kinfo_proc **procList, size_t *procCount) {
-    // Declaring mib as const requires use of a cast since the
-    // sysctl prototype doesn't include the const modifier.
-    static const int mib3[3] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL };
-    size_t           size, size2;
-    void            *ptr;
-    int              err, lim = 8;  // some limit
-
-    assert( procList != NULL);
-    assert(*procList == NULL);
-    assert(procCount != NULL);
-
-    *procCount = 0;
-
-    /*
-     * We start by calling sysctl with ptr == NULL and size == 0.
-     * That will succeed, and set size to the appropriate length.
-     * We then allocate a buffer of at least that size and call
-     * sysctl with that buffer.  If that succeeds, we're done.
-     * If that call fails with ENOMEM, we throw the buffer away
-     * and try again.
-     * Note that the loop calls sysctl with NULL again.  This is
-     * is necessary because the ENOMEM failure case sets size to
-     * the amount of data returned, not the amount of data that
-     * could have been returned.
-     */
-    while (lim-- > 0) {
-        size = 0;
-        if (sysctl((int *)mib3, 3, NULL, &size, NULL, 0) == -1)
-            return errno;
-        size2 = size + (size >> 3);  // add some
-        if (size2 > size) {
-            ptr = malloc(size2);
-            if (ptr == NULL)
-                ptr = malloc(size);
-            else
-                size = size2;
-        }
-        else {
-            ptr = malloc(size);
-        }
-        if (ptr == NULL)
-            return ENOMEM;
-
-        if (sysctl((int *)mib3, 3, ptr, &size, NULL, 0) == -1) {
-            err = errno;
-            free(ptr);
-            if (err != ENOMEM)
-                return err;
-        }
-        else {
-            *procList = (kinfo_proc *)ptr;
-            *procCount = size / sizeof(kinfo_proc);
-            return 0;
-        }
-    }
-    return ENOMEM;
-}
-
-
-// Read the maximum argument size for processes
-int
-psutil_get_argmax() {
-    int argmax;
-    int mib[] = { CTL_KERN, KERN_ARGMAX };
-    size_t size = sizeof(argmax);
-
-    if (sysctl(mib, 2, &argmax, &size, NULL, 0) == 0)
-        return argmax;
-    return 0;
-}
-
-
-// return process args as a python list
-PyObject *
-psutil_get_cmdline(long pid) {
-    int mib[3];
-    int nargs;
-    int len;
-    char *procargs = NULL;
-    char *arg_ptr;
-    char *arg_end;
-    char *curr_arg;
-    size_t argmax;
-
-    PyObject *py_arg = NULL;
-    PyObject *py_retlist = NULL;
-
-    // special case for PID 0 (kernel_task) where cmdline cannot be fetched
-    if (pid == 0)
-        return Py_BuildValue("[]");
-
-    // read argmax and allocate memory for argument space.
-    argmax = psutil_get_argmax();
-    if (! argmax) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    procargs = (char *)malloc(argmax);
-    if (NULL == procargs) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    // read argument space
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROCARGS2;
-    mib[2] = pid;
-    if (sysctl(mib, 3, procargs, &argmax, NULL, 0) < 0) {
-        if (EINVAL == errno) {
-            // EINVAL == access denied OR nonexistent PID
-            if (psutil_pid_exists(pid))
-                AccessDenied();
-            else
-                NoSuchProcess();
-        }
-        goto error;
-    }
-
-    arg_end = &procargs[argmax];
-    // copy the number of arguments to nargs
-    memcpy(&nargs, procargs, sizeof(nargs));
-
-    arg_ptr = procargs + sizeof(nargs);
-    len = strlen(arg_ptr);
-    arg_ptr += len + 1;
-
-    if (arg_ptr == arg_end) {
-        free(procargs);
-        return Py_BuildValue("[]");
-    }
-
-    // skip ahead to the first argument
-    for (; arg_ptr < arg_end; arg_ptr++) {
-        if (*arg_ptr != '\0')
-            break;
-    }
-
-    // iterate through arguments
-    curr_arg = arg_ptr;
-    py_retlist = Py_BuildValue("[]");
-    if (!py_retlist)
-        goto error;
-    while (arg_ptr < arg_end && nargs > 0) {
-        if (*arg_ptr++ == '\0') {
-#if PY_MAJOR_VERSION >= 3
-            py_arg = PyUnicode_DecodeFSDefault(curr_arg);
-#else
-            py_arg = Py_BuildValue("s", curr_arg);
-#endif
-            if (!py_arg)
-                goto error;
-            if (PyList_Append(py_retlist, py_arg))
-                goto error;
-            Py_DECREF(py_arg);
-            // iterate to next arg and decrement # of args
-            curr_arg = arg_ptr;
-            nargs--;
-        }
-    }
-
-    free(procargs);
-    return py_retlist;
-
-error:
-    Py_XDECREF(py_arg);
-    Py_XDECREF(py_retlist);
-    if (procargs != NULL)
-        free(procargs);
-    return NULL;
-}
-
-
-// return process environment as a python string
-PyObject *
-psutil_get_environ(long pid) {
-    int mib[3];
-    int nargs;
-    char *procargs = NULL;
-    char *procenv = NULL;
-    char *arg_ptr;
-    char *arg_end;
-    char *env_start;
-    size_t argmax;
-    PyObject *py_ret = NULL;
-
-    // special case for PID 0 (kernel_task) where cmdline cannot be fetched
-    if (pid == 0)
-        goto empty;
-
-    // read argmax and allocate memory for argument space.
-    argmax = psutil_get_argmax();
-    if (! argmax) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    procargs = (char *)malloc(argmax);
-    if (NULL == procargs) {
-        PyErr_SetFromErrno(PyExc_OSError);
-        goto error;
-    }
-
-    // read argument space
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROCARGS2;
-    mib[2] = pid;
-    if (sysctl(mib, 3, procargs, &argmax, NULL, 0) < 0) {
-        if (EINVAL == errno) {
-            // EINVAL == access denied OR nonexistent PID
-            if (psutil_pid_exists(pid))
-                AccessDenied();
-            else
-                NoSuchProcess();
-        }
-        goto error;
-    }
-
-    arg_end = &procargs[argmax];
-    // copy the number of arguments to nargs
-    memcpy(&nargs, procargs, sizeof(nargs));
-
-    // skip executable path
-    arg_ptr = procargs + sizeof(nargs);
-    arg_ptr = memchr(arg_ptr, '\0', arg_end - arg_ptr);
-
-    if (arg_ptr == NULL || arg_ptr == arg_end)
-        goto empty;
-
-    // skip ahead to the first argument
-    for (; arg_ptr < arg_end; arg_ptr++) {
-        if (*arg_ptr != '\0')
-            break;
-    }
-
-    // iterate through arguments
-    while (arg_ptr < arg_end && nargs > 0) {
-        if (*arg_ptr++ == '\0')
-            nargs--;
-    }
-
-    // build an environment variable block
-    env_start = arg_ptr;
-
-    procenv = calloc(1, arg_end - arg_ptr);
-
-    if (procenv == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    while (*arg_ptr != '\0' && arg_ptr < arg_end) {
-        char *s = memchr(arg_ptr + 1, '\0', arg_end - arg_ptr);
-
-        if (s == NULL)
-            break;
-
-        memcpy(procenv + (arg_ptr - env_start), arg_ptr, s - arg_ptr);
-
-        arg_ptr = s + 1;
-    }
-
-#if PY_MAJOR_VERSION >= 3
-    py_ret = PyUnicode_FromStringAndSize(procenv, arg_ptr - env_start + 1);
-#else
-    py_ret = PyString_FromStringAndSize(procenv, arg_ptr - env_start + 1);
-#endif
-
-    if (!py_ret)
-        goto error;
-
-    free(procargs);
-    free(procenv);
-
-    return py_ret;
-
-empty:
-    if (procargs != NULL)
-        free(procargs);
-    return Py_BuildValue("s", "");
-
-error:
-    Py_XDECREF(py_ret);
-    if (procargs != NULL)
-        free(procargs);
-    if (procenv != NULL)
-        free(procargs);
-    return NULL;
-}
-
-
-int
-psutil_get_kinfo_proc(pid_t pid, struct kinfo_proc *kp) {
-    int mib[4];
-    size_t len;
-    mib[0] = CTL_KERN;
-    mib[1] = KERN_PROC;
-    mib[2] = KERN_PROC_PID;
-    mib[3] = pid;
-
-    // fetch the info with sysctl()
-    len = sizeof(struct kinfo_proc);
-
-    // now read the data from sysctl
-    if (sysctl(mib, 4, kp, &len, NULL, 0) == -1) {
-        // raise an exception and throw errno as the error
-        PyErr_SetFromErrno(PyExc_OSError);
-        return -1;
-    }
-
-    // sysctl succeeds but len is zero, happens when process has gone away
-    if (len == 0) {
-        NoSuchProcess();
-        return -1;
-    }
-    return 0;
-}
-
-
-/*
- * A thin wrapper around proc_pidinfo()
- */
-int
-psutil_proc_pidinfo(long pid, int flavor, void *pti, int size) {
-    int ret = proc_pidinfo((int)pid, flavor, 0, pti, size);
-    if (ret == 0) {
-        if (! psutil_pid_exists(pid)) {
-            NoSuchProcess();
-            return 0;
-        }
-        else {
-            AccessDenied();
-            return 0;
-        }
-    }
-    else if (ret != size) {
-        AccessDenied();
-        return 0;
-    }
-    else {
-        return 1;
-    }
-}
diff --git a/psutil/arch/osx/process_info.h b/psutil/arch/osx/process_info.h
deleted file mode 100644
index 8bc10ec1bb..0000000000
--- a/psutil/arch/osx/process_info.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include <Python.h>
-
-typedef struct kinfo_proc kinfo_proc;
-
-int psutil_get_argmax(void);
-int psutil_get_kinfo_proc(pid_t pid, struct kinfo_proc *kp);
-int psutil_get_proc_list(kinfo_proc **procList, size_t *procCount);
-int psutil_pid_exists(long pid);
-int psutil_proc_pidinfo(long pid, int flavor, void *pti, int size);
-PyObject* psutil_get_cmdline(long pid);
-PyObject* psutil_get_environ(long pid);
diff --git a/psutil/arch/osx/sensors.c b/psutil/arch/osx/sensors.c
new file mode 100644
index 0000000000..d2f53bf384
--- /dev/null
+++ b/psutil/arch/osx/sensors.c
@@ -0,0 +1,122 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Sensors related functions. Original code was refactored and moved
+// from psutil/_psutil_osx.c in 2023. This is the GIT blame before the move:
+// https://github.com/giampaolo/psutil/blame/efd7ed3/psutil/_psutil_osx.c
+// Original battery code:
+// https://github.com/giampaolo/psutil/commit/e0df5da
+
+
+#include <Python.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <IOKit/ps/IOPowerSources.h>
+#include <IOKit/ps/IOPSKeys.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_sensors_battery(PyObject *self, PyObject *args) {
+    PyObject *py_tuple = NULL;
+    CFTypeRef power_info = NULL;
+    CFArrayRef power_sources_list = NULL;
+    CFDictionaryRef power_sources_information = NULL;
+    CFNumberRef capacity_ref = NULL;
+    CFNumberRef time_to_empty_ref = NULL;
+    CFStringRef ps_state_ref = NULL;
+    uint32_t capacity;  // units are percent
+    int time_to_empty;  // units are minutes
+    int is_power_plugged;
+
+    // Queries the power management stack (IPC + SMC).
+    Py_BEGIN_ALLOW_THREADS
+    power_info = IOPSCopyPowerSourcesInfo();
+    Py_END_ALLOW_THREADS
+    if (!power_info) {
+        psutil_runtime_error("IOPSCopyPowerSourcesInfo() syscall failed");
+        goto error;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    power_sources_list = IOPSCopyPowerSourcesList(power_info);
+    Py_END_ALLOW_THREADS
+    if (!power_sources_list) {
+        psutil_runtime_error("IOPSCopyPowerSourcesList() syscall failed");
+        goto error;
+    }
+
+    if (CFArrayGetCount(power_sources_list) == 0) {
+        PyErr_SetString(PyExc_NotImplementedError, "no battery");
+        goto error;
+    }
+
+    power_sources_information = IOPSGetPowerSourceDescription(
+        power_info, CFArrayGetValueAtIndex(power_sources_list, 0)
+    );
+    if (!power_sources_information) {
+        psutil_runtime_error("Failed to get power source description");
+        goto error;
+    }
+
+    capacity_ref = (CFNumberRef)CFDictionaryGetValue(
+        power_sources_information, CFSTR(kIOPSCurrentCapacityKey)
+    );
+    if (!capacity_ref
+        || !CFNumberGetValue(capacity_ref, kCFNumberSInt32Type, &capacity))
+    {
+        psutil_runtime_error(
+            "No battery capacity information in power sources info"
+        );
+        goto error;
+    }
+
+    ps_state_ref = (CFStringRef)CFDictionaryGetValue(
+        power_sources_information, CFSTR(kIOPSPowerSourceStateKey)
+    );
+    if (!ps_state_ref) {
+        psutil_runtime_error("power source state info missing");
+        goto error;
+    }
+    is_power_plugged = CFStringCompare(
+                           ps_state_ref, CFSTR(kIOPSACPowerValue), 0
+                       )
+                       == kCFCompareEqualTo;
+
+    time_to_empty_ref = (CFNumberRef)CFDictionaryGetValue(
+        power_sources_information, CFSTR(kIOPSTimeToEmptyKey)
+    );
+    if (!time_to_empty_ref
+        || !CFNumberGetValue(
+            time_to_empty_ref, kCFNumberIntType, &time_to_empty
+        ))
+    {
+        // This value is recommended for non-Apple power sources, so
+        // it's not an error if it doesn't exist. We'll return -1 for
+        // "unknown" A value of -1 indicates "Still Calculating the
+        // Time" also for apple power source.
+        time_to_empty = -1;
+    }
+
+    py_tuple = Py_BuildValue(
+        "dii", (double)capacity, time_to_empty, is_power_plugged
+    );
+    if (!py_tuple)
+        goto error;
+
+    CFRelease(power_info);
+    CFRelease(power_sources_list);
+    // Caller should NOT release power_sources_information
+    return py_tuple;
+
+error:
+    if (power_info)
+        CFRelease(power_info);
+    if (power_sources_list)
+        CFRelease(power_sources_list);
+    Py_XDECREF(py_tuple);
+    return NULL;
+}
diff --git a/psutil/arch/osx/sys.c b/psutil/arch/osx/sys.c
new file mode 100644
index 0000000000..3fafcac2b5
--- /dev/null
+++ b/psutil/arch/osx/sys.c
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// System related functions. Original code was refactored and moved
+// from psutil/_psutil_osx.c in 2023. This is the GIT blame before the move:
+// https://github.com/giampaolo/psutil/blame/efd7ed3/psutil/_psutil_osx.c
+
+#include <Python.h>
+#include <sys/sysctl.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_boot_time(PyObject *self, PyObject *args) {
+    // fetch sysctl "kern.boottime"
+    int mib[2] = {CTL_KERN, KERN_BOOTTIME};
+    struct timeval result;
+    time_t boot_time = 0;
+
+    if (psutil_sysctl(mib, 2, &result, sizeof(result)) == -1)
+        return NULL;
+    boot_time = result.tv_sec;
+    return Py_BuildValue("d", (double)boot_time);
+}
diff --git a/psutil/arch/posix/init.c b/psutil/arch/posix/init.c
new file mode 100644
index 0000000000..613d5db3f7
--- /dev/null
+++ b/psutil/arch/posix/init.c
@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <sys/resource.h>
+#include <sys/socket.h>
+
+#include "../all/init.h"
+#include "init.h"
+
+PyObject *ZombieProcessError = NULL;
+
+// "man getpagesize" says:
+//
+// In SUSv2 the getpagesize() call is labeled LEGACY, and in
+// POSIX.1-2001 it has been dropped. Portable applications should
+// employ sysconf(_SC_PAGESIZE) instead of getpagesize(). Most systems
+// allow the synonym _SC_PAGE_SIZE for _SC_PAGESIZE. Whether
+// getpagesize() is present as a Linux system call depends on the
+// architecture.
+long
+psutil_getpagesize(void) {
+#ifdef _SC_PAGESIZE
+    // recommended POSIX
+    return sysconf(_SC_PAGESIZE);
+#elif _SC_PAGE_SIZE
+    // alias
+    return sysconf(_SC_PAGE_SIZE);
+#else
+    // legacy
+    return (long)getpagesize();
+#endif
+}
+
+
+// Exposed so we can test it against Python's stdlib.
+PyObject *
+psutil_getpagesize_pywrapper(PyObject *self, PyObject *args) {
+    return Py_BuildValue("l", psutil_getpagesize());
+}
+
+
+// POSIX-only methods.
+static PyMethodDef posix_methods[] = {
+    {"getpagesize", psutil_getpagesize_pywrapper, METH_VARARGS},
+    {"net_if_addrs", psutil_net_if_addrs, METH_VARARGS},
+    {"net_if_flags", psutil_net_if_flags, METH_VARARGS},
+    {"net_if_is_running", psutil_net_if_is_running, METH_VARARGS},
+    {"net_if_mtu", psutil_net_if_mtu, METH_VARARGS},
+    {"proc_priority_get", psutil_proc_priority_get, METH_VARARGS},
+    {"proc_priority_set", psutil_proc_priority_set, METH_VARARGS},
+#if defined(PSUTIL_BSD) || defined(PSUTIL_OSX)
+    {"net_if_duplex_speed", psutil_net_if_duplex_speed, METH_VARARGS},
+#endif
+#if !defined(PSUTIL_OPENBSD) && !defined(PSUTIL_AIX)
+    {"users", psutil_users, METH_VARARGS},
+#endif
+#if defined(PSUTIL_OSX) || defined(PSUTIL_BSD)
+    {"proc_is_zombie", psutil_proc_is_zombie, METH_VARARGS},
+#endif
+    {NULL, NULL, 0, NULL}
+};
+
+
+// Add POSIX methods to main OS module.
+int
+psutil_posix_add_methods(PyObject *mod) {
+    for (int i = 0; posix_methods[i].ml_name != NULL; i++) {
+        PyObject *f = PyCFunction_NewEx(&posix_methods[i], NULL, mod);
+        if (!f) {
+            return -1;
+        }
+        if (PyModule_AddObject(mod, posix_methods[i].ml_name, f)) {
+            Py_DECREF(f);
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+
+// Add POSIX constants to main OS module.
+int
+psutil_posix_add_constants(PyObject *mod) {
+    if (!mod)
+        return -1;
+
+#if defined(PSUTIL_BSD) || defined(PSUTIL_OSX) || defined(PSUTIL_SUNOS) \
+    || defined(PSUTIL_AIX)
+    PSUTIL_ADD_INT(mod, "AF_LINK", AF_LINK);
+#endif
+
+#if defined(PSUTIL_LINUX) || defined(PSUTIL_FREEBSD)
+    PyObject *v;
+
+#ifdef RLIMIT_AS
+    PSUTIL_ADD_INT(mod, "RLIMIT_AS", RLIMIT_AS);
+#endif
+#ifdef RLIMIT_CORE
+    PSUTIL_ADD_INT(mod, "RLIMIT_CORE", RLIMIT_CORE);
+#endif
+#ifdef RLIMIT_CPU
+    PSUTIL_ADD_INT(mod, "RLIMIT_CPU", RLIMIT_CPU);
+#endif
+#ifdef RLIMIT_DATA
+    PSUTIL_ADD_INT(mod, "RLIMIT_DATA", RLIMIT_DATA);
+#endif
+#ifdef RLIMIT_FSIZE
+    PSUTIL_ADD_INT(mod, "RLIMIT_FSIZE", RLIMIT_FSIZE);
+#endif
+#ifdef RLIMIT_MEMLOCK
+    PSUTIL_ADD_INT(mod, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK);
+#endif
+#ifdef RLIMIT_NOFILE
+    PSUTIL_ADD_INT(mod, "RLIMIT_NOFILE", RLIMIT_NOFILE);
+#endif
+#ifdef RLIMIT_NPROC
+    PSUTIL_ADD_INT(mod, "RLIMIT_NPROC", RLIMIT_NPROC);
+#endif
+#ifdef RLIMIT_RSS
+    PSUTIL_ADD_INT(mod, "RLIMIT_RSS", RLIMIT_RSS);
+#endif
+#ifdef RLIMIT_STACK
+    PSUTIL_ADD_INT(mod, "RLIMIT_STACK", RLIMIT_STACK);
+#endif
+
+    // Linux specific
+
+#ifdef RLIMIT_LOCKS
+    PSUTIL_ADD_INT(mod, "RLIMIT_LOCKS", RLIMIT_LOCKS);
+#endif
+#ifdef RLIMIT_MSGQUEUE
+    PSUTIL_ADD_INT(mod, "RLIMIT_MSGQUEUE", RLIMIT_MSGQUEUE);
+#endif
+#ifdef RLIMIT_NICE
+    PSUTIL_ADD_INT(mod, "RLIMIT_NICE", RLIMIT_NICE);
+#endif
+#ifdef RLIMIT_RTPRIO
+    PSUTIL_ADD_INT(mod, "RLIMIT_RTPRIO", RLIMIT_RTPRIO);
+#endif
+#ifdef RLIMIT_RTTIME
+    PSUTIL_ADD_INT(mod, "RLIMIT_RTTIME", RLIMIT_RTTIME);
+#endif
+#ifdef RLIMIT_SIGPENDING
+    PSUTIL_ADD_INT(mod, "RLIMIT_SIGPENDING", RLIMIT_SIGPENDING);
+#endif
+
+    // FreeBSD specific
+
+#ifdef RLIMIT_SWAP
+    PSUTIL_ADD_INT(mod, "RLIMIT_SWAP", RLIMIT_SWAP);
+#endif
+#ifdef RLIMIT_SBSIZE
+    PSUTIL_ADD_INT(mod, "RLIMIT_SBSIZE", RLIMIT_SBSIZE);
+#endif
+#ifdef RLIMIT_NPTS
+    PSUTIL_ADD_INT(mod, "RLIMIT_NPTS", RLIMIT_NPTS);
+#endif
+
+#if defined(HAVE_LONG_LONG)
+    if (sizeof(RLIM_INFINITY) > sizeof(long)) {
+        v = PyLong_FromLongLong((PY_LONG_LONG)RLIM_INFINITY);
+    }
+    else
+#endif
+    {
+        v = PyLong_FromLong((long)RLIM_INFINITY);
+    }
+    if (v) {
+        if (PyModule_AddObject(mod, "RLIM_INFINITY", v))
+            return -1;
+    }
+#endif  // defined(PSUTIL_LINUX) || defined(PSUTIL_FREEBSD)
+
+    return 0;
+}
diff --git a/psutil/arch/posix/init.h b/psutil/arch/posix/init.h
new file mode 100644
index 0000000000..1500ca0102
--- /dev/null
+++ b/psutil/arch/posix/init.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+extern PyObject *ZombieProcessError;
+
+// convert a timeval struct to a double
+#ifdef PSUTIL_SUNOS
+#define PSUTIL_TV2DOUBLE(t) (((t).tv_nsec * 0.000000001) + (t).tv_sec)
+#else
+#define PSUTIL_TV2DOUBLE(t) ((t).tv_sec + (t).tv_usec / 1000000.0)
+#endif
+
+// clang-format off
+#if !defined(PSUTIL_OPENBSD) && !defined(PSUTIL_AIX)
+    #define PSUTIL_HAS_POSIX_USERS
+    PyObject *psutil_users(PyObject *self, PyObject *args);
+#endif
+
+#if defined(PSUTIL_BSD) || defined(PSUTIL_OSX)
+    #include <sys/types.h>
+    #define PSUTIL_HAS_SYSCTL
+    int psutil_sysctl(int *mib, u_int miblen, void *buf, size_t buflen);
+    int psutil_sysctl_malloc(int *mib, u_int miblen, char **buf, size_t *buflen);
+    size_t psutil_sysctl_argmax();
+
+    #if !defined(PSUTIL_OPENBSD)
+        #define PSUTIL_HAS_SYSCTLBYNAME
+        int psutil_sysctlbyname(const char *name, void *buf, size_t buflen);
+    #endif
+#endif
+
+#if defined(PSUTIL_BSD) || defined(PSUTIL_OSX)
+    #define PSUTIL_HAS_NET_IF_DUPLEX_SPEED
+    PyObject *psutil_net_if_duplex_speed(PyObject *self, PyObject *args);
+#endif
+// clang-format on
+
+// --- internal utils
+
+int psutil_pid_exists(pid_t pid);
+long psutil_getpagesize(void);
+int psutil_posix_add_constants(PyObject *mod);
+int psutil_posix_add_methods(PyObject *mod);
+PyObject *psutil_raise_for_pid(pid_t pid, char *msg);
+
+// --- Python wrappers
+
+PyObject *psutil_getpagesize_pywrapper(PyObject *self, PyObject *args);
+PyObject *psutil_net_if_addrs(PyObject *self, PyObject *args);
+PyObject *psutil_net_if_flags(PyObject *self, PyObject *args);
+PyObject *psutil_net_if_is_running(PyObject *self, PyObject *args);
+PyObject *psutil_net_if_mtu(PyObject *self, PyObject *args);
+PyObject *psutil_proc_priority_get(PyObject *self, PyObject *args);
+PyObject *psutil_proc_priority_set(PyObject *self, PyObject *args);
+#if defined(PSUTIL_OSX) || defined(PSUTIL_BSD)
+PyObject *psutil_proc_is_zombie(PyObject *self, PyObject *args);
+#endif
diff --git a/psutil/arch/posix/net.c b/psutil/arch/posix/net.c
new file mode 100644
index 0000000000..4a8220ccc6
--- /dev/null
+++ b/psutil/arch/posix/net.c
@@ -0,0 +1,688 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <unistd.h>
+
+#ifdef PSUTIL_AIX
+#include "../../arch/aix/ifaddrs.h"
+#else
+#include <ifaddrs.h>
+#endif
+
+#if defined(PSUTIL_LINUX)
+#include <netdb.h>
+#include <linux/types.h>
+#include <linux/if_packet.h>
+#endif
+
+#if defined(PSUTIL_BSD) || defined(PSUTIL_OSX)
+#include <netdb.h>
+#include <netinet/in.h>
+#include <net/if_dl.h>
+#include <sys/sockio.h>
+#include <net/if_media.h>
+#include <net/if.h>
+#endif
+
+#if defined(PSUTIL_SUNOS)
+#include <netdb.h>
+#include <sys/sockio.h>
+#endif
+
+#if defined(PSUTIL_AIX)
+#include <netdb.h>
+#endif
+
+#include "../../arch/all/init.h"
+
+
+// Translate a sockaddr struct into a Python string.
+// Return None if address family is not AF_INET* or AF_PACKET.
+PyObject *
+psutil_convert_ipaddr(struct sockaddr *addr, int family) {
+    char buf[NI_MAXHOST];
+    int err;
+    int addrlen;
+    size_t n;
+    size_t len;
+    const char *data;
+    char *ptr;
+
+    if (addr == NULL) {
+        Py_RETURN_NONE;
+    }
+    else if (family == AF_INET || family == AF_INET6) {
+        if (family == AF_INET)
+            addrlen = sizeof(struct sockaddr_in);
+        else
+            addrlen = sizeof(struct sockaddr_in6);
+        err = getnameinfo(
+            addr, addrlen, buf, sizeof(buf), NULL, 0, NI_NUMERICHOST
+        );
+        if (err != 0) {
+            // XXX we get here on FreeBSD when processing 'lo' / AF_INET6
+            // broadcast. Not sure what to do other than returning None.
+            // ifconfig does not show anything BTW.
+            // psutil_runtime_error(gai_strerror(err));
+            // return NULL;
+            Py_RETURN_NONE;
+        }
+        else {
+            return PyUnicode_FromString(buf);
+        }
+    }
+#ifdef PSUTIL_LINUX
+    else if (family == AF_PACKET) {
+        struct sockaddr_ll *lladdr = (struct sockaddr_ll *)addr;
+        len = lladdr->sll_halen;
+        data = (const char *)lladdr->sll_addr;
+    }
+#elif defined(PSUTIL_BSD) || defined(PSUTIL_OSX)
+    else if (addr->sa_family == AF_LINK) {
+        // Note: prior to Python 3.4 socket module does not expose
+        // AF_LINK so we'll do.
+        struct sockaddr_dl *dladdr = (struct sockaddr_dl *)addr;
+        len = dladdr->sdl_alen;
+        data = LLADDR(dladdr);
+    }
+#endif
+    else {
+        // unknown family
+        Py_RETURN_NONE;
+    }
+
+    // AF_PACKET or AF_LINK
+    if (len > 0) {
+        ptr = buf;
+        for (n = 0; n < len; ++n) {
+            str_format(ptr, sizeof(ptr), "%02x:", data[n] & 0xff);
+            ptr += 3;
+        }
+        *--ptr = '\0';
+        return PyUnicode_FromString(buf);
+    }
+    else {
+        Py_RETURN_NONE;
+    }
+}
+
+
+// Return NICs information a-la ifconfig as a list of tuples.
+// TODO: on Solaris we won't get any MAC address.
+PyObject *
+psutil_net_if_addrs(PyObject *self, PyObject *args) {
+    struct ifaddrs *ifaddr, *ifa;
+    int family;
+    int ret;
+
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_address = NULL;
+    PyObject *py_netmask = NULL;
+    PyObject *py_broadcast = NULL;
+    PyObject *py_ptp = NULL;
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    // Netlink round trip on Linux, a bunch of ioctls on AIX.
+    Py_BEGIN_ALLOW_THREADS
+    ret = getifaddrs(&ifaddr);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) {
+        if (!ifa->ifa_addr)  // virtual NIC
+            goto append_none;
+
+        family = ifa->ifa_addr->sa_family;
+
+        py_address = psutil_convert_ipaddr(ifa->ifa_addr, family);
+        if (py_address == Py_None) {  // virtual NIC
+            Py_CLEAR(py_address);
+            goto append_none;
+        }
+        if (py_address == NULL)
+            goto error;
+
+        py_netmask = psutil_convert_ipaddr(ifa->ifa_netmask, family);
+        if (py_netmask == NULL)
+            goto error;
+
+        if (ifa->ifa_flags & IFF_BROADCAST) {
+            py_broadcast = psutil_convert_ipaddr(ifa->ifa_broadaddr, family);
+            Py_INCREF(Py_None);
+            py_ptp = Py_None;
+        }
+        else if (ifa->ifa_flags & IFF_POINTOPOINT) {
+            py_ptp = psutil_convert_ipaddr(ifa->ifa_dstaddr, family);
+            Py_INCREF(Py_None);
+            py_broadcast = Py_None;
+        }
+        else {
+            Py_INCREF(Py_None);
+            Py_INCREF(Py_None);
+            py_broadcast = Py_None;
+            py_ptp = Py_None;
+        }
+
+        if ((py_broadcast == NULL) || (py_ptp == NULL))
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(siOOOO)",
+                ifa->ifa_name,
+                family,
+                py_address,
+                py_netmask,
+                py_broadcast,
+                py_ptp
+            ))
+        {
+            goto error;
+        }
+        Py_CLEAR(py_address);
+        Py_CLEAR(py_netmask);
+        Py_CLEAR(py_broadcast);
+        Py_CLEAR(py_ptp);
+        continue;
+
+    append_none:
+        // When the primary address can't be determined, still include
+        // the NIC with None values. These are usually virtual
+        // IPv4/IPv6 tunnel interfaces.
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(siOOOO)",
+                ifa->ifa_name,
+                AF_UNSPEC,
+                Py_None,
+                Py_None,
+                Py_None,
+                Py_None
+            ))
+        {
+            goto error;
+        }
+    }
+
+    freeifaddrs(ifaddr);
+    return py_retlist;
+
+error:
+    if (ifaddr != NULL)
+        freeifaddrs(ifaddr);
+    Py_DECREF(py_retlist);
+    Py_XDECREF(py_address);
+    Py_XDECREF(py_netmask);
+    Py_XDECREF(py_broadcast);
+    Py_XDECREF(py_ptp);
+    return NULL;
+}
+
+
+// Return NIC MTU. References:
+// http://www.i-scream.org/libstatgrab/
+PyObject *
+psutil_net_if_mtu(PyObject *self, PyObject *args) {
+    char *nic_name;
+    int sock = -1;
+    int ret;
+    struct ifreq ifr;
+
+    if (!PyArg_ParseTuple(args, "s", &nic_name))
+        return NULL;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock == -1)
+        goto error;
+
+    str_copy(ifr.ifr_name, sizeof(ifr.ifr_name), nic_name);
+    // A NIC driver may take a while to answer.
+    Py_BEGIN_ALLOW_THREADS
+    ret = ioctl(sock, SIOCGIFMTU, &ifr);
+    Py_END_ALLOW_THREADS
+    if (ret == -1)
+        goto error;
+    close(sock);
+
+    return Py_BuildValue("i", ifr.ifr_mtu);
+
+error:
+    if (sock != -1)
+        close(sock);
+    return psutil_oserror();
+}
+
+static int
+append_flag(PyObject *py_retlist, const char *flag_name) {
+    return pylist_append_obj(py_retlist, PyUnicode_FromString(flag_name));
+}
+
+// Get all of the NIC flags and return them.
+PyObject *
+psutil_net_if_flags(PyObject *self, PyObject *args) {
+    char *nic_name;
+    int sock = -1;
+    int ret;
+    struct ifreq ifr;
+    PyObject *py_retlist = PyList_New(0);
+    short int flags;
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    if (!PyArg_ParseTuple(args, "s", &nic_name))
+        goto error;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock == -1) {
+        psutil_oserror_wsyscall("socket(SOCK_DGRAM)");
+        goto error;
+    }
+
+    str_copy(ifr.ifr_name, sizeof(ifr.ifr_name), nic_name);
+    // A NIC driver may take a while to answer.
+    Py_BEGIN_ALLOW_THREADS
+    ret = ioctl(sock, SIOCGIFFLAGS, &ifr);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_oserror_wsyscall("ioctl(SIOCGIFFLAGS)");
+        goto error;
+    }
+
+    close(sock);
+    sock = -1;
+
+    flags = ifr.ifr_flags & 0xFFFF;
+
+    // Linux/glibc IFF flags:
+    // https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/gnu/net/if.h;h=251418f82331c0426e58707fe4473d454893b132;hb=HEAD
+    // macOS IFF flags:
+    // https://opensource.apple.com/source/xnu/xnu-792/bsd/net/if.h.auto.html
+    // AIX IFF flags:
+    // https://www.ibm.com/support/pages/how-hexadecimal-flags-displayed-ifconfig-are-calculated
+    // FreeBSD IFF flags:
+    // https://www.freebsd.org/cgi/man.cgi?query=if_allmulti&apropos=0&sektion=0&manpath=FreeBSD+10-current&format=html
+
+#ifdef IFF_UP
+    // Available in (at least) Linux, macOS, AIX, BSD
+    if (flags & IFF_UP)
+        if (!append_flag(py_retlist, "up"))
+            goto error;
+#endif
+#ifdef IFF_BROADCAST
+    // Available in (at least) Linux, macOS, AIX, BSD
+    if (flags & IFF_BROADCAST)
+        if (!append_flag(py_retlist, "broadcast"))
+            goto error;
+#endif
+#ifdef IFF_DEBUG
+    // Available in (at least) Linux, macOS, BSD
+    if (flags & IFF_DEBUG)
+        if (!append_flag(py_retlist, "debug"))
+            goto error;
+#endif
+#ifdef IFF_LOOPBACK
+    // Available in (at least) Linux, macOS, BSD
+    if (flags & IFF_LOOPBACK)
+        if (!append_flag(py_retlist, "loopback"))
+            goto error;
+#endif
+#ifdef IFF_POINTOPOINT
+    // Available in (at least) Linux, macOS, BSD
+    if (flags & IFF_POINTOPOINT)
+        if (!append_flag(py_retlist, "pointopoint"))
+            goto error;
+#endif
+#ifdef IFF_NOTRAILERS
+    // Available in (at least) Linux, macOS, AIX
+    if (flags & IFF_NOTRAILERS)
+        if (!append_flag(py_retlist, "notrailers"))
+            goto error;
+#endif
+#ifdef IFF_RUNNING
+    // Available in (at least) Linux, macOS, AIX, BSD
+    if (flags & IFF_RUNNING)
+        if (!append_flag(py_retlist, "running"))
+            goto error;
+#endif
+#ifdef IFF_NOARP
+    // Available in (at least) Linux, macOS, BSD
+    if (flags & IFF_NOARP)
+        if (!append_flag(py_retlist, "noarp"))
+            goto error;
+#endif
+#ifdef IFF_PROMISC
+    // Available in (at least) Linux, macOS, BSD
+    if (flags & IFF_PROMISC)
+        if (!append_flag(py_retlist, "promisc"))
+            goto error;
+#endif
+#ifdef IFF_ALLMULTI
+    // Available in (at least) Linux, macOS, BSD
+    if (flags & IFF_ALLMULTI)
+        if (!append_flag(py_retlist, "allmulti"))
+            goto error;
+#endif
+#ifdef IFF_MASTER
+    // Available in (at least) Linux
+    if (flags & IFF_MASTER)
+        if (!append_flag(py_retlist, "master"))
+            goto error;
+#endif
+#ifdef IFF_SLAVE
+    // Available in (at least) Linux
+    if (flags & IFF_SLAVE)
+        if (!append_flag(py_retlist, "slave"))
+            goto error;
+#endif
+#ifdef IFF_MULTICAST
+    // Available in (at least) Linux, macOS, BSD
+    if (flags & IFF_MULTICAST)
+        if (!append_flag(py_retlist, "multicast"))
+            goto error;
+#endif
+#ifdef IFF_PORTSEL
+    // Available in (at least) Linux
+    if (flags & IFF_PORTSEL)
+        if (!append_flag(py_retlist, "portsel"))
+            goto error;
+#endif
+#ifdef IFF_AUTOMEDIA
+    // Available in (at least) Linux
+    if (flags & IFF_AUTOMEDIA)
+        if (!append_flag(py_retlist, "automedia"))
+            goto error;
+#endif
+#ifdef IFF_DYNAMIC
+    // Available in (at least) Linux
+    if (flags & IFF_DYNAMIC)
+        if (!append_flag(py_retlist, "dynamic"))
+            goto error;
+#endif
+#ifdef IFF_OACTIVE
+    // Available in (at least) macOS, BSD
+    if (flags & IFF_OACTIVE)
+        if (!append_flag(py_retlist, "oactive"))
+            goto error;
+#endif
+#ifdef IFF_SIMPLEX
+    // Available in (at least) macOS, AIX, BSD
+    if (flags & IFF_SIMPLEX)
+        if (!append_flag(py_retlist, "simplex"))
+            goto error;
+#endif
+#ifdef IFF_LINK0
+    // Available in (at least) macOS, BSD
+    if (flags & IFF_LINK0)
+        if (!append_flag(py_retlist, "link0"))
+            goto error;
+#endif
+#ifdef IFF_LINK1
+    // Available in (at least) macOS, BSD
+    if (flags & IFF_LINK1)
+        if (!append_flag(py_retlist, "link1"))
+            goto error;
+#endif
+#ifdef IFF_LINK2
+    // Available in (at least) macOS, BSD
+    if (flags & IFF_LINK2)
+        if (!append_flag(py_retlist, "link2"))
+            goto error;
+#endif
+#ifdef IFF_D2
+    // Available in (at least) AIX
+    if (flags & IFF_D2)
+        if (!append_flag(py_retlist, "d2"))
+            goto error;
+#endif
+
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    if (sock != -1)
+        close(sock);
+    return NULL;
+}
+
+
+// Inspect NIC flags, returns a bool indicating whether the NIC is
+// running. References:
+// http://www.i-scream.org/libstatgrab/
+PyObject *
+psutil_net_if_is_running(PyObject *self, PyObject *args) {
+    char *nic_name;
+    int sock = -1;
+    int ret;
+    struct ifreq ifr;
+
+    if (!PyArg_ParseTuple(args, "s", &nic_name))
+        return NULL;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock == -1)
+        goto error;
+
+    str_copy(ifr.ifr_name, sizeof(ifr.ifr_name), nic_name);
+    // A NIC driver may take a while to answer.
+    Py_BEGIN_ALLOW_THREADS
+    ret = ioctl(sock, SIOCGIFFLAGS, &ifr);
+    Py_END_ALLOW_THREADS
+    if (ret == -1)
+        goto error;
+
+    close(sock);
+    if ((ifr.ifr_flags & IFF_RUNNING) != 0)
+        return Py_BuildValue("O", Py_True);
+    else
+        return Py_BuildValue("O", Py_False);
+
+error:
+    if (sock != -1)
+        close(sock);
+    return psutil_oserror();
+}
+
+
+// net_if_stats() macOS/BSD implementation.
+#ifdef PSUTIL_HAS_NET_IF_DUPLEX_SPEED
+
+int
+psutil_get_nic_speed(int ifm_active) {
+    // Determine NIC speed. Taken from:
+    // http://www.i-scream.org/libstatgrab/
+    // Assuming only ETHER devices
+    switch (IFM_TYPE(ifm_active)) {
+        case IFM_ETHER:
+            switch (IFM_SUBTYPE(ifm_active)) {
+#if defined(IFM_HPNA_1) \
+    && ((!defined(IFM_10G_LR)) || (IFM_10G_LR != IFM_HPNA_1))
+                // HomePNA 1.0 (1Mb/s)
+                case (IFM_HPNA_1):
+                    return 1;
+#endif
+                // 10 Mbit
+                case (IFM_10_T):  // 10BaseT - RJ45
+                case (IFM_10_2):  // 10Base2 - Thinnet
+                case (IFM_10_5):  // 10Base5 - AUI
+                case (IFM_10_STP):  // 10BaseT over shielded TP
+                case (IFM_10_FL):  // 10baseFL - Fiber
+                    return 10;
+                // 100 Mbit
+                case (IFM_100_TX):  // 100BaseTX - RJ45
+                case (IFM_100_FX):  // 100BaseFX - Fiber
+                case (IFM_100_T4):  // 100BaseT4 - 4 pair cat 3
+                case (IFM_100_VG):  // 100VG-AnyLAN
+                case (IFM_100_T2):  // 100BaseT2
+                    return 100;
+                // 1000 Mbit
+                case (IFM_1000_SX):  // 1000BaseSX - multi-mode fiber
+                case (IFM_1000_LX):  // 1000baseLX - single-mode fiber
+                case (IFM_1000_CX):  // 1000baseCX - 150ohm STP
+#if defined(IFM_1000_TX) && !defined(PSUTIL_OPENBSD)
+#define HAS_CASE_IFM_1000_TX 1
+                // FreeBSD 4 and others (but NOT OpenBSD) -> #define IFM_1000_T
+                // in net/if_media.h
+                case (IFM_1000_TX):
+#endif
+#ifdef IFM_1000_FX
+                case (IFM_1000_FX):
+#endif
+#if defined(IFM_1000_T) && (!HAS_CASE_IFM_1000_TX || IFM_1000_T != IFM_1000_TX)
+                case (IFM_1000_T):
+#endif
+                    return 1000;
+#if defined(IFM_10G_SR) || defined(IFM_10G_LR) || defined(IFM_10G_CX4) \
+    || defined(IFM_10G_T)
+#ifdef IFM_10G_SR
+                case (IFM_10G_SR):
+#endif
+#ifdef IFM_10G_LR
+                case (IFM_10G_LR):
+#endif
+#ifdef IFM_10G_CX4
+                case (IFM_10G_CX4):
+#endif
+#ifdef IFM_10G_TWINAX
+                case (IFM_10G_TWINAX):
+#endif
+#ifdef IFM_10G_TWINAX_LONG
+                case (IFM_10G_TWINAX_LONG):
+#endif
+#ifdef IFM_10G_T
+                case (IFM_10G_T):
+#endif
+                    return 10000;
+#endif
+#if defined(IFM_2500_SX)
+#ifdef IFM_2500_SX
+                case (IFM_2500_SX):
+#endif
+                    return 2500;
+#endif  // any 2.5GBit stuff...
+        // We don't know what it is
+                default:
+                    return 0;
+            }
+            break;
+
+#ifdef IFM_TOKEN
+        case IFM_TOKEN:
+            switch (IFM_SUBTYPE(ifm_active)) {
+                case IFM_TOK_STP4:  // Shielded twisted pair 4m - DB9
+                case IFM_TOK_UTP4:  // Unshielded twisted pair 4m - RJ45
+                    return 4;
+                case IFM_TOK_STP16:  // Shielded twisted pair 16m - DB9
+                case IFM_TOK_UTP16:  // Unshielded twisted pair 16m - RJ45
+                    return 16;
+#if defined(IFM_TOK_STP100) || defined(IFM_TOK_UTP100)
+#ifdef IFM_TOK_STP100
+                case IFM_TOK_STP100:  // Shielded twisted pair 100m - DB9
+#endif
+#ifdef IFM_TOK_UTP100
+                case IFM_TOK_UTP100:  // Unshielded twisted pair 100m - RJ45
+#endif
+                    return 100;
+#endif
+                // We don't know what it is
+                default:
+                    return 0;
+            }
+            break;
+#endif
+
+#ifdef IFM_FDDI
+        case IFM_FDDI:
+            switch (IFM_SUBTYPE(ifm_active)) {
+                // We don't know what it is
+                default:
+                    return 0;
+            }
+            break;
+#endif
+        case IFM_IEEE80211:
+            switch (IFM_SUBTYPE(ifm_active)) {
+                case IFM_IEEE80211_FH1:  // Frequency Hopping 1Mbps
+                case IFM_IEEE80211_DS1:  // Direct Sequence 1Mbps
+                    return 1;
+                case IFM_IEEE80211_FH2:  // Frequency Hopping 2Mbps
+                case IFM_IEEE80211_DS2:  // Direct Sequence 2Mbps
+                    return 2;
+                case IFM_IEEE80211_DS5:  // Direct Sequence 5Mbps
+                    return 5;
+                case IFM_IEEE80211_DS11:  // Direct Sequence 11Mbps
+                    return 11;
+                case IFM_IEEE80211_DS22:  // Direct Sequence 22Mbps
+                    return 22;
+                // We don't know what it is
+                default:
+                    return 0;
+            }
+            break;
+
+        default:
+            return 0;
+    }
+}
+
+
+// Return stats about a particular network interface.
+// References:
+// http://www.i-scream.org/libstatgrab/
+PyObject *
+psutil_net_if_duplex_speed(PyObject *self, PyObject *args) {
+    char *nic_name;
+    int sock = -1;
+    int ret;
+    int duplex;
+    int speed;
+    struct ifreq ifr;
+    struct ifmediareq ifmed;
+
+    if (!PyArg_ParseTuple(args, "s", &nic_name))
+        return NULL;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock == -1)
+        return psutil_oserror();
+    str_copy(ifr.ifr_name, sizeof(ifr.ifr_name), nic_name);
+
+    // speed / duplex
+    memset(&ifmed, 0, sizeof(struct ifmediareq));
+    str_copy(ifmed.ifm_name, sizeof(ifmed.ifm_name), nic_name);
+    // A NIC driver may take a while to answer.
+    Py_BEGIN_ALLOW_THREADS
+    ret = ioctl(sock, SIOCGIFMEDIA, (caddr_t)&ifmed);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        speed = 0;
+        duplex = 0;
+    }
+    else {
+        speed = psutil_get_nic_speed(ifmed.ifm_active);
+        if ((ifmed.ifm_active | IFM_FDX) == ifmed.ifm_active)
+            duplex = 2;
+        else if ((ifmed.ifm_active | IFM_HDX) == ifmed.ifm_active)
+            duplex = 1;
+        else
+            duplex = 0;
+    }
+
+    close(sock);
+    return Py_BuildValue("[ii]", duplex, speed);
+}
+#endif  // PSUTIL_HAS_NET_IF_DUPLEX_SPEED
diff --git a/psutil/arch/posix/pids.c b/psutil/arch/posix/pids.c
new file mode 100644
index 0000000000..368c53c91a
--- /dev/null
+++ b/psutil/arch/posix/pids.c
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <sys/types.h>
+#include <signal.h>
+#include <errno.h>
+
+#include "../../arch/all/init.h"
+
+
+static int
+has_pid_zero(void) {
+#if defined(PSUTIL_LINUX) || defined(PSUTIL_FREEBSD)
+    return 0;
+#else
+    return 1;
+#endif
+}
+
+
+// Check if PID exists. Return values:
+// 1: exists
+// 0: does not exist
+// -1: error (Python exception is set)
+int
+psutil_pid_exists(pid_t pid) {
+    int ret;
+
+    // No negative PID exists, plus -1 is an alias for sending signal
+    // too all processes except system ones. Not what we want.
+    if (pid < 0)
+        return 0;
+
+    // As per "man 2 kill" PID 0 is an alias for sending the signal to
+    // every process in the process group of the calling process. Not
+    // what we want. Some platforms have PID 0, some do not. We decide
+    // that at runtime.
+    if (pid == 0)
+        return has_pid_zero();
+
+    ret = kill(pid, 0);
+    if (ret == 0)
+        return 1;
+
+    // ESRCH == No such process
+    if (errno == ESRCH)
+        return 0;
+
+    // EPERM clearly indicates there's a process to deny access to.
+    if (errno == EPERM)
+        return 1;
+
+    // According to "man 2 kill" possible error values are (EINVAL,
+    // EPERM, ESRCH) therefore we should never get here.
+    return -1;
+}
diff --git a/psutil/arch/posix/proc.c b/psutil/arch/posix/proc.c
new file mode 100644
index 0000000000..f8cd7e6a92
--- /dev/null
+++ b/psutil/arch/posix/proc.c
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/resource.h>
+
+#include "../../arch/all/init.h"
+
+
+#if defined(PSUTIL_OSX) || defined(PSUTIL_BSD)
+// Return True if PID is a zombie else False, including if PID does not
+// exist or the underlying function fails (never raise exception).
+PyObject *
+psutil_proc_is_zombie(PyObject *self, PyObject *args) {
+    pid_t pid;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if (is_zombie(pid) == 1)
+        Py_RETURN_TRUE;
+    else
+        Py_RETURN_FALSE;
+}
+#endif
+
+
+// Utility used for those syscalls which do not return a meaningful
+// error that we can directly translate into an exception which makes
+// sense. As such we'll have to guess, e.g. if errno is set or if PID
+// does not exist. If reason can't be determined raise RuntimeError.
+PyObject *
+psutil_raise_for_pid(pid_t pid, char *syscall) {
+    if (errno != 0)
+        psutil_oserror_wsyscall(syscall);
+    else if (psutil_pid_exists(pid) == 0)
+        psutil_oserror_nsp(syscall);
+#if defined(PSUTIL_OSX) || defined(PSUTIL_BSD)
+    else if (is_zombie(pid))
+        PyErr_SetString(ZombieProcessError, "");
+#endif
+    else
+        psutil_runtime_error("%s syscall failed", syscall);
+    return NULL;
+}
+
+
+// Get PID priority.
+PyObject *
+psutil_proc_priority_get(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int priority;
+    errno = 0;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+#ifdef PSUTIL_OSX
+    priority = getpriority(PRIO_PROCESS, (id_t)pid);
+#else
+    priority = getpriority(PRIO_PROCESS, pid);
+#endif
+    if (errno != 0)
+        return psutil_oserror();
+    return Py_BuildValue("i", priority);
+}
+
+
+// Set PID priority.
+PyObject *
+psutil_proc_priority_set(PyObject *self, PyObject *args) {
+    pid_t pid;
+    int priority;
+    int retval;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i", &pid, &priority))
+        return NULL;
+
+#ifdef PSUTIL_OSX
+    retval = setpriority(PRIO_PROCESS, (id_t)pid, priority);
+#else
+    retval = setpriority(PRIO_PROCESS, pid, priority);
+#endif
+    if (retval == -1)
+        return psutil_oserror();
+    Py_RETURN_NONE;
+}
diff --git a/psutil/arch/posix/sysctl.c b/psutil/arch/posix/sysctl.c
new file mode 100644
index 0000000000..e68030f1a8
--- /dev/null
+++ b/psutil/arch/posix/sysctl.c
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "../../arch/all/init.h"
+
+#ifdef PSUTIL_HAS_SYSCTL
+#include <Python.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
+
+
+static const int MAX_RETRIES = 10;
+
+
+// A thin wrapper on top of sysctl().
+int
+psutil_sysctl(int *mib, u_int miblen, void *buf, size_t buflen) {
+    size_t len = buflen;
+
+    if (!mib || miblen == 0 || !buf || buflen == 0)
+        return psutil_badargs("psutil_sysctl");
+
+    if (sysctl(mib, miblen, buf, &len, NULL, 0) == -1) {
+        psutil_oserror_wsyscall("sysctl()");
+        return -1;
+    }
+
+    if (len > buflen) {
+        psutil_runtime_error("sysctl() size mismatch");
+        return -1;
+    }
+
+    return 0;
+}
+
+
+// Allocate buffer for sysctl with retry on ENOMEM or buffer size mismatch.
+// The caller is responsible for freeing the memory.
+int
+psutil_sysctl_malloc(int *mib, u_int miblen, char **buf, size_t *buflen) {
+    size_t needed = 0;
+    char *buffer = NULL;
+    int ret;
+    int max_retries = MAX_RETRIES;
+
+    if (!mib || miblen == 0 || !buf || !buflen)
+        return psutil_badargs("psutil_sysctl_malloc");
+
+    // Unlike the fixed-size reads in psutil_sysctl(), these queries
+    // fetch whole kernel tables (processes, sockets, disks). The
+    // kernel walks them under lock, which can take a while on busy
+    // systems, so release the GIL. This includes the size probes:
+    // counting the table costs about as much as copying it.
+
+    // First query to determine required size
+    Py_BEGIN_ALLOW_THREADS
+    ret = sysctl(mib, miblen, NULL, &needed, NULL, 0);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_oserror_wsyscall("sysctl() malloc 1/3");
+        return -1;
+    }
+
+    if (needed == 0) {
+        psutil_debug("psutil_sysctl_malloc() size = 0");
+    }
+
+    while (max_retries-- > 0) {
+        // zero-initialize buffer to prevent uninitialized bytes
+        buffer = calloc(1, needed);
+        if (buffer == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+
+        size_t len = needed;
+        Py_BEGIN_ALLOW_THREADS
+        ret = sysctl(mib, miblen, buffer, &len, NULL, 0);
+        Py_END_ALLOW_THREADS
+
+        if (ret == 0) {
+            // Success: return buffer and length
+            *buf = buffer;
+            *buflen = len;
+            return 0;
+        }
+
+        // Handle buffer too small
+        if (errno == ENOMEM) {
+            free(buffer);
+            buffer = NULL;
+
+            // Re-query needed size for next attempt
+            Py_BEGIN_ALLOW_THREADS
+            ret = sysctl(mib, miblen, NULL, &needed, NULL, 0);
+            Py_END_ALLOW_THREADS
+            if (ret == -1) {
+                psutil_oserror_wsyscall("sysctl() malloc 2/3");
+                return -1;
+            }
+
+            psutil_debug("psutil_sysctl_malloc() retry");
+            continue;
+        }
+
+        // Other errors: clean up and give up
+        free(buffer);
+        psutil_oserror_wsyscall("sysctl() malloc 3/3");
+        return -1;
+    }
+
+    psutil_runtime_error("sysctl() buffer allocation retry limit exceeded");
+    return -1;
+}
+
+
+// Get the maximum process arguments size. Return 0 on error.
+size_t
+psutil_sysctl_argmax() {
+    int argmax;
+    int mib[2] = {CTL_KERN, KERN_ARGMAX};
+
+    if (psutil_sysctl(mib, 2, &argmax, sizeof(argmax)) != 0) {
+        return 0;
+    }
+
+    if (argmax <= 0) {
+        psutil_runtime_error("sysctl(KERN_ARGMAX) return <= 0");
+        return 0;
+    }
+
+    return (size_t)argmax;
+}
+
+
+#ifdef PSUTIL_HAS_SYSCTLBYNAME
+// A thin wrapper on top of sysctlbyname().
+int
+psutil_sysctlbyname(const char *name, void *buf, size_t buflen) {
+    size_t len = buflen;
+    char errbuf[256];
+
+    if (!name || !buf || buflen == 0)
+        return psutil_badargs("psutil_sysctlbyname");
+
+    if (sysctlbyname(name, buf, &len, NULL, 0) == -1) {
+        str_format(errbuf, sizeof(errbuf), "sysctlbyname('%s')", name);
+        psutil_oserror_wsyscall(errbuf);
+        return -1;
+    }
+
+    if (len > buflen) {
+        str_format(
+            errbuf,
+            sizeof(errbuf),
+            "sysctlbyname('%s') size mismatch: returned %zu, expected %zu",
+            name,
+            len,
+            buflen
+        );
+        psutil_runtime_error(errbuf);
+        return -1;
+    }
+
+    return 0;
+}
+
+
+#endif  // PSUTIL_HAS_SYSCTLBYNAME
+#endif  // PSUTIL_HAS_SYSCTL
diff --git a/psutil/arch/posix/users.c b/psutil/arch/posix/users.c
new file mode 100644
index 0000000000..21f50973f9
--- /dev/null
+++ b/psutil/arch/posix/users.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "../../arch/all/init.h"
+
+#ifdef PSUTIL_HAS_POSIX_USERS
+#include <Python.h>
+#include <string.h>
+
+#include <utmpx.h>
+
+
+// The utmpx functions are not thread safe: there is one global
+// cursor per process, and each getutxent() call advances it. Two
+// threads iterating at the same time would each get only some of
+// the entries. The whole loop must run under a lock. On normal
+// builds the GIL acts as that lock, so this file must not release
+// it.
+static void
+setup() {
+    UTXENT_MUTEX_LOCK();
+    setutxent();
+}
+
+
+static void
+teardown() {
+    endutxent();
+    UTXENT_MUTEX_UNLOCK();
+}
+
+
+PyObject *
+psutil_users(PyObject *self, PyObject *args) {
+    struct utmpx *ut;
+    size_t host_len;
+    PyObject *py_username = NULL;
+    PyObject *py_tty = NULL;
+    PyObject *py_hostname = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    setup();
+
+    while ((ut = getutxent()) != NULL) {
+        if (ut->ut_type != USER_PROCESS)
+            continue;
+
+        py_username = PyUnicode_DecodeFSDefault(ut->ut_user);
+        if (!py_username)
+            goto error;
+
+        py_tty = PyUnicode_DecodeFSDefault(ut->ut_line);
+        if (!py_tty)
+            goto error;
+
+        host_len = strnlen(ut->ut_host, sizeof(ut->ut_host));
+        if (host_len == 0 || (strcmp(ut->ut_host, ":0") == 0)
+            || (strcmp(ut->ut_host, ":0.0") == 0))
+        {
+            py_hostname = PyUnicode_DecodeFSDefault("localhost");
+        }
+        else {
+            // ut_host might not be null-terminated if the hostname is
+            // very long, so we do it. The extra byte is for the
+            // terminator, since host_len can be sizeof(ut_host).
+            char hostbuf[sizeof(ut->ut_host) + 1];
+            memcpy(hostbuf, ut->ut_host, host_len);
+            hostbuf[host_len] = '\0';
+            py_hostname = PyUnicode_DecodeFSDefault(hostbuf);
+        }
+        if (!py_hostname)
+            goto error;
+
+        if (!pylist_append_fmt(
+                py_retlist,
+                "OOOd" _Py_PARSE_PID,
+                py_username,  // username
+                py_tty,  // tty
+                py_hostname,  // hostname
+                (double)ut->ut_tv.tv_sec,  // tstamp
+                ut->ut_pid  // process id
+            ))
+        {
+            goto error;
+        }
+        Py_CLEAR(py_username);
+        Py_CLEAR(py_tty);
+        Py_CLEAR(py_hostname);
+    }
+
+    teardown();
+    return py_retlist;
+
+error:
+    teardown();
+    Py_XDECREF(py_username);
+    Py_XDECREF(py_tty);
+    Py_XDECREF(py_hostname);
+    Py_DECREF(py_retlist);
+    return NULL;
+}
+#endif  // PSUTIL_HAS_POSIX_USERS
diff --git a/psutil/arch/solaris/v10/ifaddrs.c b/psutil/arch/solaris/v10/ifaddrs.c
deleted file mode 100644
index 59529e6af8..0000000000
--- a/psutil/arch/solaris/v10/ifaddrs.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/* Refrences:
- * https://lists.samba.org/archive/samba-technical/2009-February/063079.html
- * http://stackoverflow.com/questions/4139405/#4139811
- * https://code.google.com/p/openpgm/source/browse/trunk/openpgm/pgm/getifaddrs.c
- */
-
-#include <string.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <net/if.h>
-#include <netinet/in.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/sockio.h>
-
-#include "ifaddrs.h"
-
-#define MAX(x,y) ((x)>(y)?(x):(y))
-#define SIZE(p) MAX((p).ss_len,sizeof(p))
-
-
-static struct sockaddr *
-sa_dup (struct sockaddr *sa1)
-{
-    struct sockaddr *sa2;
-    size_t sz = sizeof(sa1);
-    sa2 = (struct sockaddr *) calloc(1,sz);
-    memcpy(sa2,sa1,sz);
-    return(sa2);
-}
-
-
-void freeifaddrs (struct ifaddrs *ifp)
-{
-    if (NULL == ifp) return;
-    free(ifp->ifa_name);
-    free(ifp->ifa_addr);
-    free(ifp->ifa_netmask);
-    free(ifp->ifa_dstaddr);
-    freeifaddrs(ifp->ifa_next);
-    free(ifp);
-}
-
-
-int getifaddrs (struct ifaddrs **ifap)
-{
-    int sd = -1;
-    char *ccp, *ecp;
-    struct lifconf ifc;
-    struct lifreq *ifr;
-    struct lifnum lifn;
-    struct ifaddrs *cifa = NULL; /* current */
-    struct ifaddrs *pifa = NULL; /* previous */
-    const size_t IFREQSZ = sizeof(struct lifreq);
-
-    sd = socket(AF_INET, SOCK_STREAM, 0);
-    if (sd < 0)
-        goto error;
-
-    ifc.lifc_buf = NULL;
-    *ifap = NULL;
-    /* find how much memory to allocate for the SIOCGLIFCONF call */
-    lifn.lifn_family = AF_UNSPEC;
-    lifn.lifn_flags = 0;
-    if (ioctl(sd, SIOCGLIFNUM, &lifn) < 0)
-        goto error;
-
-    /* Sun and Apple code likes to pad the interface count here in case interfaces
-     * are coming up between calls */
-    lifn.lifn_count += 4;
-
-    ifc.lifc_family = AF_UNSPEC;
-    ifc.lifc_len = lifn.lifn_count * sizeof(struct lifreq);
-    ifc.lifc_buf = calloc(1, ifc.lifc_len);
-    if (ioctl(sd, SIOCGLIFCONF, &ifc) < 0)
-        goto error;
-
-    ccp = (char *)ifc.lifc_req;
-    ecp = ccp + ifc.lifc_len;
-
-    while (ccp < ecp) {
-
-        ifr = (struct lifreq *) ccp;
-        cifa = (struct ifaddrs *) calloc(1, sizeof(struct ifaddrs));
-        cifa->ifa_next = NULL;
-        cifa->ifa_name = strdup(ifr->lifr_name);
-
-        if (pifa == NULL) *ifap = cifa; /* first one */
-        else pifa->ifa_next = cifa;
-
-        if (ioctl(sd, SIOCGLIFADDR, ifr, IFREQSZ) < 0)
-            goto error;
-        cifa->ifa_addr = sa_dup((struct sockaddr*)&ifr->lifr_addr);
-
-        if (ioctl(sd, SIOCGLIFNETMASK, ifr, IFREQSZ) < 0)
-            goto error;
-        cifa->ifa_netmask = sa_dup((struct sockaddr*)&ifr->lifr_addr);
-
-        cifa->ifa_flags = 0;
-        cifa->ifa_dstaddr = NULL;
-
-        if (0 == ioctl(sd, SIOCGLIFFLAGS, ifr)) /* optional */
-            cifa->ifa_flags = ifr->lifr_flags;
-
-        if (ioctl(sd, SIOCGLIFDSTADDR, ifr, IFREQSZ) < 0) {
-            if (0 == ioctl(sd, SIOCGLIFBRDADDR, ifr, IFREQSZ))
-                cifa->ifa_dstaddr = sa_dup((struct sockaddr*)&ifr->lifr_addr);
-        }
-        else cifa->ifa_dstaddr = sa_dup((struct sockaddr*)&ifr->lifr_addr);
-
-        pifa = cifa;
-        ccp += IFREQSZ;
-    }
-    free(ifc.lifc_buf);
-    close(sd);
-    return 0;
-error:
-    if (ifc.lifc_buf != NULL)
-        free(ifc.lifc_buf);
-    if (sd != -1)
-        close(sd);
-    return (-1);
-}
diff --git a/psutil/arch/solaris/v10/ifaddrs.h b/psutil/arch/solaris/v10/ifaddrs.h
deleted file mode 100644
index e1d885963a..0000000000
--- a/psutil/arch/solaris/v10/ifaddrs.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/* Reference: https://lists.samba.org/archive/samba-technical/2009-February/063079.html */
-
-
-#ifndef __IFADDRS_H___
-#define __IFADDRS_H___
-
-#include <sys/socket.h>
-#include <net/if.h>
-
-#undef  ifa_dstaddr
-#undef  ifa_broadaddr
-#define ifa_broadaddr ifa_dstaddr
-
-struct ifaddrs {
-    struct ifaddrs  *ifa_next;
-    char            *ifa_name;
-    unsigned int     ifa_flags;
-    struct sockaddr *ifa_addr;
-    struct sockaddr *ifa_netmask;
-    struct sockaddr *ifa_dstaddr;
-};
-
-extern int getifaddrs(struct ifaddrs **);
-extern void freeifaddrs(struct ifaddrs *);
-
-#endif
\ No newline at end of file
diff --git a/psutil/arch/sunos/cpu.c b/psutil/arch/sunos/cpu.c
new file mode 100644
index 0000000000..8c3579c5ad
--- /dev/null
+++ b/psutil/arch/sunos/cpu.c
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+
+#include <sys/sysinfo.h>
+#include <kstat.h>
+
+#include "../../arch/all/init.h"
+
+
+// System-wide CPU times.
+PyObject *
+psutil_per_cpu_times(PyObject *self, PyObject *args) {
+    kstat_ctl_t *kc;
+    kstat_t *ksp;
+    cpu_stat_t cs;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    // Opens /dev/kstat and snapshots the whole kstat chain.
+    Py_BEGIN_ALLOW_THREADS
+    kc = kstat_open();
+    Py_END_ALLOW_THREADS
+    if (kc == NULL) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) {
+        if (strcmp(ksp->ks_module, "cpu_stat") == 0) {
+            if (kstat_read(kc, ksp, &cs) == -1) {
+                psutil_oserror();
+                goto error;
+            }
+            if (!pylist_append_fmt(
+                    py_retlist,
+                    "ffff",
+                    (float)cs.cpu_sysinfo.cpu[CPU_USER],
+                    (float)cs.cpu_sysinfo.cpu[CPU_KERNEL],
+                    (float)cs.cpu_sysinfo.cpu[CPU_IDLE],
+                    (float)cs.cpu_sysinfo.cpu[CPU_WAIT]
+                ))
+            {
+                goto error;
+            }
+        }
+    }
+
+    kstat_close(kc);
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    if (kc != NULL)
+        kstat_close(kc);
+    return NULL;
+}
+
+
+// Return the number of CPU cores on the system.
+PyObject *
+psutil_cpu_count_cores(PyObject *self, PyObject *args) {
+    kstat_ctl_t *kc;
+    kstat_t *ksp;
+    int ncpus = 0;
+
+    // Opens /dev/kstat and snapshots the whole kstat chain.
+    Py_BEGIN_ALLOW_THREADS
+    kc = kstat_open();
+    Py_END_ALLOW_THREADS
+    if (kc == NULL)
+        goto error;
+    ksp = kstat_lookup(kc, "cpu_info", -1, NULL);
+    if (ksp == NULL)
+        goto error;
+
+    for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
+        if (strcmp(ksp->ks_module, "cpu_info") != 0)
+            continue;
+        if (kstat_read(kc, ksp, NULL) == -1)
+            goto error;
+        ncpus += 1;
+    }
+
+    kstat_close(kc);
+    if (ncpus > 0)
+        return Py_BuildValue("i", ncpus);
+    else
+        goto error;
+
+error:
+    // mimic os.cpu_count()
+    if (kc != NULL)
+        kstat_close(kc);
+    Py_RETURN_NONE;
+}
+
+
+// Return CPU statistics.
+PyObject *
+psutil_cpu_stats(PyObject *self, PyObject *args) {
+    kstat_ctl_t *kc;
+    kstat_t *ksp;
+    cpu_stat_t cs;
+    unsigned int ctx_switches = 0;
+    unsigned int interrupts = 0;
+    unsigned int traps = 0;
+    unsigned int syscalls = 0;
+
+    // Opens /dev/kstat and snapshots the whole kstat chain.
+    Py_BEGIN_ALLOW_THREADS
+    kc = kstat_open();
+    Py_END_ALLOW_THREADS
+    if (kc == NULL) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (ksp = kc->kc_chain; ksp != NULL; ksp = ksp->ks_next) {
+        if (strcmp(ksp->ks_module, "cpu_stat") == 0) {
+            if (kstat_read(kc, ksp, &cs) == -1) {
+                psutil_oserror();
+                goto error;
+            }
+            // voluntary + involuntary
+            ctx_switches += cs.cpu_sysinfo.pswitch + cs.cpu_sysinfo.inv_swtch;
+            interrupts += cs.cpu_sysinfo.intr;
+            traps += cs.cpu_sysinfo.trap;
+            syscalls += cs.cpu_sysinfo.syscall;
+        }
+    }
+
+    kstat_close(kc);
+    return Py_BuildValue("IIII", ctx_switches, interrupts, syscalls, traps);
+
+error:
+    if (kc != NULL)
+        kstat_close(kc);
+    return NULL;
+}
diff --git a/psutil/arch/sunos/disk.c b/psutil/arch/sunos/disk.c
new file mode 100644
index 0000000000..0025fce434
--- /dev/null
+++ b/psutil/arch/sunos/disk.c
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+
+#include <sys/mntent.h>
+#include <sys/mnttab.h>
+#include <kstat.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_disk_io_counters(PyObject *self, PyObject *args) {
+    kstat_ctl_t *kc;
+    kstat_t *ksp;
+    kstat_io_t kio;
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_disk_info = NULL;
+
+    if (py_retdict == NULL)
+        return NULL;
+    // Opens /dev/kstat and snapshots the whole kstat chain.
+    Py_BEGIN_ALLOW_THREADS
+    kc = kstat_open();
+    Py_END_ALLOW_THREADS
+    if (kc == NULL) {
+        psutil_oserror();
+        goto error;
+    }
+    ksp = kc->kc_chain;
+    while (ksp != NULL) {
+        if (ksp->ks_type == KSTAT_TYPE_IO) {
+            if (strcmp(ksp->ks_class, "disk") == 0) {
+                if (kstat_read(kc, ksp, &kio) == -1) {
+                    psutil_oserror();
+                    goto error;
+                }
+                py_disk_info = Py_BuildValue(
+                    "(IIKKLL)",
+                    kio.reads,
+                    kio.writes,
+                    kio.nread,
+                    kio.nwritten,
+                    kio.rtime / 1000 / 1000,  // from nano to milli secs
+                    kio.wtime / 1000 / 1000  // from nano to milli secs
+                );
+                if (!py_disk_info)
+                    goto error;
+                if (PyDict_SetItemString(
+                        py_retdict, ksp->ks_name, py_disk_info
+                    ))
+                    goto error;
+                Py_CLEAR(py_disk_info);
+            }
+        }
+        ksp = ksp->ks_next;
+    }
+    kstat_close(kc);
+
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_disk_info);
+    Py_DECREF(py_retdict);
+    if (kc != NULL)
+        kstat_close(kc);
+    return NULL;
+}
+
+
+PyObject *
+psutil_disk_partitions(PyObject *self, PyObject *args) {
+    FILE *file;
+    struct mnttab mt;
+    PyObject *py_dev = NULL;
+    PyObject *py_mountp = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    Py_BEGIN_ALLOW_THREADS
+    file = fopen(MNTTAB, "rb");
+    Py_END_ALLOW_THREADS
+    if (file == NULL) {
+        psutil_oserror();
+        goto error;
+    }
+
+    // NOTE: getmntent() fills a buffer owned by libc, so we can't
+    // release the GIL around it.
+    while (getmntent(file, &mt) == 0) {
+        py_dev = PyUnicode_DecodeFSDefault(mt.mnt_special);
+        if (!py_dev)
+            goto error;
+        py_mountp = PyUnicode_DecodeFSDefault(mt.mnt_mountp);
+        if (!py_mountp)
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(OOss)",
+                py_dev,  // device
+                py_mountp,  // mount point
+                mt.mnt_fstype,  // fs type
+                mt.mnt_mntopts  // options
+            ))
+        {
+            goto error;
+        }
+        Py_CLEAR(py_dev);
+        Py_CLEAR(py_mountp);
+    }
+    fclose(file);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_dev);
+    Py_XDECREF(py_mountp);
+    Py_DECREF(py_retlist);
+    if (file != NULL)
+        fclose(file);
+    return NULL;
+}
diff --git a/psutil/arch/sunos/environ.c b/psutil/arch/sunos/environ.c
new file mode 100644
index 0000000000..ecd970cb59
--- /dev/null
+++ b/psutil/arch/sunos/environ.c
@@ -0,0 +1,359 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola', Oleksii Shevchuk.
+ * All rights reserved. Use of this source code is governed by a BSD-style
+ * license that can be found in the LICENSE file.
+ */
+
+#define _STRUCTURED_PROC 1
+
+#include <Python.h>
+
+#include <sys/types.h>
+#include <sys/procfs.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "../../arch/all/init.h"
+
+
+#define STRING_SEARCH_BUF_SIZE 512
+
+
+// Open address space of specified process and return file descriptor.
+static int
+open_address_space(pid_t pid, const char *procfs_path) {
+    int fd;
+    char proc_path[PATH_MAX];
+
+    str_format(proc_path, PATH_MAX, "%s/%i/as", procfs_path, pid);
+    // Reading another process's address space may need to page it
+    // back in from swap.
+    Py_BEGIN_ALLOW_THREADS
+    fd = open(proc_path, O_RDONLY);
+    Py_END_ALLOW_THREADS
+    if (fd < 0)
+        psutil_oserror();
+
+    return fd;
+}
+
+
+// Read chunk of data by offset to specified buffer of the same size.
+// Return the amount of bytes stored to the buffer or -1 on error.
+static size_t
+read_offt(int fd, off_t offset, char *buf, size_t buf_size) {
+    size_t to_read = buf_size;
+    size_t stored = 0;
+    int r;
+
+    while (to_read) {
+        Py_BEGIN_ALLOW_THREADS
+        r = pread(fd, buf + stored, to_read, offset + stored);
+        Py_END_ALLOW_THREADS
+        if (r < 0)
+            goto error;
+        else if (r == 0)
+            break;
+
+        to_read -= r;
+        stored += r;
+    }
+
+    return stored;
+
+error:
+    psutil_oserror();
+    return -1;
+}
+
+
+// Read null-terminated string from file descriptor starting from
+// specified offset. Return allocated null-terminated string or NULL in
+// case of error.
+static char *
+read_cstring_offt(int fd, off_t offset) {
+    int r;
+    int i = 0;
+    off_t end = offset;
+    off_t off;
+    size_t len;
+    char buf[STRING_SEARCH_BUF_SIZE];
+    char *result = NULL;
+
+    Py_BEGIN_ALLOW_THREADS
+    off = lseek(fd, offset, SEEK_SET);
+    Py_END_ALLOW_THREADS
+    if (off == (off_t)-1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    // Search end of string
+    for (;;) {
+        Py_BEGIN_ALLOW_THREADS
+        r = read(fd, buf, sizeof(buf));
+        Py_END_ALLOW_THREADS
+        if (r == -1) {
+            psutil_oserror();
+            goto error;
+        }
+        else if (r == 0) {
+            break;
+        }
+        else {
+            for (i = 0; i < r; i++)
+                if (!buf[i])
+                    goto found;
+        }
+
+        end += r;
+    }
+
+found:
+    len = end + i - offset;
+
+    result = malloc(len + 1);
+    if (!result) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    if (len) {
+        if (read_offt(fd, offset, result, len) < 0) {
+            goto error;
+        }
+    }
+
+    result[len] = '\0';
+    return result;
+
+error:
+    if (result)
+        free(result);
+    return NULL;
+}
+
+
+// Read block of addresses by offset, dereference them one by one and
+// create an array of null terminated C strings from them. Return
+// allocated array of strings dereferenced and read by offset. Number
+// of elements in array are count. In case of error function returns
+// NULL.
+static char **
+read_cstrings_block(int fd, off_t offset, size_t ptr_size, size_t count) {
+    char **result = NULL;
+    char *pblock = NULL;
+    size_t pblock_size;
+    size_t i;
+
+    assert(ptr_size == 4 || ptr_size == 8);
+
+    if (!count)
+        goto error;
+
+    pblock_size = ptr_size * count;
+
+    pblock = malloc(pblock_size);
+    if (!pblock) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    if (read_offt(fd, offset, pblock, pblock_size) != pblock_size)
+        goto error;
+
+    result = (char **)calloc(count, sizeof(char *));
+    if (!result) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    for (i = 0; i < count; i++) {
+        result[i] = read_cstring_offt(
+            fd,
+            (ptr_size == 4 ? ((uint32_t *)pblock)[i] : ((uint64_t *)pblock)[i])
+        );
+
+        if (!result[i])
+            goto error;
+    }
+
+    free(pblock);
+    return result;
+
+error:
+    if (result)
+        psutil_free_cstrings_array(result, i);
+    if (pblock)
+        free(pblock);
+    return NULL;
+}
+
+
+// Check that caller process can extract proper values from psinfo_t
+// structure. Return 1 in case if caller process can extract proper
+// values from psinfo_t structure, 0 otherwise.
+static inline int
+is_ptr_dereference_possible(psinfo_t info) {
+#if !defined(_LP64)
+    return info.pr_dmodel == PR_MODEL_ILP32;
+#else
+    return 1;
+#endif
+}
+
+
+// Return pointer size according to psinfo_t structure. Return the
+// pointer size (4 or 8).
+static inline int
+ptr_size_by_psinfo(psinfo_t info) {
+    return info.pr_dmodel == PR_MODEL_ILP32 ? 4 : 8;
+}
+
+
+// Count amount of pointers in a block which ends with NULL. Return the
+// amount of non-NULL pointers or -1 on error.
+static int
+search_pointers_vector_size_offt(int fd, off_t offt, size_t ptr_size) {
+    int count = 0;
+    size_t r;
+    char buf[8];
+    static const char zeros[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+
+    assert(ptr_size == 4 || ptr_size == 8);
+
+    if (lseek(fd, offt, SEEK_SET) == (off_t)-1)
+        goto error;
+
+    for (;; count++) {
+        r = read(fd, buf, ptr_size);
+
+        if (r < 0)
+            goto error;
+
+        if (r == 0)
+            break;
+
+        if (r != ptr_size) {
+            psutil_runtime_error("pointer block is truncated");
+            return -1;
+        }
+
+        if (!memcmp(buf, zeros, ptr_size))
+            break;
+    }
+
+    return count;
+
+error:
+    psutil_oserror();
+    return -1;
+}
+
+
+// Dereference and read array of strings by psinfo_t.pr_argv pointer
+// from remote process. Return allocated array of cstrings or NULL on
+// error.
+char **
+psutil_read_raw_args(psinfo_t info, const char *procfs_path, size_t *count) {
+    int as;
+    char **result;
+
+    if (!is_ptr_dereference_possible(info)) {
+        PyErr_SetString(
+            PyExc_NotImplementedError,
+            "can't get env of a 64 bit process from a 32 bit process"
+        );
+        return NULL;
+    }
+
+    if (!(info.pr_argv && info.pr_argc)) {
+        psutil_runtime_error("process doesn't have arguments block");
+
+        return NULL;
+    }
+
+    as = open_address_space(info.pr_pid, procfs_path);
+    if (as < 0)
+        return NULL;
+
+    result = read_cstrings_block(
+        as, info.pr_argv, ptr_size_by_psinfo(info), info.pr_argc
+    );
+
+    if (result && count)
+        *count = info.pr_argc;
+
+    close(as);
+
+    return result;
+}
+
+
+// Dereference and read array of strings by psinfo_t.pr_envp pointer
+// from remote process.
+//
+// @param info: a pointer to process info (psinfo_t) structure of the
+// interesting process.
+// @param procfs_path: a cstring with path to mounted procfs filesystem.
+// @param count: a pointer to variable where to store amount of elements in
+// returned array. In case of error value of variable will not be
+// changed. To detect special case (described later) variable should be
+// initialized by -1 or other negative value.
+//
+// Return allocated array of cstrings or NULL in case of error.
+// Special case: count set to 0, return NULL.
+// Special case means there is no error acquired, but no data
+// retrieved.
+// Special case exists because the nature of the process. From the
+// beginning it's not clear how many pointers in envp array. Also
+// situation when environment is empty is common for kernel processes.
+char **
+psutil_read_raw_env(psinfo_t info, const char *procfs_path, ssize_t *count) {
+    int as;
+    int env_count;
+    int ptr_size;
+    char **result = NULL;
+
+    if (!is_ptr_dereference_possible(info)) {
+        PyErr_SetString(
+            PyExc_NotImplementedError,
+            "can't get env of a 64 bit process from a 32 bit process"
+        );
+        return NULL;
+    }
+
+    as = open_address_space(info.pr_pid, procfs_path);
+    if (as < 0)
+        return NULL;
+
+    ptr_size = ptr_size_by_psinfo(info);
+
+    env_count = search_pointers_vector_size_offt(as, info.pr_envp, ptr_size);
+
+    if (env_count >= 0 && count)
+        *count = env_count;
+
+    if (env_count > 0)
+        result = read_cstrings_block(as, info.pr_envp, ptr_size, env_count);
+
+    close(as);
+    return result;
+}
+
+
+// Free array of cstrings.
+void
+psutil_free_cstrings_array(char **array, size_t count) {
+    size_t i;
+
+    if (!array)
+        return;
+    for (i = 0; i < count; i++) {
+        if (array[i]) {
+            free(array[i]);
+        }
+    }
+    free(array);
+}
diff --git a/psutil/arch/sunos/init.h b/psutil/arch/sunos/init.h
new file mode 100644
index 0000000000..67f80fe67a
--- /dev/null
+++ b/psutil/arch/sunos/init.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <libproc.h>
+
+#ifndef PROCESS_AS_UTILS_H
+#define PROCESS_AS_UTILS_H
+
+char **psutil_read_raw_args(
+    psinfo_t info, const char *procfs_path, size_t *count
+);
+
+char **psutil_read_raw_env(
+    psinfo_t info, const char *procfs_path, ssize_t *count
+);
+
+void psutil_free_cstrings_array(char **array, size_t count);
+#endif  // PROCESS_AS_UTILS_H
+
+PyObject *psutil_boot_time(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_count_cores(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_stats(PyObject *self, PyObject *args);
+PyObject *psutil_disk_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_disk_partitions(PyObject *self, PyObject *args);
+PyObject *psutil_net_connections(PyObject *self, PyObject *args);
+PyObject *psutil_net_if_stats(PyObject *self, PyObject *args);
+PyObject *psutil_net_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_per_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cpu_num(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cred(PyObject *self, PyObject *args);
+PyObject *psutil_proc_environ(PyObject *self, PyObject *args);
+PyObject *psutil_proc_memory_maps(PyObject *self, PyObject *args);
+PyObject *psutil_proc_name_and_args(PyObject *self, PyObject *args);
+PyObject *psutil_proc_num_ctx_switches(PyObject *self, PyObject *args);
+PyObject *psutil_proc_oneshot(PyObject *self, PyObject *args);
+PyObject *psutil_proc_page_faults(PyObject *self, PyObject *args);
+PyObject *psutil_proc_query_thread(PyObject *self, PyObject *args);
+PyObject *psutil_swap_mem(PyObject *self, PyObject *args);
diff --git a/psutil/arch/sunos/mem.c b/psutil/arch/sunos/mem.c
new file mode 100644
index 0000000000..984974d1e2
--- /dev/null
+++ b/psutil/arch/sunos/mem.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+
+#include <kstat.h>
+#include <sys/sysinfo.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_swap_mem(PyObject *self, PyObject *args) {
+    // XXX (arghhh!)
+    // total/free swap mem: commented out as for some reason I can't
+    // manage to get the same results shown by "swap -l", despite the
+    // code below is exactly the same as:
+    // http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/usr/src/
+    //    cmd/swap/swap.c
+    // We're going to parse "swap -l" output from Python (sigh!)
+
+    /*
+        struct swaptable     *st;
+        struct swapent    *swapent;
+        int    i;
+        struct stat64 statbuf;
+        char *path;
+        char fullpath[MAXPATHLEN+1];
+        int    num;
+
+        if ((num = swapctl(SC_GETNSWP, NULL)) == -1) {
+            psutil_oserror();
+            return NULL;
+        }
+        if (num == 0) {
+            psutil_runtime_error("no swap devices configured");
+            return NULL;
+        }
+        if ((st = malloc(num * sizeof(swapent_t) + sizeof (int))) == NULL) {
+            psutil_runtime_error("malloc failed");
+            return NULL;
+        }
+        if ((path = malloc(num * MAXPATHLEN)) == NULL) {
+            psutil_runtime_error("malloc failed");
+            return NULL;
+        }
+        swapent = st->swt_ent;
+        for (i = 0; i < num; i++, swapent++) {
+            swapent->ste_path = path;
+            path += MAXPATHLEN;
+        }
+        st->swt_n = num;
+        if ((num = swapctl(SC_LIST, st)) == -1) {
+            psutil_oserror();
+            return NULL;
+        }
+
+        swapent = st->swt_ent;
+        long t = 0, f = 0;
+        for (i = 0; i < num; i++, swapent++) {
+            int diskblks_per_page =(int)(sysconf(_SC_PAGESIZE) >> DEV_BSHIFT);
+            t += (long)swapent->ste_pages;
+            f += (long)swapent->ste_free;
+        }
+
+        free(st);
+        return Py_BuildValue("(kk)", t, f);
+    */
+
+    kstat_ctl_t *kc;
+    kstat_t *k;
+    cpu_stat_t *cpu;
+    int cpu_count = 0;
+    int flag = 0;
+    uint_t sin = 0;
+    uint_t sout = 0;
+
+    // Opens /dev/kstat and snapshots the whole kstat chain.
+    Py_BEGIN_ALLOW_THREADS
+    kc = kstat_open();
+    Py_END_ALLOW_THREADS
+    if (kc == NULL)
+        return psutil_oserror();
+    ;
+
+    k = kc->kc_chain;
+    while (k != NULL) {
+        if ((strncmp(k->ks_name, "cpu_stat", 8) == 0)
+            && (kstat_read(kc, k, NULL) != -1))
+        {
+            flag = 1;
+            cpu = (cpu_stat_t *)k->ks_data;
+            sin += cpu->cpu_vminfo.pgswapin;  // num pages swapped in
+            sout += cpu->cpu_vminfo.pgswapout;  // num pages swapped out
+        }
+        cpu_count += 1;
+        k = k->ks_next;
+    }
+    kstat_close(kc);
+    if (!flag) {
+        psutil_runtime_error("no swap device was found");
+        return NULL;
+    }
+    return Py_BuildValue("(II)", sin, sout);
+}
diff --git a/psutil/arch/sunos/net.c b/psutil/arch/sunos/net.c
new file mode 100644
index 0000000000..f3aa08dca3
--- /dev/null
+++ b/psutil/arch/sunos/net.c
@@ -0,0 +1,587 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <inet/mib2.h>
+#include <kstat.h>
+#include <netinet/in.h>
+#include <stdio.h>
+#include <stropts.h>
+#include <sys/fcntl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/sockio.h>
+#include <netinet/in.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/stropts.h>
+#include <sys/tihdr.h>
+#include <net/if.h>
+#include <fcntl.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_net_io_counters(PyObject *self, PyObject *args) {
+    kstat_ctl_t *kc = NULL;
+    kstat_t *ksp;
+    kstat_named_t *rbytes, *wbytes, *rpkts, *wpkts, *ierrs, *oerrs;
+    int ret;
+    int sock = -1;
+    struct lifreq ifr;
+
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_ifc_info = NULL;
+
+    if (py_retdict == NULL)
+        return NULL;
+    // Opens /dev/kstat and snapshots the whole kstat chain.
+    Py_BEGIN_ALLOW_THREADS
+    kc = kstat_open();
+    Py_END_ALLOW_THREADS
+    if (kc == NULL)
+        goto error;
+
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    ksp = kc->kc_chain;
+    while (ksp != NULL) {
+        if (ksp->ks_type != KSTAT_TYPE_NAMED)
+            goto next;
+        if (strcmp(ksp->ks_class, "net") != 0)
+            goto next;
+        // skip 'lo' (localhost) because it doesn't have the statistics we need
+        // and it makes kstat_data_lookup() fail
+        if (strcmp(ksp->ks_module, "lo") == 0)
+            goto next;
+
+        // check if this is a network interface by sending a ioctl
+        str_copy(ifr.lifr_name, sizeof(ifr.lifr_name), ksp->ks_name);
+        Py_BEGIN_ALLOW_THREADS
+        ret = ioctl(sock, SIOCGLIFFLAGS, &ifr);
+        Py_END_ALLOW_THREADS
+        if (ret == -1)
+            goto next;
+
+        if (kstat_read(kc, ksp, NULL) == -1) {
+            errno = 0;
+            goto next;
+        }
+
+        rbytes = (kstat_named_t *)kstat_data_lookup(ksp, "rbytes");
+        wbytes = (kstat_named_t *)kstat_data_lookup(ksp, "obytes");
+        rpkts = (kstat_named_t *)kstat_data_lookup(ksp, "ipackets");
+        wpkts = (kstat_named_t *)kstat_data_lookup(ksp, "opackets");
+        ierrs = (kstat_named_t *)kstat_data_lookup(ksp, "ierrors");
+        oerrs = (kstat_named_t *)kstat_data_lookup(ksp, "oerrors");
+
+        if ((rbytes == NULL) || (wbytes == NULL) || (rpkts == NULL)
+            || (wpkts == NULL) || (ierrs == NULL) || (oerrs == NULL))
+        {
+            psutil_runtime_error("kstat_data_lookup() failed");
+            goto error;
+        }
+
+        if (rbytes->data_type == KSTAT_DATA_UINT64) {
+            py_ifc_info = Py_BuildValue(
+                "(KKKKIIii)",
+                wbytes->value.ui64,
+                rbytes->value.ui64,
+                wpkts->value.ui64,
+                rpkts->value.ui64,
+                ierrs->value.ui32,
+                oerrs->value.ui32,
+                0,  // dropin not supported
+                0  // dropout not supported
+            );
+        }
+        else {
+            py_ifc_info = Py_BuildValue(
+                "(IIIIIIii)",
+                wbytes->value.ui32,
+                rbytes->value.ui32,
+                wpkts->value.ui32,
+                rpkts->value.ui32,
+                ierrs->value.ui32,
+                oerrs->value.ui32,
+                0,  // dropin not supported
+                0  // dropout not supported
+            );
+        }
+        if (!py_ifc_info)
+            goto error;
+        if (PyDict_SetItemString(py_retdict, ksp->ks_name, py_ifc_info))
+            goto error;
+        Py_CLEAR(py_ifc_info);
+        goto next;
+
+    next:
+        ksp = ksp->ks_next;
+    }
+
+    kstat_close(kc);
+    close(sock);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_ifc_info);
+    Py_DECREF(py_retdict);
+    if (kc != NULL)
+        kstat_close(kc);
+    if (sock != -1) {
+        close(sock);
+    }
+    return NULL;
+}
+
+
+// Return stats about a particular network interface. Refs:
+// * https://github.com/dpaleino/wicd/blob/master/wicd/backends/be-ioctl.py
+// * http://www.i-scream.org/libstatgrab/
+PyObject *
+psutil_net_if_stats(PyObject *self, PyObject *args) {
+    kstat_ctl_t *kc = NULL;
+    kstat_t *ksp;
+    kstat_named_t *knp;
+    int ret;
+    int sock = -1;
+    int duplex;
+    int speed;
+
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_ifc_info = NULL;
+    PyObject *py_is_up = NULL;
+
+    if (py_retdict == NULL)
+        return NULL;
+    // Opens /dev/kstat and snapshots the whole kstat chain.
+    Py_BEGIN_ALLOW_THREADS
+    kc = kstat_open();
+    Py_END_ALLOW_THREADS
+    if (kc == NULL)
+        goto error;
+    sock = socket(AF_INET, SOCK_DGRAM, 0);
+    if (sock == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    for (ksp = kc->kc_chain; ksp; ksp = ksp->ks_next) {
+        if (strcmp(ksp->ks_class, "net") == 0) {
+            struct lifreq ifr;
+
+            kstat_read(kc, ksp, NULL);
+            if (ksp->ks_type != KSTAT_TYPE_NAMED)
+                continue;
+            if (strcmp(ksp->ks_class, "net") != 0)
+                continue;
+
+            str_copy(ifr.lifr_name, sizeof(ifr.lifr_name), ksp->ks_name);
+            Py_BEGIN_ALLOW_THREADS
+            ret = ioctl(sock, SIOCGLIFFLAGS, &ifr);
+            Py_END_ALLOW_THREADS
+            if (ret == -1)
+                continue;  // not a network interface
+
+            // is up?
+            if ((ifr.lifr_flags & IFF_UP) != 0) {
+                if ((knp = kstat_data_lookup(ksp, "link_up")) != NULL) {
+                    if (knp->value.ui32 != 0u)
+                        py_is_up = Py_True;
+                    else
+                        py_is_up = Py_False;
+                }
+                else {
+                    py_is_up = Py_True;
+                }
+            }
+            else {
+                py_is_up = Py_False;
+            }
+            Py_INCREF(py_is_up);
+
+            // duplex
+            duplex = 0;  // unknown
+            if ((knp = kstat_data_lookup(ksp, "link_duplex")) != NULL) {
+                if (knp->value.ui32 == 1)
+                    duplex = 1;  // half
+                else if (knp->value.ui32 == 2)
+                    duplex = 2;  // full
+            }
+
+            // speed
+            if ((knp = kstat_data_lookup(ksp, "ifspeed")) != NULL)
+                // expressed in bits per sec, we want mega bits per sec
+                speed = (int)knp->value.ui64 / 1000000;
+            else
+                speed = 0;
+
+            // mtu
+            Py_BEGIN_ALLOW_THREADS
+            ret = ioctl(sock, SIOCGLIFMTU, &ifr);
+            Py_END_ALLOW_THREADS
+            if (ret == -1)
+                goto error;
+
+            py_ifc_info = Py_BuildValue(
+                "(Oiii)", py_is_up, duplex, speed, ifr.lifr_mtu
+            );
+            if (!py_ifc_info)
+                goto error;
+            if (PyDict_SetItemString(py_retdict, ksp->ks_name, py_ifc_info))
+                goto error;
+            Py_CLEAR(py_ifc_info);
+        }
+    }
+
+    close(sock);
+    kstat_close(kc);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_is_up);
+    Py_XDECREF(py_ifc_info);
+    Py_DECREF(py_retdict);
+    if (sock != -1)
+        close(sock);
+    if (kc != NULL)
+        kstat_close(kc);
+    psutil_oserror();
+    return NULL;
+}
+
+
+// Return TCP and UDP connections opened by process. UNIX sockets are excluded.
+// Thanks to:
+// https://github.com/DavidGriffith/finx/blob/master/nxsensor-3.5.0-1/src/sysdeps/solaris.c
+// https://hg.java.net/hg/solaris~on-src/file/tip/usr/src/cmd/cmd-inet/usr.bin/netstat/netstat.c
+PyObject *
+psutil_net_connections(PyObject *self, PyObject *args) {
+    long pid;
+    int sd = 0;
+    mib2_tcpConnEntry_t tp;
+    mib2_udpEntry_t ude;
+#if defined(AF_INET6)
+    mib2_tcp6ConnEntry_t tp6;
+    mib2_udp6Entry_t ude6;
+#endif
+    char buf[512];
+    int i, flags, getcode, num_ent, state, ret;
+    char lip[INET6_ADDRSTRLEN], rip[INET6_ADDRSTRLEN];
+    int lport, rport;
+    int processed_pid;
+    int databuf_init = 0;
+    struct strbuf ctlbuf, databuf;
+    struct T_optmgmt_req tor = {0};
+    struct T_optmgmt_ack toa = {0};
+    struct T_error_ack tea = {0};
+    struct opthdr mibhdr = {0};
+
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_laddr = NULL;
+    PyObject *py_raddr = NULL;
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, "l", &pid))
+        goto error;
+
+    Py_BEGIN_ALLOW_THREADS
+    sd = open("/dev/arp", O_RDWR);
+    Py_END_ALLOW_THREADS
+    if (sd == -1) {
+        PyErr_SetFromErrnoWithFilename(PyExc_OSError, "/dev/arp");
+        goto error;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    ret = ioctl(sd, I_PUSH, "tcp");
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    ret = ioctl(sd, I_PUSH, "udp");
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_oserror();
+        goto error;
+    }
+    //
+    // OK, this mess is basically copied and pasted from nxsensor project
+    // which copied and pasted it from netstat source code, mibget()
+    // function.  Also see:
+    // http://stackoverflow.com/questions/8723598/
+    tor.PRIM_type = T_SVR4_OPTMGMT_REQ;
+    tor.OPT_offset = sizeof(struct T_optmgmt_req);
+    tor.OPT_length = sizeof(struct opthdr);
+    tor.MGMT_flags = T_CURRENT;
+    mibhdr.level = MIB2_IP;
+    mibhdr.name = 0;
+
+    mibhdr.len = 1;
+    memcpy(buf, &tor, sizeof tor);
+    memcpy(buf + tor.OPT_offset, &mibhdr, sizeof mibhdr);
+
+    ctlbuf.buf = buf;
+    ctlbuf.len = tor.OPT_offset + tor.OPT_length;
+    flags = 0;  // request to be sent in non-priority
+
+    Py_BEGIN_ALLOW_THREADS
+    ret = putmsg(sd, &ctlbuf, (struct strbuf *)0, flags);
+    Py_END_ALLOW_THREADS
+    if (ret == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    ctlbuf.maxlen = sizeof(buf);
+    for (;;) {
+        flags = 0;
+        Py_BEGIN_ALLOW_THREADS
+        getcode = getmsg(sd, &ctlbuf, (struct strbuf *)0, &flags);
+        Py_END_ALLOW_THREADS
+        memcpy(&toa, buf, sizeof toa);
+        memcpy(&tea, buf, sizeof tea);
+
+        if (getcode != MOREDATA
+            || ctlbuf.len < (int)sizeof(struct T_optmgmt_ack)
+            || toa.PRIM_type != T_OPTMGMT_ACK || toa.MGMT_flags != T_SUCCESS)
+        {
+            break;
+        }
+        if (ctlbuf.len >= (int)sizeof(struct T_error_ack)
+            && tea.PRIM_type == T_ERROR_ACK)
+        {
+            psutil_runtime_error("ERROR_ACK");
+            goto error;
+        }
+        if (getcode == 0 && ctlbuf.len >= (int)sizeof(struct T_optmgmt_ack)
+            && toa.PRIM_type == T_OPTMGMT_ACK && toa.MGMT_flags == T_SUCCESS)
+        {
+            psutil_runtime_error("ERROR_T_OPTMGMT_ACK");
+            goto error;
+        }
+
+        memset(&mibhdr, 0x0, sizeof(mibhdr));
+        memcpy(&mibhdr, buf + toa.OPT_offset, toa.OPT_length);
+
+        databuf.maxlen = mibhdr.len;
+        databuf.len = 0;
+        databuf.buf = (char *)malloc((int)mibhdr.len);
+        if (!databuf.buf) {
+            PyErr_NoMemory();
+            goto error;
+        }
+        databuf_init = 1;
+
+        flags = 0;
+        Py_BEGIN_ALLOW_THREADS
+        getcode = getmsg(sd, (struct strbuf *)0, &databuf, &flags);
+        Py_END_ALLOW_THREADS
+        if (getcode < 0) {
+            psutil_oserror();
+            goto error;
+        }
+
+        // TCPv4
+        if (mibhdr.level == MIB2_TCP && mibhdr.name == MIB2_TCP_13) {
+            num_ent = mibhdr.len / sizeof(mib2_tcpConnEntry_t);
+            for (i = 0; i < num_ent; i++) {
+                memcpy(&tp, databuf.buf + i * sizeof tp, sizeof tp);
+                processed_pid = tp.tcpConnCreationProcess;
+                if (pid != -1 && processed_pid != pid)
+                    continue;
+                // construct local/remote addresses
+                inet_ntop(AF_INET, &tp.tcpConnLocalAddress, lip, sizeof(lip));
+                inet_ntop(AF_INET, &tp.tcpConnRemAddress, rip, sizeof(rip));
+                lport = tp.tcpConnLocalPort;
+                rport = tp.tcpConnRemPort;
+
+                // construct python tuple/list
+                py_laddr = Py_BuildValue("(si)", lip, lport);
+                if (!py_laddr)
+                    goto error;
+                if (rport != 0)
+                    py_raddr = Py_BuildValue("(si)", rip, rport);
+                else {
+                    py_raddr = Py_BuildValue("()");
+                }
+                if (!py_raddr)
+                    goto error;
+                state = tp.tcpConnEntryInfo.ce_state;
+
+                // add item
+                if (!pylist_append_fmt(
+                        py_retlist,
+                        "(iiiNNiI)",
+                        -1,
+                        AF_INET,
+                        SOCK_STREAM,
+                        py_laddr,
+                        py_raddr,
+                        state,
+                        processed_pid
+                    ))
+                {
+                    goto error;
+                }
+                py_laddr = NULL;
+                py_raddr = NULL;
+            }
+        }
+#if defined(AF_INET6)
+        // TCPv6
+        else if (mibhdr.level == MIB2_TCP6 && mibhdr.name == MIB2_TCP6_CONN) {
+            num_ent = mibhdr.len / sizeof(mib2_tcp6ConnEntry_t);
+
+            for (i = 0; i < num_ent; i++) {
+                memcpy(&tp6, databuf.buf + i * sizeof tp6, sizeof tp6);
+                processed_pid = tp6.tcp6ConnCreationProcess;
+                if (pid != -1 && processed_pid != pid)
+                    continue;
+                // construct local/remote addresses
+                inet_ntop(
+                    AF_INET6, &tp6.tcp6ConnLocalAddress, lip, sizeof(lip)
+                );
+                inet_ntop(AF_INET6, &tp6.tcp6ConnRemAddress, rip, sizeof(rip));
+                lport = tp6.tcp6ConnLocalPort;
+                rport = tp6.tcp6ConnRemPort;
+
+                // construct python tuple/list
+                py_laddr = Py_BuildValue("(si)", lip, lport);
+                if (!py_laddr)
+                    goto error;
+                if (rport != 0)
+                    py_raddr = Py_BuildValue("(si)", rip, rport);
+                else
+                    py_raddr = Py_BuildValue("()");
+                if (!py_raddr)
+                    goto error;
+                state = tp6.tcp6ConnEntryInfo.ce_state;
+
+                // add item
+                if (!pylist_append_fmt(
+                        py_retlist,
+                        "(iiiNNiI)",
+                        -1,
+                        AF_INET6,
+                        SOCK_STREAM,
+                        py_laddr,
+                        py_raddr,
+                        state,
+                        processed_pid
+                    ))
+                {
+                    goto error;
+                }
+                py_laddr = NULL;
+                py_raddr = NULL;
+            }
+        }
+#endif
+        // UDPv4
+        else if (mibhdr.level == MIB2_UDP && mibhdr.name == MIB2_UDP_ENTRY) {
+            num_ent = mibhdr.len / sizeof(mib2_udpEntry_t);
+            assert(num_ent * sizeof(mib2_udpEntry_t) == mibhdr.len);
+            for (i = 0; i < num_ent; i++) {
+                memcpy(&ude, databuf.buf + i * sizeof ude, sizeof ude);
+                processed_pid = ude.udpCreationProcess;
+                if (pid != -1 && processed_pid != pid)
+                    continue;
+                // XXX Very ugly hack! It seems we get here only the first
+                // time we bump into a UDPv4 socket.  PID is a very high
+                // number (clearly impossible) and the address does not
+                // belong to any valid interface.  Not sure what else
+                // to do other than skipping.
+                if (processed_pid > 131072)
+                    continue;
+                inet_ntop(AF_INET, &ude.udpLocalAddress, lip, sizeof(lip));
+                lport = ude.udpLocalPort;
+                py_laddr = Py_BuildValue("(si)", lip, lport);
+                if (!py_laddr)
+                    goto error;
+                py_raddr = Py_BuildValue("()");
+                if (!py_raddr)
+                    goto error;
+                if (!pylist_append_fmt(
+                        py_retlist,
+                        "(iiiNNiI)",
+                        -1,
+                        AF_INET,
+                        SOCK_DGRAM,
+                        py_laddr,
+                        py_raddr,
+                        PSUTIL_CONN_NONE,
+                        processed_pid
+                    ))
+                {
+                    goto error;
+                }
+                py_laddr = NULL;
+                py_raddr = NULL;
+            }
+        }
+#if defined(AF_INET6)
+        // UDPv6
+        else if (mibhdr.level == MIB2_UDP6 || mibhdr.level == MIB2_UDP6_ENTRY)
+        {
+            num_ent = mibhdr.len / sizeof(mib2_udp6Entry_t);
+            for (i = 0; i < num_ent; i++) {
+                memcpy(&ude6, databuf.buf + i * sizeof ude6, sizeof ude6);
+                processed_pid = ude6.udp6CreationProcess;
+                if (pid != -1 && processed_pid != pid)
+                    continue;
+                inet_ntop(AF_INET6, &ude6.udp6LocalAddress, lip, sizeof(lip));
+                lport = ude6.udp6LocalPort;
+                py_laddr = Py_BuildValue("(si)", lip, lport);
+                if (!py_laddr)
+                    goto error;
+                py_raddr = Py_BuildValue("()");
+                if (!py_raddr)
+                    goto error;
+                if (!pylist_append_fmt(
+                        py_retlist,
+                        "(iiiNNiI)",
+                        -1,
+                        AF_INET6,
+                        SOCK_DGRAM,
+                        py_laddr,
+                        py_raddr,
+                        PSUTIL_CONN_NONE,
+                        processed_pid
+                    ))
+                {
+                    goto error;
+                }
+                py_laddr = NULL;
+                py_raddr = NULL;
+            }
+        }
+#endif
+        free(databuf.buf);
+    }
+
+    close(sd);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_laddr);
+    Py_XDECREF(py_raddr);
+    Py_DECREF(py_retlist);
+    if (databuf_init == 1)
+        free(databuf.buf);
+    if (sd != 0)
+        close(sd);
+    return NULL;
+}
diff --git a/psutil/arch/sunos/proc.c b/psutil/arch/sunos/proc.c
new file mode 100644
index 0000000000..1924fc4729
--- /dev/null
+++ b/psutil/arch/sunos/proc.c
@@ -0,0 +1,602 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+
+#include <fcntl.h>
+#include <libproc.h>
+
+#include "../../arch/all/init.h"
+
+
+// Read a file content and fills a C structure with it.
+static int
+psutil_file_to_struct(char *path, void *fstruct, size_t size) {
+    int fd;
+    ssize_t nbytes;
+
+    Py_BEGIN_ALLOW_THREADS
+    fd = open(path, O_RDONLY);
+    Py_END_ALLOW_THREADS
+    if (fd == -1) {
+        PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
+        return 0;
+    }
+    Py_BEGIN_ALLOW_THREADS
+    nbytes = read(fd, fstruct, size);
+    Py_END_ALLOW_THREADS
+    if (nbytes == -1) {
+        close(fd);
+        psutil_oserror();
+        return 0;
+    }
+    if (nbytes != (ssize_t)size) {
+        close(fd);
+        psutil_runtime_error("read() file structure size mismatch");
+        return 0;
+    }
+    close(fd);
+    return nbytes;
+}
+
+
+PyObject *
+psutil_proc_oneshot(PyObject *self, PyObject *args) {
+    int pid;
+    char path[1000];
+    psinfo_t info;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+
+    str_format(path, sizeof(path), "%s/%i/psinfo", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+    return Py_BuildValue(
+        "ikkdiiikiiii",
+        info.pr_ppid,  // parent pid
+        info.pr_rssize,  // rss
+        info.pr_size,  // vms
+        PSUTIL_TV2DOUBLE(info.pr_start),  // create time
+        info.pr_lwp.pr_nice - NZERO,  // nice
+        info.pr_nlwp,  // no. of threads
+        info.pr_lwp.pr_state,  // status code
+        info.pr_ttydev,  // tty nr
+        (int)info.pr_uid,  // real user id
+        (int)info.pr_euid,  // effective user id
+        (int)info.pr_gid,  // real group id
+        (int)info.pr_egid  // effective group id
+    );
+}
+
+
+// Return process name and args as a Python tuple.
+PyObject *
+psutil_proc_name_and_args(PyObject *self, PyObject *args) {
+    int pid;
+    char path[1000];
+    psinfo_t info;
+    const char *procfs_path;
+    size_t i;
+    size_t argc;
+    char **argv = NULL;
+    PyObject *py_name = NULL;
+    PyObject *py_sep = NULL;
+    PyObject *py_arg = NULL;
+    PyObject *py_args_str = NULL;
+    PyObject *py_args_list = NULL;
+    PyObject *py_rettuple = NULL;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+    str_format(path, sizeof(path), "%s/%i/psinfo", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+
+    py_name = PyUnicode_DecodeFSDefault(info.pr_fname);
+    if (!py_name)
+        goto error;
+
+    // SunOS truncates arguments to length PRARGSZ and has them
+    // space-separated. The only way to retrieve full properly-split
+    // command line is to parse process memory.
+    argv = psutil_read_raw_args(info, procfs_path, &argc);
+    if (argv) {
+        py_args_list = PyList_New(argc);
+        if (!py_args_list)
+            goto error;
+
+        // iterate through arguments
+        for (i = 0; i < argc; i++) {
+            py_arg = PyUnicode_DecodeFSDefault(argv[i]);
+            if (!py_arg) {
+                Py_DECREF(py_args_list);
+                py_args_list = NULL;
+                break;
+            }
+
+            if (PyList_SetItem(py_args_list, i, py_arg))
+                goto error;
+
+            py_arg = NULL;
+        }
+
+        psutil_free_cstrings_array(argv, argc);
+    }
+
+    // If we can't read process memory or can't decode the result
+    // then return args from /proc.
+    if (!py_args_list) {
+        PyErr_Clear();
+        py_args_str = PyUnicode_DecodeFSDefault(info.pr_psargs);
+        if (!py_args_str)
+            goto error;
+
+        py_sep = PyUnicode_FromString(" ");
+        if (!py_sep)
+            goto error;
+
+        py_args_list = PyUnicode_Split(py_args_str, py_sep, -1);
+        if (!py_args_list)
+            goto error;
+
+        Py_XDECREF(py_sep);
+        Py_XDECREF(py_args_str);
+    }
+
+    py_rettuple = Py_BuildValue("OO", py_name, py_args_list);
+    if (!py_rettuple)
+        goto error;
+
+    Py_DECREF(py_name);
+    Py_DECREF(py_args_list);
+
+    return py_rettuple;
+
+error:
+    psutil_free_cstrings_array(argv, argc);
+    Py_XDECREF(py_name);
+    Py_XDECREF(py_args_list);
+    Py_XDECREF(py_sep);
+    Py_XDECREF(py_arg);
+    Py_XDECREF(py_args_str);
+    Py_XDECREF(py_rettuple);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_environ(PyObject *self, PyObject *args) {
+    int pid;
+    char path[1000];
+    psinfo_t info;
+    const char *procfs_path;
+    char **env = NULL;
+    ssize_t env_count = -1;
+    char *dm;
+    int i = 0;
+    PyObject *py_envname = NULL;
+    PyObject *py_envval = NULL;
+    PyObject *py_retdict;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+
+    py_retdict = PyDict_New();
+    if (!py_retdict)
+        return PyErr_NoMemory();
+
+    str_format(path, sizeof(path), "%s/%i/psinfo", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        goto error;
+
+    if (!info.pr_envp) {
+        psutil_oserror_ad("/proc/pid/psinfo struct not set");
+        goto error;
+    }
+
+    env = psutil_read_raw_env(info, procfs_path, &env_count);
+    if (!env && env_count != 0)
+        goto error;
+
+    for (i = 0; i < env_count; i++) {
+        if (!env[i])
+            break;
+
+        dm = strchr(env[i], '=');
+        if (!dm)
+            continue;
+
+        *dm = '\0';
+
+        py_envname = PyUnicode_DecodeFSDefault(env[i]);
+        if (!py_envname)
+            goto error;
+
+        py_envval = PyUnicode_DecodeFSDefault(dm + 1);
+        if (!py_envval)
+            goto error;
+
+        if (PyDict_SetItem(py_retdict, py_envname, py_envval) < 0)
+            goto error;
+
+        Py_CLEAR(py_envname);
+        Py_CLEAR(py_envval);
+    }
+
+    psutil_free_cstrings_array(env, env_count);
+    return py_retdict;
+
+error:
+    if (env && env_count >= 0)
+        psutil_free_cstrings_array(env, env_count);
+
+    Py_XDECREF(py_envname);
+    Py_XDECREF(py_envval);
+    Py_XDECREF(py_retdict);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_cpu_times(PyObject *self, PyObject *args) {
+    int pid;
+    char path[1000];
+    pstatus_t info;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+    str_format(path, sizeof(path), "%s/%i/status", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+    // results are more precise than os.times()
+    return Py_BuildValue(
+        "(dddd)",
+        PSUTIL_TV2DOUBLE(info.pr_utime),
+        PSUTIL_TV2DOUBLE(info.pr_stime),
+        PSUTIL_TV2DOUBLE(info.pr_cutime),
+        PSUTIL_TV2DOUBLE(info.pr_cstime)
+    );
+}
+
+
+// Return what CPU the process is running on.
+PyObject *
+psutil_proc_cpu_num(PyObject *self, PyObject *args) {
+    int fd = -1;
+    int pid;
+    char path[1000];
+    struct prheader header;
+    struct lwpsinfo *lwp = NULL;
+    int nent;
+    int size;
+    int proc_num;
+    ssize_t nbytes;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+
+    str_format(path, sizeof(path), "%s/%i/lpsinfo", procfs_path, pid);
+    Py_BEGIN_ALLOW_THREADS
+    fd = open(path, O_RDONLY);
+    Py_END_ALLOW_THREADS
+    if (fd == -1) {
+        PyErr_SetFromErrnoWithFilename(PyExc_OSError, path);
+        return NULL;
+    }
+
+    // read header
+    Py_BEGIN_ALLOW_THREADS
+    nbytes = pread(fd, &header, sizeof(header), 0);
+    Py_END_ALLOW_THREADS
+    if (nbytes == -1) {
+        psutil_oserror();
+        goto error;
+    }
+    if (nbytes != sizeof(header)) {
+        psutil_runtime_error("read() file structure size mismatch");
+        goto error;
+    }
+
+    // malloc
+    nent = header.pr_nent;
+    size = header.pr_entsize * nent;
+    lwp = malloc(size);
+    if (lwp == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    // read the rest
+    Py_BEGIN_ALLOW_THREADS
+    nbytes = pread(fd, lwp, size, sizeof(header));
+    Py_END_ALLOW_THREADS
+    if (nbytes == -1) {
+        psutil_oserror();
+        goto error;
+    }
+    if (nbytes != size) {
+        psutil_runtime_error("read() file structure size mismatch");
+        goto error;
+    }
+
+    // done
+    proc_num = lwp->pr_onpro;
+    close(fd);
+    free(lwp);
+    return Py_BuildValue("i", proc_num);
+
+error:
+    if (fd != -1)
+        close(fd);
+    free(lwp);
+    return NULL;
+}
+
+
+// Return process uids/gids as a Python tuple.
+PyObject *
+psutil_proc_cred(PyObject *self, PyObject *args) {
+    int pid;
+    char path[1000];
+    prcred_t info;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+    str_format(path, sizeof(path), "%s/%i/cred", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+    return Py_BuildValue(
+        "iiiiii",
+        info.pr_ruid,
+        info.pr_euid,
+        info.pr_suid,
+        info.pr_rgid,
+        info.pr_egid,
+        info.pr_sgid
+    );
+}
+
+
+PyObject *
+psutil_proc_num_ctx_switches(PyObject *self, PyObject *args) {
+    int pid;
+    char path[1000];
+    prusage_t info;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+    str_format(path, sizeof(path), "%s/%i/usage", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+    return Py_BuildValue("kk", info.pr_vctx, info.pr_ictx);
+}
+
+
+PyObject *
+psutil_proc_page_faults(PyObject *self, PyObject *args) {
+    int pid;
+    char path[1000];
+    prusage_t info;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+    str_format(path, sizeof(path), "%s/%i/usage", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+    return Py_BuildValue("(kk)", info.pr_minf, info.pr_majf);
+}
+
+
+/*
+ * Process IO counters.
+ *
+ * Commented out and left here as a reminder.  Apparently we cannot
+ * retrieve process IO stats because:
+ * - 'pr_ioch' is a sum of chars read and written, with no distinction
+ * - 'pr_inblk' and 'pr_oublk', which should be the number of bytes
+ *    read and written, hardly increase and according to:
+ *    http://www.brendangregg.com/Solaris/paper_diskubyp1.pdf
+ *    ...they should be meaningless anyway.
+ *
+PyObject*
+proc_io_counters(PyObject* self, PyObject* args) {
+    int pid;
+    char path[1000];
+    prusage_t info;
+    const char *procfs_path;
+
+    if (! PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        return NULL;
+    str_format(path, sizeof(path), "%s/%i/usage", procfs_path, pid);
+    if (! psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+
+    // On Solaris we only have 'pr_ioch' which accounts for bytes read
+    // *and* written.
+    // 'pr_inblk' and 'pr_oublk' should be expressed in blocks of
+    // 8KB according to:
+    // http://www.brendangregg.com/Solaris/paper_diskubyp1.pdf (pag. 8)
+    return Py_BuildValue("kkkk",
+                         info.pr_ioch,
+                         info.pr_ioch,
+                         info.pr_inblk,
+                         info.pr_oublk);
+}
+*/
+
+
+// Return information about a given process thread.
+PyObject *
+psutil_proc_query_thread(PyObject *self, PyObject *args) {
+    int pid, tid;
+    char path[1000];
+    lwpstatus_t info;
+    const char *procfs_path;
+
+    if (!PyArg_ParseTuple(args, "iis", &pid, &tid, &procfs_path))
+        return NULL;
+    str_format(
+        path, sizeof(path), "%s/%i/lwp/%i/lwpstatus", procfs_path, pid, tid
+    );
+    if (!psutil_file_to_struct(path, (void *)&info, sizeof(info)))
+        return NULL;
+    return Py_BuildValue(
+        "dd", PSUTIL_TV2DOUBLE(info.pr_utime), PSUTIL_TV2DOUBLE(info.pr_stime)
+    );
+}
+
+
+PyObject *
+psutil_proc_memory_maps(PyObject *self, PyObject *args) {
+    int pid;
+    int fd = -1;
+    char path[1000];
+    char perms[10];
+    const char *name;
+    struct stat st;
+    pstatus_t status;
+
+    prxmap_t *xmap = NULL, *p;
+    off_t size;
+    size_t nread;
+    int nmap;
+    uintptr_t pr_addr_sz;
+    uintptr_t stk_base_sz, brk_base_sz;
+    const char *procfs_path;
+
+    PyObject *py_path = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, "is", &pid, &procfs_path))
+        goto error;
+
+    str_format(path, sizeof(path), "%s/%i/status", procfs_path, pid);
+    if (!psutil_file_to_struct(path, (void *)&status, sizeof(status)))
+        goto error;
+
+    str_format(path, sizeof(path), "%s/%i/xmap", procfs_path, pid);
+    if (stat(path, &st) == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    size = st.st_size;
+
+    Py_BEGIN_ALLOW_THREADS
+    fd = open(path, O_RDONLY);
+    Py_END_ALLOW_THREADS
+    if (fd == -1) {
+        psutil_oserror();
+        goto error;
+    }
+
+    xmap = (prxmap_t *)malloc(size);
+    if (xmap == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    nread = pread(fd, xmap, size, 0);
+    Py_END_ALLOW_THREADS
+    nmap = nread / sizeof(prxmap_t);
+    p = xmap;
+
+    while (nmap) {
+        nmap -= 1;
+        if (p == NULL) {
+            p += 1;
+            continue;
+        }
+
+        perms[0] = '\0';
+        pr_addr_sz = p->pr_vaddr + p->pr_size;
+
+        // perms
+        str_format(
+            perms,
+            sizeof(perms),
+            "%c%c%c%c",
+            p->pr_mflags & MA_READ ? 'r' : '-',
+            p->pr_mflags & MA_WRITE ? 'w' : '-',
+            p->pr_mflags & MA_EXEC ? 'x' : '-',
+            p->pr_mflags & MA_SHARED ? 's' : '-'
+        );
+
+        // name
+        if (strlen(p->pr_mapname) > 0) {
+            name = p->pr_mapname;
+        }
+        else {
+            if ((p->pr_mflags & MA_ISM) || (p->pr_mflags & MA_SHM)) {
+                name = "[shmid]";
+            }
+            else {
+                stk_base_sz = status.pr_stkbase + status.pr_stksize;
+                brk_base_sz = status.pr_brkbase + status.pr_brksize;
+
+                if ((pr_addr_sz > status.pr_stkbase)
+                    && (p->pr_vaddr < stk_base_sz))
+                {
+                    name = "[stack]";
+                }
+                else if ((p->pr_mflags & MA_ANON)
+                         && (pr_addr_sz > status.pr_brkbase)
+                         && (p->pr_vaddr < brk_base_sz))
+                {
+                    name = "[heap]";
+                }
+                else {
+                    name = "[anon]";
+                }
+            }
+        }
+
+        py_path = PyUnicode_DecodeFSDefault(name);
+        if (!py_path)
+            goto error;
+        if (!pylist_append_fmt(
+                py_retlist,
+                "kksOkkk",
+                (unsigned long)p->pr_vaddr,
+                (unsigned long)pr_addr_sz,
+                perms,
+                py_path,
+                (unsigned long)p->pr_rss * p->pr_pagesize,
+                (unsigned long)p->pr_anon * p->pr_pagesize,
+                (unsigned long)p->pr_locked * p->pr_pagesize
+            ))
+        {
+            goto error;
+        }
+        Py_CLEAR(py_path);
+
+        // increment pointer
+        p += 1;
+    }
+
+    close(fd);
+    free(xmap);
+    return py_retlist;
+
+error:
+    if (fd != -1)
+        close(fd);
+    Py_XDECREF(py_path);
+    Py_DECREF(py_retlist);
+    if (xmap != NULL)
+        free(xmap);
+    return NULL;
+}
diff --git a/psutil/arch/sunos/sys.c b/psutil/arch/sunos/sys.c
new file mode 100644
index 0000000000..d3afb12418
--- /dev/null
+++ b/psutil/arch/sunos/sys.c
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+
+#include <utmpx.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_boot_time(PyObject *self, PyObject *args) {
+    float boot_time = 0.0;
+    struct utmpx *ut;
+
+    UTXENT_MUTEX_LOCK();
+    setutxent();
+    while (NULL != (ut = getutxent())) {
+        if (ut->ut_type == BOOT_TIME) {
+            boot_time = (float)ut->ut_tv.tv_sec;
+            break;
+        }
+    }
+    endutxent();
+    UTXENT_MUTEX_UNLOCK();
+    if (fabs(boot_time) < 0.000001) {
+        // could not find BOOT_TIME in getutxent loop
+        psutil_runtime_error("can't determine boot time");
+        return NULL;
+    }
+    return Py_BuildValue("f", boot_time);
+}
diff --git a/psutil/arch/windows/cpu.c b/psutil/arch/windows/cpu.c
new file mode 100644
index 0000000000..34bfadf551
--- /dev/null
+++ b/psutil/arch/windows/cpu.c
@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <windows.h>
+#include <PowrProf.h>
+
+#include "../../arch/all/init.h"
+
+
+// Return the number of logical, active CPUs. Return 0 if undetermined.
+// See discussion at: https://bugs.python.org/issue33166#msg314631
+static unsigned int
+psutil_get_num_cpus(int fail_on_err) {
+    unsigned int ncpus;
+
+    ncpus = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS);
+    if ((ncpus == 0) && (fail_on_err == 1)) {
+        psutil_oserror();
+    }
+    return ncpus;
+}
+
+
+// Retrieves system CPU timing information as a (user, system, idle)
+// tuple. The values returned are the sum of times across all CPUs.
+PyObject *
+psutil_cpu_times(PyObject *self, PyObject *args) {
+    double idle, kernel, user, system;
+    FILETIME idle_time, kernel_time, user_time;
+
+    if (!GetSystemTimes(&idle_time, &kernel_time, &user_time)) {
+        psutil_oserror();
+        return NULL;
+    }
+
+    idle = (double)((HI_T * idle_time.dwHighDateTime)
+                    + (LO_T * idle_time.dwLowDateTime));
+    user = (double)((HI_T * user_time.dwHighDateTime)
+                    + (LO_T * user_time.dwLowDateTime));
+    kernel = (double)((HI_T * kernel_time.dwHighDateTime)
+                      + (LO_T * kernel_time.dwLowDateTime));
+
+    // Kernel time includes idle time.
+    // We return only busy kernel time subtracting idle time from
+    // kernel time.
+    system = (kernel - idle);
+    return Py_BuildValue("(ddd)", user, system, idle);
+}
+
+
+// Same as above but for all CPUs.
+PyObject *
+psutil_per_cpu_times(PyObject *self, PyObject *args) {
+    double idle, kernel, systemt, user, interrupt, dpc;
+    NTSTATUS status;
+    SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *sppi = NULL;
+    UINT i;
+    unsigned int ncpus;
+    ULONG retlen = 0;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    // retrieves number of processors
+    ncpus = psutil_get_num_cpus(1);
+    if (ncpus == 0)
+        goto error;
+
+    // allocates an array of SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION
+    // structures, one per processor
+    sppi = (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *)malloc(
+        ncpus * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)
+    );
+    if (sppi == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    // gets cpu time information
+    status = NtQuerySystemInformation(
+        SystemProcessorPerformanceInformation,
+        sppi,
+        ncpus * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION),
+        &retlen
+    );
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(
+            status,
+            "NtQuerySystemInformation(SystemProcessorPerformanceInformation)"
+        );
+        goto error;
+    }
+
+    // The kernel may return entries for less CPUs than ncpus: on
+    // systems with more than 64 CPUs it only covers the calling
+    // thread's processor group.
+    ncpus = retlen / sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
+
+    idle = user = kernel = interrupt = dpc = 0;
+    for (i = 0; i < ncpus; i++) {
+        user = (double)((HI_T * sppi[i].UserTime.HighPart)
+                        + (LO_T * sppi[i].UserTime.LowPart));
+        idle = (double)((HI_T * sppi[i].IdleTime.HighPart)
+                        + (LO_T * sppi[i].IdleTime.LowPart));
+        kernel = (double)((HI_T * sppi[i].KernelTime.HighPart)
+                          + (LO_T * sppi[i].KernelTime.LowPart));
+        interrupt = (double)((HI_T * sppi[i].InterruptTime.HighPart)
+                             + (LO_T * sppi[i].InterruptTime.LowPart));
+        dpc = (double)((HI_T * sppi[i].DpcTime.HighPart)
+                       + (LO_T * sppi[i].DpcTime.LowPart));
+
+        // kernel time includes idle time on windows
+        // we return only busy kernel time subtracting
+        // idle time from kernel time
+        systemt = kernel - idle;
+        if (!pylist_append_fmt(
+                py_retlist, "(ddddd)", user, systemt, idle, interrupt, dpc
+            ))
+            goto error;
+    }
+
+    free(sppi);
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    if (sppi)
+        free(sppi);
+    return NULL;
+}
+
+
+// Return the number of active, logical CPUs.
+PyObject *
+psutil_cpu_count_logical(PyObject *self, PyObject *args) {
+    unsigned int ncpus;
+
+    ncpus = psutil_get_num_cpus(0);
+    if (ncpus != 0)
+        return Py_BuildValue("I", ncpus);
+    else
+        Py_RETURN_NONE;  // mimic os.cpu_count()
+}
+
+
+// Return the number of CPU cores (non hyper-threading).
+PyObject *
+psutil_cpu_count_cores(PyObject *self, PyObject *args) {
+    DWORD rc;
+    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX buffer = NULL;
+    PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX ptr = NULL;
+    DWORD length = 0;
+    DWORD offset = 0;
+    DWORD ncpus = 0;
+    DWORD prev_processor_info_size = 0;
+
+    // Differently from GetLogicalProcessorInformation(),
+    // GetLogicalProcessorInformationEx() supports process groups,
+    // meaning this is able to report more than 64 CPUs. See:
+    // https://bugs.python.org/issue33166
+    while (1) {
+        rc = GetLogicalProcessorInformationEx(RelationAll, buffer, &length);
+        if (rc == FALSE) {
+            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+                if (buffer) {
+                    free(buffer);
+                }
+                buffer = (PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX
+                )malloc(length);
+                if (NULL == buffer) {
+                    PyErr_NoMemory();
+                    return NULL;
+                }
+            }
+            else {
+                psutil_debug(
+                    "GetLogicalProcessorInformationEx() returned %u",
+                    GetLastError()
+                );
+                goto return_none;
+            }
+        }
+        else {
+            break;
+        }
+    }
+
+    ptr = buffer;
+    while (offset < length) {
+        // Advance ptr by the size of the previous
+        // SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX struct.
+        ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX
+                   *)(((char *)ptr) + prev_processor_info_size);
+
+        if (ptr->Relationship == RelationProcessorCore) {
+            ncpus += 1;
+        }
+
+        // When offset == length, we've reached the last processor
+        // info struct in the buffer.
+        offset += ptr->Size;
+        prev_processor_info_size = ptr->Size;
+    }
+
+    free(buffer);
+    if (ncpus != 0) {
+        return Py_BuildValue("I", ncpus);
+    }
+    else {
+        psutil_debug("GetLogicalProcessorInformationEx() count was 0");
+        Py_RETURN_NONE;  // mimic os.cpu_count()
+    }
+
+return_none:
+    if (buffer != NULL)
+        free(buffer);
+    Py_RETURN_NONE;
+}
+
+
+PyObject *
+psutil_cpu_stats(PyObject *self, PyObject *args) {
+    NTSTATUS status;
+    SYSTEM_PERFORMANCE_INFORMATION *spi = NULL;
+    SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *sppi = NULL;
+    SYSTEM_INTERRUPT_INFORMATION *InterruptInformation = NULL;
+    unsigned int ncpus;
+    unsigned int nentries;
+    UINT i;
+    ULONG retlen = 0;
+    ULONG64 dpcs = 0;
+    ULONG interrupts = 0;
+    ULONG ctx_switches;
+    ULONG syscalls;
+
+    // retrieves number of processors
+    ncpus = psutil_get_num_cpus(1);
+    if (ncpus == 0)
+        goto error;
+
+    // get syscalls / ctx switches (system-wide, not per CPU)
+    spi = (SYSTEM_PERFORMANCE_INFORMATION *)malloc(
+        sizeof(SYSTEM_PERFORMANCE_INFORMATION)
+    );
+    if (spi == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+    status = NtQuerySystemInformation(
+        SystemPerformanceInformation,
+        spi,
+        sizeof(SYSTEM_PERFORMANCE_INFORMATION),
+        NULL
+    );
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(
+            status, "NtQuerySystemInformation(SystemPerformanceInformation)"
+        );
+        goto error;
+    }
+
+    // get DPCs
+    InterruptInformation = malloc(
+        sizeof(SYSTEM_INTERRUPT_INFORMATION) * ncpus
+    );
+    if (InterruptInformation == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    status = NtQuerySystemInformation(
+        SystemInterruptInformation,
+        InterruptInformation,
+        ncpus * sizeof(SYSTEM_INTERRUPT_INFORMATION),
+        &retlen
+    );
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(
+            status, "NtQuerySystemInformation(SystemInterruptInformation)"
+        );
+        goto error;
+    }
+    // The kernel may return entries for less CPUs than ncpus: on
+    // systems with more than 64 CPUs it only covers the calling
+    // thread's processor group.
+    nentries = retlen / sizeof(SYSTEM_INTERRUPT_INFORMATION);
+    for (i = 0; i < nentries; i++) {
+        dpcs += InterruptInformation[i].DpcCount;
+    }
+
+    // get interrupts
+    sppi = (SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION *)malloc(
+        ncpus * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION)
+    );
+    if (sppi == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    status = NtQuerySystemInformation(
+        SystemProcessorPerformanceInformation,
+        sppi,
+        ncpus * sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION),
+        &retlen
+    );
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(
+            status,
+            "NtQuerySystemInformation(SystemProcessorPerformanceInformation)"
+        );
+        goto error;
+    }
+
+    nentries = retlen / sizeof(SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION);
+    for (i = 0; i < nentries; i++) {
+        interrupts += sppi[i].InterruptCount;
+    }
+
+    ctx_switches = spi->ContextSwitches;
+    syscalls = spi->SystemCalls;
+    free(spi);
+    free(InterruptInformation);
+    free(sppi);
+    return Py_BuildValue(
+        "kkkk", ctx_switches, interrupts, (unsigned long)dpcs, syscalls
+    );
+
+error:
+    if (spi)
+        free(spi);
+    if (InterruptInformation)
+        free(InterruptInformation);
+    if (sppi)
+        free(sppi);
+    return NULL;
+}
+
+
+PyObject *
+psutil_cpu_freq(PyObject *self, PyObject *args) {
+    PROCESSOR_POWER_INFORMATION *ppi;
+    NTSTATUS ret;
+    ULONG size;
+    LPBYTE pBuffer = NULL;
+    ULONG current;
+    ULONG max;
+    unsigned int ncpus;
+
+    // Get the number of CPUs.
+    ncpus = psutil_get_num_cpus(1);
+    if (ncpus == 0)
+        return NULL;
+
+    // Allocate size.
+    size = ncpus * sizeof(PROCESSOR_POWER_INFORMATION);
+    pBuffer = (BYTE *)LocalAlloc(LPTR, size);
+    if (!pBuffer) {
+        psutil_oserror();
+        return NULL;
+    }
+
+    // Syscall.
+    ret = CallNtPowerInformation(ProcessorInformation, NULL, 0, pBuffer, size);
+    if (!NT_SUCCESS(ret)) {
+        psutil_SetFromNTStatusErr(ret, "CallNtPowerInformation");
+        goto error;
+    }
+
+    // Results.
+    ppi = (PROCESSOR_POWER_INFORMATION *)pBuffer;
+    max = ppi->MaxMhz;
+    current = ppi->CurrentMhz;
+    LocalFree(pBuffer);
+
+    return Py_BuildValue("kk", current, max);
+
+error:
+    if (pBuffer != NULL)
+        LocalFree(pBuffer);
+    return NULL;
+}
diff --git a/psutil/arch/windows/disk.c b/psutil/arch/windows/disk.c
new file mode 100644
index 0000000000..01d7375192
--- /dev/null
+++ b/psutil/arch/windows/disk.c
@@ -0,0 +1,458 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <windows.h>
+
+#include "../../arch/all/init.h"
+
+
+#ifndef _ARRAYSIZE
+#define _ARRAYSIZE(a) (sizeof(a) / sizeof(a[0]))
+#endif
+
+static char *
+psutil_get_drive_type(int type) {
+    switch (type) {
+        case DRIVE_FIXED:
+            return "fixed";
+        case DRIVE_CDROM:
+            return "cdrom";
+        case DRIVE_REMOVABLE:
+            return "removable";
+        case DRIVE_UNKNOWN:
+            return "unknown";
+        case DRIVE_NO_ROOT_DIR:
+            return "unmounted";
+        case DRIVE_REMOTE:
+            return "remote";
+        case DRIVE_RAMDISK:
+            return "ramdisk";
+        default:
+            return "?";
+    }
+}
+
+
+PyObject *
+psutil_disk_usage(PyObject *self, PyObject *args) {
+    PyObject *py_path;
+    wchar_t *path = NULL;
+    ULARGE_INTEGER total, free, avail;
+    BOOL retval;
+    ULONGLONG used;
+
+    if (!PyArg_ParseTuple(args, "U", &py_path)) {
+        return NULL;
+    }
+
+    path = PyUnicode_AsWideCharString(py_path, NULL);
+    if (path == NULL) {
+        return NULL;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    retval = GetDiskFreeSpaceExW(path, &avail, &total, &free);
+    Py_END_ALLOW_THREADS
+
+    PyMem_Free(path);
+
+    if (retval == 0) {
+        return PyErr_SetExcFromWindowsErrWithFilenameObject(
+            PyExc_OSError, 0, py_path
+        );
+    }
+
+    used = total.QuadPart - free.QuadPart;
+    return Py_BuildValue("(KKK)", total.QuadPart, used, free.QuadPart);
+}
+
+
+PyObject *
+psutil_disk_io_counters(PyObject *self, PyObject *args) {
+    DISK_PERFORMANCE *diskPerformance = NULL;
+    DWORD dwSize;
+    HANDLE hDevice = NULL;
+    char szDevice[MAX_PATH];
+    char szDeviceDisplay[MAX_PATH];
+    int devNum;
+    DWORD ioctrlSize;
+    BOOL ret;
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_tuple = NULL;
+
+    if (py_retdict == NULL)
+        return NULL;
+
+    // Drivers may return a bigger struct than the one we know about,
+    // in which case the ioctl below asks for a bigger buffer.
+    ioctrlSize = sizeof(DISK_PERFORMANCE);
+    diskPerformance = malloc(ioctrlSize);
+    if (diskPerformance == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    // Apparently there's no way to figure out how many times we have
+    // to iterate in order to find valid drives.
+    // Let's assume 32, which is higher than 26, the number of letters
+    // in the alphabet (from A:\ to Z:\).
+    for (devNum = 0; devNum <= 32; ++devNum) {
+        py_tuple = NULL;
+        str_format(szDevice, MAX_PATH, "\\\\.\\PhysicalDrive%d", devNum);
+        // Opening a disk device may block, so do it without the GIL.
+        Py_BEGIN_ALLOW_THREADS
+        hDevice = CreateFile(
+            szDevice,
+            0,
+            FILE_SHARE_READ | FILE_SHARE_WRITE,
+            NULL,
+            OPEN_EXISTING,
+            0,
+            NULL
+        );
+        Py_END_ALLOW_THREADS
+        if (hDevice == INVALID_HANDLE_VALUE)
+            continue;
+
+        // DeviceIoControl() sucks!
+        while (1) {
+            Py_BEGIN_ALLOW_THREADS
+            ret = DeviceIoControl(
+                hDevice,
+                IOCTL_DISK_PERFORMANCE,
+                NULL,
+                0,
+                diskPerformance,
+                ioctrlSize,
+                &dwSize,
+                NULL
+            );
+            Py_END_ALLOW_THREADS
+            if (ret != 0)
+                break;  // OK!
+            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+                // Grow the buffer for real, up to a sane limit.
+                if (ioctrlSize < 1024 * 1024) {
+                    void *tmp;
+
+                    ioctrlSize *= 2;
+                    tmp = realloc(diskPerformance, ioctrlSize);
+                    if (tmp == NULL) {
+                        PyErr_NoMemory();
+                        goto error;
+                    }
+                    diskPerformance = tmp;
+                    continue;
+                }
+            }
+            else if (GetLastError() == ERROR_INVALID_FUNCTION) {
+                // This happens on AppVeyor:
+                // https://ci.appveyor.com/project/giampaolo/psutil/build/1364/job/ascpdi271b06jle3
+                // Assume it means we're dealing with some exotic disk
+                // and go on.
+                psutil_debug(
+                    "DeviceIoControl -> ERROR_INVALID_FUNCTION; "
+                    "ignore PhysicalDrive%i",
+                    devNum
+                );
+                goto next;
+            }
+            else if (GetLastError() == ERROR_NOT_SUPPORTED) {
+                // Again, let's assume we're dealing with some exotic disk.
+                psutil_debug(
+                    "DeviceIoControl -> ERROR_NOT_SUPPORTED; "
+                    "ignore PhysicalDrive%i",
+                    devNum
+                );
+                goto next;
+            }
+            // XXX: it seems we should also catch ERROR_INVALID_PARAMETER:
+            // https://sites.ualberta.ca/dept/aict/uts/software/openbsd/ports/4.1/i386/openafs/w-openafs-1.4.14-transarc/openafs-1.4.14/src/usd/usd_nt.c
+
+            // XXX: we can also bump into ERROR_MORE_DATA in which case
+            // (quoting doc) we're supposed to retry with a bigger buffer
+            // and specify  a new "starting point", whatever it means.
+            psutil_oserror();
+            goto error;
+        }
+
+        str_format(szDeviceDisplay, MAX_PATH, "PhysicalDrive%i", devNum);
+        py_tuple = Py_BuildValue(
+            "(IILLKK)",
+            diskPerformance->ReadCount,
+            diskPerformance->WriteCount,
+            diskPerformance->BytesRead,
+            diskPerformance->BytesWritten,
+            // convert to ms:
+            // https://github.com/giampaolo/psutil/issues/1012
+            (unsigned long long)(diskPerformance->ReadTime.QuadPart)
+                / 10000000,
+            (unsigned long long)(diskPerformance->WriteTime.QuadPart)
+                / 10000000
+        );
+        if (!py_tuple)
+            goto error;
+        if (PyDict_SetItemString(py_retdict, szDeviceDisplay, py_tuple))
+            goto error;
+        Py_CLEAR(py_tuple);
+
+    next:
+        CloseHandle(hDevice);
+    }
+
+    free(diskPerformance);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_tuple);
+    Py_DECREF(py_retdict);
+    if (hDevice != NULL && hDevice != INVALID_HANDLE_VALUE)
+        CloseHandle(hDevice);
+    if (diskPerformance != NULL)
+        free(diskPerformance);
+    return NULL;
+}
+
+
+PyObject *
+psutil_disk_partitions(PyObject *self, PyObject *args) {
+    DWORD num_chars;
+    wchar_t drive_strings[255];
+    wchar_t *drive_letter = drive_strings;
+    wchar_t mp_buf[MAX_PATH];
+    wchar_t mp_path[MAX_PATH];
+    int all = 0;
+    int type;
+    int ret;
+    unsigned int old_mode = 0;
+    char opts[50];
+    HANDLE mp_h;
+    BOOL mp_flag = TRUE;
+    wchar_t fs_type[MAX_PATH + 1] = {0};
+    DWORD pflags = 0;
+    DWORD lpMaximumComponentLength = 0;  // max file name
+    PyObject *py_drive = NULL;
+    PyObject *py_mount = NULL;
+    PyObject *py_fs = NULL;
+    PyObject *py_opts = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL) {
+        return NULL;
+    }
+
+    // avoid to visualize a message box in case something goes wrong
+    // see https://github.com/giampaolo/psutil/issues/264
+    old_mode = SetErrorMode(SEM_FAILCRITICALERRORS);
+
+    if (!PyArg_ParseTuple(args, "p", &all))
+        goto error;
+
+    Py_BEGIN_ALLOW_THREADS
+    num_chars = GetLogicalDriveStringsW(254, drive_letter);
+    Py_END_ALLOW_THREADS
+
+    if (num_chars == 0) {
+        psutil_oserror_wsyscall("GetLogicalDriveStringsW");
+        goto error;
+    }
+
+    while (*drive_letter != 0) {
+        opts[0] = 0;
+        fs_type[0] = 0;
+
+        Py_BEGIN_ALLOW_THREADS
+        type = GetDriveTypeW(drive_letter);
+        Py_END_ALLOW_THREADS
+
+        // by default we only show hard drives and cd-roms
+        if (all == 0) {
+            if ((type == DRIVE_UNKNOWN) || (type == DRIVE_NO_ROOT_DIR)
+                || (type == DRIVE_REMOTE) || (type == DRIVE_RAMDISK))
+            {
+                goto next;
+            }
+            // floppy disk: skip it by default as it introduces a
+            // considerable slowdown.
+            if ((type == DRIVE_REMOVABLE)
+                && (wcscmp(drive_letter, L"A:\\") == 0))
+            {
+                goto next;
+            }
+        }
+
+        // May spin up a removable drive or go over the wire for a
+        // network one, so do it without the GIL.
+        Py_BEGIN_ALLOW_THREADS
+        ret = GetVolumeInformationW(
+            drive_letter,
+            NULL,  // we don't want the volume name
+            0,
+            NULL,
+            &lpMaximumComponentLength,
+            &pflags,
+            fs_type,
+            _ARRAYSIZE(fs_type)
+        );
+        Py_END_ALLOW_THREADS
+
+        if (ret == 0) {
+            // We might get here in case of a floppy hard drive, in
+            // which case the error is (21, "device not ready").
+            // Let's pretend it didn't happen as we already have
+            // the drive name and type ('removable'). opts is left
+            // empty.
+            SetLastError(0);
+        }
+        else {
+            if (pflags & FILE_READ_ONLY_VOLUME)
+                str_append(opts, sizeof(opts), "ro");
+            else
+                str_append(opts, sizeof(opts), "rw");
+            if (pflags & FILE_VOLUME_IS_COMPRESSED)
+                str_append(opts, sizeof(opts), ",compressed");
+            if (pflags & FILE_READ_ONLY_VOLUME)
+                str_append(opts, sizeof(opts), ",readonly");
+        }
+
+        if (strlen(opts) > 0)
+            str_append(opts, sizeof(opts), ",");
+        str_append(opts, sizeof(opts), psutil_get_drive_type(type));
+
+        // Convert the strings which will go into the result tuples.
+        py_drive = PyUnicode_FromWideChar(drive_letter, wcslen(drive_letter));
+        if (py_drive == NULL)
+            goto error;
+        py_fs = PyUnicode_FromWideChar(fs_type, wcslen(fs_type));
+        if (py_fs == NULL)
+            goto error;
+        // opts holds pure ASCII, so plain UTF-8 decoding is safe.
+        py_opts = PyUnicode_FromString(opts);
+        if (py_opts == NULL)
+            goto error;
+
+        // Check for mount points on this volume and add/get info
+        // (checks first to know if we can even have mount points)
+        if ((ret != 0) && (pflags & FILE_SUPPORTS_REPARSE_POINTS)) {
+            Py_BEGIN_ALLOW_THREADS
+            mp_h = FindFirstVolumeMountPointW(drive_letter, mp_buf, MAX_PATH);
+            Py_END_ALLOW_THREADS
+
+            if (mp_h != INVALID_HANDLE_VALUE) {
+                mp_flag = TRUE;
+                while (mp_flag) {
+                    // Append full mount path with drive letter.
+                    mp_path[0] = L'\0';
+                    wcsncat(mp_path, drive_letter, _ARRAYSIZE(mp_path) - 1);
+                    wcsncat(
+                        mp_path,
+                        mp_buf,
+                        _ARRAYSIZE(mp_path) - wcslen(mp_path) - 1
+                    );
+
+                    py_mount = PyUnicode_FromWideChar(
+                        mp_path, wcslen(mp_path)
+                    );
+                    if (py_mount == NULL) {
+                        FindVolumeMountPointClose(mp_h);
+                        goto error;
+                    }
+
+                    if (!pylist_append_fmt(
+                            py_retlist,
+                            "(OOOO)",
+                            py_drive,
+                            py_mount,
+                            py_fs,  // typically "NTFS"
+                            py_opts
+                        ))
+                    {
+                        FindVolumeMountPointClose(mp_h);
+                        goto error;
+                    }
+                    Py_CLEAR(py_mount);
+
+                    // Continue looking for more mount points
+                    Py_BEGIN_ALLOW_THREADS
+                    mp_flag = FindNextVolumeMountPointW(
+                        mp_h, mp_buf, MAX_PATH
+                    );
+                    Py_END_ALLOW_THREADS
+                }
+                FindVolumeMountPointClose(mp_h);
+            }
+        }
+
+        if (!pylist_append_fmt(
+                py_retlist,
+                "(OOOO)",
+                py_drive,
+                py_drive,
+                py_fs,  // either FAT, FAT32, NTFS, HPFS, CDFS, UDF or NWFS
+                py_opts
+            ))
+        {
+            goto error;
+        }
+        goto next;
+
+    next:
+        Py_CLEAR(py_opts);
+        Py_CLEAR(py_fs);
+        Py_CLEAR(py_mount);
+        Py_CLEAR(py_drive);
+        drive_letter = wcschr(drive_letter, 0) + 1;
+    }
+
+    SetErrorMode(old_mode);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_opts);
+    Py_XDECREF(py_fs);
+    Py_XDECREF(py_mount);
+    Py_XDECREF(py_drive);
+    SetErrorMode(old_mode);
+    Py_DECREF(py_retlist);
+    return NULL;
+}
+
+
+// Accept a filename's drive in native  format like "\Device\HarddiskVolume1\"
+// and return the corresponding drive letter (e.g. "C:\\").
+// If no match is found return an empty string.
+PyObject *
+psutil_QueryDosDevice(PyObject *self, PyObject *args) {
+    PyObject *py_device_path;
+    PyObject *py_ret = NULL;
+    wchar_t *device_path;
+    wchar_t d = L'A';
+
+    if (!PyArg_ParseTuple(args, "U", &py_device_path))
+        return NULL;
+
+    device_path = PyUnicode_AsWideCharString(py_device_path, NULL);
+    if (device_path == NULL)
+        return NULL;
+
+    while (d <= L'Z') {
+        wchar_t szDeviceName[3] = {d, L':', L'\0'};
+        wchar_t szTarget[512] = {0};
+        if (QueryDosDeviceW(szDeviceName, szTarget, 511) != 0) {
+            if (wcscmp(device_path, szTarget) == 0) {
+                py_ret = PyUnicode_FromWideChar(
+                    szDeviceName, wcslen(szDeviceName)
+                );
+                PyMem_Free(device_path);
+                return py_ret;
+            }
+        }
+        d++;
+    }
+    PyMem_Free(device_path);
+    return PyUnicode_FromString("");
+}
diff --git a/psutil/arch/windows/glpi.h b/psutil/arch/windows/glpi.h
deleted file mode 100644
index 6f98483733..0000000000
--- a/psutil/arch/windows/glpi.h
+++ /dev/null
@@ -1,41 +0,0 @@
-// mingw headers are missing this
-
-typedef enum _LOGICAL_PROCESSOR_RELATIONSHIP {
-    RelationProcessorCore,
-    RelationNumaNode,
-    RelationCache,
-    RelationProcessorPackage,
-    RelationGroup,
-    RelationAll=0xffff
-} LOGICAL_PROCESSOR_RELATIONSHIP;
-
-typedef enum _PROCESSOR_CACHE_TYPE {
-    CacheUnified,CacheInstruction,CacheData,CacheTrace
-} PROCESSOR_CACHE_TYPE;
-
-typedef struct _CACHE_DESCRIPTOR {
-    BYTE Level;
-    BYTE Associativity;
-    WORD LineSize;
-    DWORD Size;
-    PROCESSOR_CACHE_TYPE Type;
-} CACHE_DESCRIPTOR,*PCACHE_DESCRIPTOR;
-
-typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION {
-    ULONG_PTR ProcessorMask;
-    LOGICAL_PROCESSOR_RELATIONSHIP Relationship;
-    union {
-        struct {
-            BYTE Flags;
-        } ProcessorCore;
-        struct {
-            DWORD NodeNumber;
-        } NumaNode;
-        CACHE_DESCRIPTOR Cache;
-        ULONGLONG Reserved[2];
-    };
-} SYSTEM_LOGICAL_PROCESSOR_INFORMATION,*PSYSTEM_LOGICAL_PROCESSOR_INFORMATION;
-
-WINBASEAPI WINBOOL WINAPI
-GetLogicalProcessorInformation(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer,
-                               PDWORD ReturnedLength);
\ No newline at end of file
diff --git a/psutil/arch/windows/heap.c b/psutil/arch/windows/heap.c
new file mode 100644
index 0000000000..d025eed364
--- /dev/null
+++ b/psutil/arch/windows/heap.c
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+
+#include <Python.h>
+#include <windows.h>
+#include <malloc.h>
+
+#include "../../arch/all/init.h"
+
+
+// Returns a tuple with:
+//
+// - heap_used: sum of used blocks, like `uordblks` on Linux. Catches
+//   small `malloc()` without `free()` and small `HeapAlloc()` without
+//   `HeapFree()`. If bigger than some KB they go into `mmap_used`.
+//
+// - mmap_used: VirtualAlloc'd regions, like `hblkhd` on Linux. Catches
+//   `VirtualAlloc()` without `VirtualFree()`.
+//
+// - heap_count (Windows only): number of private heaps. Catches
+//   `HeapCreate()` without `HeapDestroy()`.
+PyObject *
+psutil_heap_info(PyObject *self, PyObject *args) {
+    MEMORY_BASIC_INFORMATION mbi;
+    LPVOID addr = NULL;
+    SIZE_T heap_used = 0;
+    SIZE_T mmap_used = 0;
+    DWORD heap_count;
+    DWORD nhandles;
+    _HEAPINFO hinfo = {0};
+    hinfo._pentry = NULL;
+    int status;
+    HANDLE *heaps = NULL;
+
+    // Walk CRT heaps to measure heap used.
+    while ((status = _heapwalk(&hinfo)) == _HEAPOK) {
+        if (hinfo._useflag == _USEDENTRY) {
+            heap_used += hinfo._size;
+        }
+    }
+    if ((status != _HEAPEND) && (status != _HEAPOK))
+        return psutil_oserror_wsyscall("_heapwalk");
+
+    // Get number of heaps (+ heap handles).
+    nhandles = GetProcessHeaps(0, NULL);  // 1st: get count
+    if (nhandles == 0)
+        return psutil_oserror_wsyscall("GetProcessHeaps (1/2)");
+
+    heaps = (HANDLE *)malloc(nhandles * sizeof(HANDLE));
+    if (!heaps) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    heap_count = GetProcessHeaps(nhandles, heaps);  // 2nd: get heaps handles
+    if (heap_count == 0) {
+        free(heaps);
+        return psutil_oserror_wsyscall("GetProcessHeaps (2/2)");
+    }
+    // The number of heaps may have changed between the two calls. If
+    // it shrank, fewer handles than `nhandles` were stored; if it
+    // grew, the extra heaps didn't fit in the buffer. Either way only
+    // the first min(heap_count, nhandles) buffer entries are valid.
+    if (heap_count != nhandles) {
+        psutil_debug(
+            "GetProcessHeaps(): heap count changed from %lu to %lu "
+            "between the two calls",
+            (unsigned long)nhandles,
+            (unsigned long)heap_count
+        );
+        if (heap_count < nhandles)
+            nhandles = heap_count;
+    }
+
+    // VirtualAlloc'd regions (large allocations / mmap|hblkhd equivalent).
+    while (VirtualQuery(addr, &mbi, sizeof(mbi)) == sizeof(mbi)) {
+        if (mbi.State == MEM_COMMIT && mbi.Type == MEM_PRIVATE
+            && (mbi.AllocationProtect & PAGE_READWRITE))
+        {
+            int is_heap_region = 0;
+            for (DWORD i = 0; i < nhandles; i++) {
+                if (mbi.AllocationBase == heaps[i]) {
+                    is_heap_region = 1;
+                    break;
+                }
+            }
+
+            if (!is_heap_region) {
+                mmap_used += mbi.RegionSize;
+            }
+        }
+        addr = (LPBYTE)mbi.BaseAddress + mbi.RegionSize;
+    }
+
+    free(heaps);
+
+    return Py_BuildValue(
+        "nnn",
+        (Py_ssize_t)heap_used,
+        (Py_ssize_t)mmap_used,
+        (Py_ssize_t)heap_count
+    );
+}
+
+
+// Return unused heap memory back to the OS. Return the size of the
+// largest committed free block in the heap, in bytes. Equivalent to
+// Linux `heap_trim(0)`.
+PyObject *
+psutil_heap_trim(PyObject *self, PyObject *args) {
+    HANDLE hHeap = GetProcessHeap();
+    SIZE_T largest_free;
+
+    if (hHeap == NULL)
+        return psutil_oserror_wsyscall("GetProcessHeap");
+
+    // HeapCompact() returns 0 both on error and when the heap has no
+    // committed free blocks, in which case last-error is untouched.
+    SetLastError(0);
+    largest_free = HeapCompact(hHeap, 0);
+    if (largest_free == 0) {
+        if (GetLastError() != NO_ERROR) {
+            return psutil_oserror_wsyscall("HeapCompact");
+        }
+    }
+    return Py_BuildValue("K", (unsigned long long)largest_free);
+}
diff --git a/psutil/arch/windows/inet_ntop.c b/psutil/arch/windows/inet_ntop.c
deleted file mode 100644
index 50dfb6aed4..0000000000
--- a/psutil/arch/windows/inet_ntop.c
+++ /dev/null
@@ -1,38 +0,0 @@
-#include "inet_ntop.h"
-
-// From: https://memset.wordpress.com/2010/10/09/inet_ntop-for-win32/
-PCSTR
-WSAAPI
-inet_ntop(__in INT Family,
-          __in PVOID pAddr,
-          __out_ecount(StringBufSize) PSTR pStringBuf,
-          __in size_t StringBufSize) {
-    DWORD dwAddressLength = 0;
-    struct sockaddr_storage srcaddr;
-    struct sockaddr_in *srcaddr4 = (struct sockaddr_in*) &srcaddr;
-    struct sockaddr_in6 *srcaddr6 = (struct sockaddr_in6*) &srcaddr;
-
-    memset(&srcaddr, 0, sizeof(struct sockaddr_storage));
-    srcaddr.ss_family = Family;
-
-    if (Family == AF_INET)
-    {
-        dwAddressLength = sizeof(struct sockaddr_in);
-        memcpy(&(srcaddr4->sin_addr), pAddr, sizeof(struct in_addr));
-    } else if (Family == AF_INET6)
-    {
-        dwAddressLength = sizeof(struct sockaddr_in6);
-        memcpy(&(srcaddr6->sin6_addr), pAddr, sizeof(struct in6_addr));
-    } else {
-        return NULL;
-    }
-
-    if (WSAAddressToString((LPSOCKADDR) &srcaddr,
-                           dwAddressLength,
-                           0,
-                           pStringBuf,
-                           (LPDWORD) &StringBufSize) != 0) {
-        return NULL;
-    }
-    return pStringBuf;
-}
diff --git a/psutil/arch/windows/inet_ntop.h b/psutil/arch/windows/inet_ntop.h
deleted file mode 100644
index 0d97e28c88..0000000000
--- a/psutil/arch/windows/inet_ntop.h
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <ws2tcpip.h>
-
-PCSTR
-WSAAPI
-inet_ntop(
-    __in                                INT             Family,
-    __in                                PVOID           pAddr,
-    __out_ecount(StringBufSize)         PSTR            pStringBuf,
-    __in                                size_t          StringBufSize
-);
\ No newline at end of file
diff --git a/psutil/arch/windows/init.c b/psutil/arch/windows/init.c
new file mode 100644
index 0000000000..acab9bda1d
--- /dev/null
+++ b/psutil/arch/windows/init.c
@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <windows.h>
+
+#include "../../arch/all/init.h"
+
+
+// Needed to make these globally visible.
+SYSTEM_INFO PSUTIL_SYSTEM_INFO;
+CRITICAL_SECTION PSUTIL_CRITICAL_SECTION;
+
+// Declared extern in ntextapi.h, assigned by psutil_loadlibs() below.
+_NtQueryInformationProcess NtQueryInformationProcess = NULL;
+_NtQueryObject NtQueryObject = NULL;
+_NtQuerySystemInformation NtQuerySystemInformation = NULL;
+_NtQueryVirtualMemory NtQueryVirtualMemory = NULL;
+_NtResumeProcess NtResumeProcess = NULL;
+_NtSetInformationProcess NtSetInformationProcess = NULL;
+_NtSuspendProcess NtSuspendProcess = NULL;
+_RtlGetVersion RtlGetVersion = NULL;
+_RtlNtStatusToDosErrorNoTeb RtlNtStatusToDosErrorNoTeb = NULL;
+_WTSEnumerateSessionsW WTSEnumerateSessionsW = NULL;
+_WTSFreeMemory WTSFreeMemory = NULL;
+_WTSQuerySessionInformationW WTSQuerySessionInformationW = NULL;
+
+
+// ====================================================================
+// --- Utils
+// ====================================================================
+
+// Convert a NTSTATUS value to a Win32 error code and set the proper
+// Python exception.
+PVOID
+psutil_SetFromNTStatusErr(NTSTATUS status, const char *syscall) {
+    ULONG err;
+    char fullmsg[1024];
+
+    if (NT_NTWIN32(status))
+        err = WIN32_FROM_NTSTATUS(status);
+    else
+        err = RtlNtStatusToDosErrorNoTeb(status);
+    str_format(fullmsg, sizeof(fullmsg), "(originated from %s)", syscall);
+    return PyErr_SetFromWindowsErrWithFilename(err, fullmsg);
+}
+
+
+// A wrapper around GetModuleHandle and GetProcAddress.
+PVOID
+psutil_GetProcAddress(LPCSTR libname, LPCSTR apiname) {
+    HMODULE mod;
+    FARPROC addr;
+
+    if ((mod = GetModuleHandleA(libname)) == NULL) {
+        psutil_debug(
+            "%s module not supported (needed for %s)", libname, apiname
+        );
+        PyErr_SetFromWindowsErrWithFilename(0, libname);
+        return NULL;
+    }
+    if ((addr = GetProcAddress(mod, apiname)) == NULL) {
+        psutil_debug("%s -> %s API not supported", libname, apiname);
+        PyErr_SetFromWindowsErrWithFilename(0, apiname);
+        return NULL;
+    }
+    return addr;
+}
+
+
+// A wrapper around LoadLibrary and GetProcAddress.
+PVOID
+psutil_GetProcAddressFromLib(LPCSTR libname, LPCSTR apiname) {
+    HMODULE mod;
+    FARPROC addr;
+
+    Py_BEGIN_ALLOW_THREADS
+    mod = LoadLibraryA(libname);
+    Py_END_ALLOW_THREADS
+    if (mod == NULL) {
+        psutil_debug("%s lib not supported (needed for %s)", libname, apiname);
+        PyErr_SetFromWindowsErrWithFilename(0, libname);
+        return NULL;
+    }
+    if ((addr = GetProcAddress(mod, apiname)) == NULL) {
+        psutil_debug("%s -> %s not supported", libname, apiname);
+        PyErr_SetFromWindowsErrWithFilename(0, apiname);
+        FreeLibrary(mod);
+        return NULL;
+    }
+    // Causes crash.
+    // FreeLibrary(mod);
+    return addr;
+}
+
+
+// Convert the hi and lo parts of a FILETIME structure or a
+// LARGE_INTEGER to a UNIX time. A FILETIME contains a 64-bit value
+// representing the number of 100-nanosecond intervals since January 1,
+// 1601 (UTC). A UNIX time is the number of seconds that have elapsed
+// since the UNIX epoch, that is the time 00:00:00 UTC on 1 January
+// 1970.
+static double
+_to_unix_time(ULONGLONG hiPart, ULONGLONG loPart) {
+    ULONGLONG ret;
+
+    // 100 nanosecond intervals since January 1, 1601.
+    ret = hiPart << 32;
+    ret += loPart;
+    // Change starting time to the Epoch (00:00:00 UTC, January 1, 1970).
+    ret -= 116444736000000000ull;
+    // Convert nano secs to secs.
+    return (double)ret / 10000000ull;
+}
+
+
+double
+psutil_FiletimeToUnixTime(FILETIME ft) {
+    return _to_unix_time(
+        (ULONGLONG)ft.dwHighDateTime, (ULONGLONG)ft.dwLowDateTime
+    );
+}
+
+
+double
+psutil_LargeIntegerToUnixTime(LARGE_INTEGER li) {
+    return _to_unix_time((ULONGLONG)li.HighPart, (ULONGLONG)li.LowPart);
+}
+
+
+// ====================================================================
+// --- Init / load libs
+// ====================================================================
+
+
+static int
+psutil_loadlibs() {
+    // --- Mandatory. ntdll is loaded in every process, so
+    // GetModuleHandle is enough.
+    NtQuerySystemInformation = psutil_GetProcAddress(
+        "ntdll.dll", "NtQuerySystemInformation"
+    );
+    if (!NtQuerySystemInformation)
+        return -1;
+    NtQueryInformationProcess = psutil_GetProcAddress(
+        "ntdll.dll", "NtQueryInformationProcess"
+    );
+    if (!NtQueryInformationProcess)
+        return -1;
+    NtSetInformationProcess = psutil_GetProcAddress(
+        "ntdll.dll", "NtSetInformationProcess"
+    );
+    if (!NtSetInformationProcess)
+        return -1;
+    NtQueryObject = psutil_GetProcAddress("ntdll.dll", "NtQueryObject");
+    if (!NtQueryObject)
+        return -1;
+    RtlGetVersion = psutil_GetProcAddress("ntdll.dll", "RtlGetVersion");
+    if (!RtlGetVersion)
+        return -1;
+    NtSuspendProcess = psutil_GetProcAddress("ntdll.dll", "NtSuspendProcess");
+    if (!NtSuspendProcess)
+        return -1;
+    NtResumeProcess = psutil_GetProcAddress("ntdll.dll", "NtResumeProcess");
+    if (!NtResumeProcess)
+        return -1;
+    NtQueryVirtualMemory = psutil_GetProcAddress(
+        "ntdll.dll", "NtQueryVirtualMemory"
+    );
+    if (!NtQueryVirtualMemory)
+        return -1;
+    RtlNtStatusToDosErrorNoTeb = psutil_GetProcAddress(
+        "ntdll.dll", "RtlNtStatusToDosErrorNoTeb"
+    );
+    if (!RtlNtStatusToDosErrorNoTeb)
+        return -1;
+
+    // --- Optional
+
+    // minimum requirements: Windows Server Core
+    WTSEnumerateSessionsW = psutil_GetProcAddressFromLib(
+        "wtsapi32.dll", "WTSEnumerateSessionsW"
+    );
+    WTSQuerySessionInformationW = psutil_GetProcAddressFromLib(
+        "wtsapi32.dll", "WTSQuerySessionInformationW"
+    );
+    WTSFreeMemory = psutil_GetProcAddressFromLib(
+        "wtsapi32.dll", "WTSFreeMemory"
+    );
+
+    PyErr_Clear();
+    return 0;
+}
+
+
+static int
+psutil_check_winver() {
+    RTL_OSVERSIONINFOEXW versionInfo;
+    NTSTATUS status;
+    ULONG maj;
+    ULONG min;
+
+    memset(&versionInfo, 0, sizeof(RTL_OSVERSIONINFOEXW));
+    versionInfo.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
+    status = RtlGetVersion((PRTL_OSVERSIONINFOW)&versionInfo);
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(status, "RtlGetVersion");
+        return -1;
+    }
+    maj = versionInfo.dwMajorVersion;
+    min = versionInfo.dwMinorVersion;
+    if (maj < 10) {
+        psutil_runtime_error(
+            "this Windows version is too old (%lu.%lu); psutil 7.2.x is "
+            "the latest version supporting Windows Vista, 7, 8, 8.1 and "
+            "their server counterparts",
+            maj,
+            min
+        );
+        return -1;
+    }
+    return 0;
+}
+
+
+// Called on module import.
+int
+psutil_setup_windows(void) {
+    if (psutil_loadlibs() != 0)
+        return -1;
+    if (psutil_check_winver() != 0)
+        return -1;
+    GetSystemInfo(&PSUTIL_SYSTEM_INFO);
+    InitializeCriticalSection(&PSUTIL_CRITICAL_SECTION);
+    return 0;
+}
diff --git a/psutil/arch/windows/init.h b/psutil/arch/windows/init.h
new file mode 100644
index 0000000000..049c18206f
--- /dev/null
+++ b/psutil/arch/windows/init.h
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <windows.h>
+#include <Winsvc.h>
+
+#include "ntextapi.h"
+
+
+extern SYSTEM_INFO PSUTIL_SYSTEM_INFO;
+extern CRITICAL_SECTION PSUTIL_CRITICAL_SECTION;
+
+#define MALLOC(x) HeapAlloc(GetProcessHeap(), 0, (x))
+#define MALLOC_ZERO(x) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (x))
+#define FREE(x) HeapFree(GetProcessHeap(), 0, (x))
+
+#define _NT_FACILITY_MASK 0xfff
+#define _NT_FACILITY_SHIFT 16
+#define _NT_FACILITY(status) \
+    ((((ULONG)(status)) >> _NT_FACILITY_SHIFT) & _NT_FACILITY_MASK)
+
+#define NT_NTWIN32(status) (_NT_FACILITY(status) == FACILITY_WIN32)
+#define WIN32_FROM_NTSTATUS(status) (((ULONG)(status)) & 0xffff)
+
+#define LO_T 1e-7
+#define HI_T 429.4967296
+
+#ifndef AF_INET6
+#define AF_INET6 23
+#endif
+
+double psutil_FiletimeToUnixTime(FILETIME ft);
+double psutil_LargeIntegerToUnixTime(LARGE_INTEGER li);
+int psutil_setup_windows(void);
+PVOID psutil_GetProcAddress(LPCSTR libname, LPCSTR procname);
+PVOID psutil_GetProcAddressFromLib(LPCSTR libname, LPCSTR procname);
+PVOID psutil_SetFromNTStatusErr(NTSTATUS status, const char *syscall);
+
+extern PyObject *TimeoutExpired;
+extern PyObject *TimeoutAbandoned;
+
+
+int _psutil_pids(DWORD **pids_array, int *pids_count);
+HANDLE psutil_handle_from_pid(DWORD pid, DWORD dwDesiredAccess);
+int psutil_pid_is_running(DWORD pid);
+int psutil_check_pid_running(DWORD pid);
+PyObject *psutil_raise_for_nt_status(
+    DWORD pid, NTSTATUS status, const char *syscall
+);
+int psutil_set_se_debug();
+
+#define PSUTIL_FIRST_PROCESS(Processes) \
+    ((PSYSTEM_PROCESS_INFORMATION)(Processes))
+
+#define PSUTIL_NEXT_PROCESS(Process)                                              \
+    (((PSYSTEM_PROCESS_INFORMATION)(Process))->NextEntryOffset                    \
+         ? (PSYSTEM_PROCESS_INFORMATION)((PCHAR)(Process)                         \
+                                         + ((PSYSTEM_PROCESS_INFORMATION)(Process \
+                                            ))                                    \
+                                               ->NextEntryOffset)                 \
+         : NULL)
+
+int psutil_proc_table(PVOID *retBuffer);
+int psutil_proc_table_entry(
+    DWORD pid, PSYSTEM_PROCESS_INFORMATION *retProcess, PVOID *retBuffer
+);
+
+PyObject *psutil_cpu_count_cores(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_count_logical(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_freq(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_stats(PyObject *self, PyObject *args);
+PyObject *psutil_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_disk_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_disk_partitions(PyObject *self, PyObject *args);
+PyObject *psutil_disk_usage(PyObject *self, PyObject *args);
+PyObject *psutil_get_loadavg();
+PyObject *psutil_get_open_files(HANDLE hProcess);
+PyObject *psutil_getpagesize(PyObject *self, PyObject *args);
+PyObject *psutil_heap_info(PyObject *self, PyObject *args);
+PyObject *psutil_heap_trim(PyObject *self, PyObject *args);
+PyObject *psutil_init_loadavg_counter();
+PyObject *psutil_net_connections(PyObject *self, PyObject *args);
+PyObject *psutil_net_if_addrs(PyObject *self, PyObject *args);
+PyObject *psutil_net_if_stats(PyObject *self, PyObject *args);
+PyObject *psutil_net_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_per_cpu_times(PyObject *self, PyObject *args);
+PyObject *psutil_pid_exists(PyObject *self, PyObject *args);
+PyObject *psutil_pids(PyObject *self, PyObject *args);
+PyObject *psutil_ppid_map(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cmdline(PyObject *self, PyObject *args, PyObject *kw);
+PyObject *psutil_proc_cpu_affinity_get(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cpu_affinity_set(PyObject *self, PyObject *args);
+PyObject *psutil_proc_cwd(PyObject *self, PyObject *args);
+PyObject *psutil_proc_environ(PyObject *self, PyObject *args);
+PyObject *psutil_proc_exe(PyObject *self, PyObject *args);
+PyObject *psutil_proc_io_counters(PyObject *self, PyObject *args);
+PyObject *psutil_proc_io_priority_get(PyObject *self, PyObject *args);
+PyObject *psutil_proc_io_priority_set(PyObject *self, PyObject *args);
+PyObject *psutil_proc_kill(PyObject *self, PyObject *args);
+PyObject *psutil_proc_memory_info(PyObject *self, PyObject *args);
+PyObject *psutil_proc_memory_maps(PyObject *self, PyObject *args);
+PyObject *psutil_proc_memory_uss(PyObject *self, PyObject *args);
+PyObject *psutil_proc_num_handles(PyObject *self, PyObject *args);
+PyObject *psutil_proc_oneshot(PyObject *self, PyObject *args);
+PyObject *psutil_proc_open_files(PyObject *self, PyObject *args);
+PyObject *psutil_proc_ppid(PyObject *self, PyObject *args);
+PyObject *psutil_proc_priority_get(PyObject *self, PyObject *args);
+PyObject *psutil_proc_priority_set(PyObject *self, PyObject *args);
+PyObject *psutil_proc_suspend_or_resume(PyObject *self, PyObject *args);
+PyObject *psutil_proc_threads(PyObject *self, PyObject *args);
+PyObject *psutil_proc_times(PyObject *self, PyObject *args);
+PyObject *psutil_proc_username(PyObject *self, PyObject *args);
+PyObject *psutil_proc_wait(PyObject *self, PyObject *args);
+PyObject *psutil_QueryDosDevice(PyObject *self, PyObject *args);
+PyObject *psutil_sensors_battery(PyObject *self, PyObject *args);
+PyObject *psutil_swap_percent(PyObject *self, PyObject *args);
+PyObject *psutil_boot_time(PyObject *self, PyObject *args);
+PyObject *psutil_users(PyObject *self, PyObject *args);
+PyObject *psutil_GetPerformanceInfo(PyObject *self, PyObject *args);
+PyObject *psutil_winservice_enumerate(PyObject *self, PyObject *args);
+PyObject *psutil_winservice_query_config(PyObject *self, PyObject *args);
+PyObject *psutil_winservice_query_descr(PyObject *self, PyObject *args);
+PyObject *psutil_winservice_query_status(PyObject *self, PyObject *args);
+PyObject *psutil_winservice_start(PyObject *self, PyObject *args);
+PyObject *psutil_winservice_stop(PyObject *self, PyObject *args);
diff --git a/psutil/arch/windows/mem.c b/psutil/arch/windows/mem.c
new file mode 100644
index 0000000000..5346935d96
--- /dev/null
+++ b/psutil/arch/windows/mem.c
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <windows.h>
+#include <Psapi.h>
+#include <pdh.h>
+
+#include "../../arch/all/init.h"
+
+
+PyObject *
+psutil_getpagesize(PyObject *self, PyObject *args) {
+    // XXX: we may want to use GetNativeSystemInfo to differentiate
+    // page size for WoW64 processes (but am not sure).
+    return Py_BuildValue("I", PSUTIL_SYSTEM_INFO.dwPageSize);
+}
+
+
+PyObject *
+psutil_GetPerformanceInfo(PyObject *self, PyObject *args) {
+    PERFORMANCE_INFORMATION info;
+    PyObject *dict = PyDict_New();
+
+    if (!dict)
+        return NULL;
+    if (!GetPerformanceInfo(&info, sizeof(PERFORMANCE_INFORMATION))) {
+        psutil_oserror();
+        goto error;
+    }
+
+    // clang-format off
+    if (!pydict_add(dict, "CommitTotal", "K", (ULONGLONG)info.CommitTotal)) goto error;
+    if (!pydict_add(dict, "CommitLimit", "K", (ULONGLONG)info.CommitLimit)) goto error;
+    if (!pydict_add(dict, "CommitPeak", "K", (ULONGLONG)info.CommitPeak)) goto error;
+    if (!pydict_add(dict, "PhysicalTotal", "K", (ULONGLONG)info.PhysicalTotal)) goto error;
+    if (!pydict_add(dict, "PhysicalAvailable", "K", (ULONGLONG)info.PhysicalAvailable)) goto error;
+    if (!pydict_add(dict, "KernelTotal", "K", (ULONGLONG)info.KernelTotal)) goto error;
+    if (!pydict_add(dict, "KernelPaged", "K", (ULONGLONG)info.KernelPaged)) goto error;
+    if (!pydict_add(dict, "KernelNonpaged", "K", (ULONGLONG)info.KernelNonpaged)) goto error;
+    if (!pydict_add(dict, "SystemCache", "K", (ULONGLONG)info.SystemCache)) goto error;
+    if (!pydict_add(dict, "PageSize", "K", (ULONGLONG)info.PageSize)) goto error;
+    // if (!pydict_add(dict, "HandleCount", "I", (unsigned int)info.HandleCount)) goto error;
+    // if (!pydict_add(dict, "ProcessCount", "I", (unsigned int)info.ProcessCount)) goto error;
+    // if (!pydict_add(dict, "ThreadCount", "I", (unsigned int)info.ThreadCount)) goto error;
+    // clang-format on
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    return NULL;
+}
+
+
+// Return a float representing the percent usage of all paging files on
+// the system.
+PyObject *
+psutil_swap_percent(PyObject *self, PyObject *args) {
+    WCHAR *szCounterPath = L"\\Paging File(_Total)\\% Usage";
+    PDH_STATUS s;
+    HQUERY hQuery;
+    HCOUNTER hCounter;
+    PDH_FMT_COUNTERVALUE counterValue;
+    double percentUsage;
+
+    Py_BEGIN_ALLOW_THREADS
+    s = PdhOpenQueryW(NULL, 0, &hQuery);
+    Py_END_ALLOW_THREADS
+    if (s != ERROR_SUCCESS) {
+        psutil_runtime_error("PdhOpenQueryW failed (0x%08X)", s);
+        return NULL;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    s = PdhAddEnglishCounterW(hQuery, szCounterPath, 0, &hCounter);
+    Py_END_ALLOW_THREADS
+    if (s != ERROR_SUCCESS) {
+        PdhCloseQuery(hQuery);
+        psutil_runtime_error(
+            "PdhAddEnglishCounterW failed (0x%08X). Performance counters may "
+            "be disabled.",
+            s
+        );
+        return NULL;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    s = PdhCollectQueryData(hQuery);
+    Py_END_ALLOW_THREADS
+    if (s != ERROR_SUCCESS) {
+        // If swap disabled this will fail.
+        psutil_debug(
+            "PdhCollectQueryData failed (0x%08X); assume swap percent is 0", s
+        );
+        percentUsage = 0;
+    }
+    else {
+        Py_BEGIN_ALLOW_THREADS
+        s = PdhGetFormattedCounterValue(
+            (PDH_HCOUNTER)hCounter, PDH_FMT_DOUBLE, 0, &counterValue
+        );
+        Py_END_ALLOW_THREADS
+        if (s != ERROR_SUCCESS) {
+            PdhCloseQuery(hQuery);
+            psutil_runtime_error(
+                "PdhGetFormattedCounterValue failed (0x%08X)", s
+            );
+            return NULL;
+        }
+        percentUsage = counterValue.doubleValue;
+    }
+
+    PdhRemoveCounter(hCounter);
+    PdhCloseQuery(hQuery);
+    return Py_BuildValue("d", percentUsage);
+}
diff --git a/psutil/arch/windows/net.c b/psutil/arch/windows/net.c
new file mode 100644
index 0000000000..e5d765609c
--- /dev/null
+++ b/psutil/arch/windows/net.c
@@ -0,0 +1,468 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Fixes clash between winsock2.h and windows.h
+#define WIN32_LEAN_AND_MEAN
+
+#include <Python.h>
+#include <windows.h>
+#include <wchar.h>
+#include <ws2tcpip.h>
+
+#include "../../arch/all/init.h"
+
+// 1st try guesses the size, 2nd uses the size the kernel asked for,
+// 3rd is in case a NIC shows up in between.
+#define MAX_TRIES 3
+
+// net_if_addrs() needs the unicast addresses. Skip the rest.
+#define GAA_FLAGS                                    \
+    (GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST \
+     | GAA_FLAG_SKIP_DNS_SERVER)
+
+// net_io_counters() and net_if_stats() don't need unicast, and it's
+// the expensive bit to collect.
+#define GAA_FLAGS_SKIP_UNICAST (GAA_FLAGS | GAA_FLAG_SKIP_UNICAST)
+
+
+static PIP_ADAPTER_ADDRESSES
+psutil_get_nic_addresses(ULONG flags) {
+    // A 15KB buffer is recommended by MSDN as it's usually big enough
+    // to make GetAdaptersAddresses() succeed on the first call, saving
+    // an extra (expensive) syscall to determine the required size.
+    ULONG bufferLength = 15 * 1024;
+    ULONG ret;
+    PIP_ADAPTER_ADDRESSES buffer;
+    int attempt;
+
+    for (attempt = 0; attempt < MAX_TRIES; attempt++) {
+        buffer = calloc(1, bufferLength);
+        if (buffer == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+
+        // Queries the network stack, may be slow with many adapters.
+        // On ERROR_BUFFER_OVERFLOW `bufferLength` is set to the
+        // required size, so the retry uses a big enough buffer.
+        Py_BEGIN_ALLOW_THREADS
+        ret = GetAdaptersAddresses(
+            AF_UNSPEC, flags, NULL, buffer, &bufferLength
+        );
+        Py_END_ALLOW_THREADS
+        if (ret == ERROR_SUCCESS)
+            return buffer;
+
+        free(buffer);
+        if (ret != ERROR_BUFFER_OVERFLOW) {
+            psutil_runtime_error(
+                "GetAdaptersAddresses() syscall failed (err=%lu)",
+                (unsigned long)ret
+            );
+            return NULL;
+        }
+        psutil_debug(
+            "GetAdaptersAddresses(): retry with %lu bytes",
+            (unsigned long)bufferLength
+        );
+    }
+
+    psutil_runtime_error(
+        "GetAdaptersAddresses() buffer was still too small after %d attempts",
+        MAX_TRIES
+    );
+    return NULL;
+}
+
+
+// Return a dict of network I/O counters, one entry per NIC.
+PyObject *
+psutil_net_io_counters(PyObject *self, PyObject *args) {
+    DWORD dwRetVal = 0;
+    MIB_IF_ROW2 ifRow;
+    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
+    PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_nic_info = NULL;
+    PyObject *py_nic_name = NULL;
+
+    if (py_retdict == NULL)
+        return NULL;
+    pAddresses = psutil_get_nic_addresses(GAA_FLAGS_SKIP_UNICAST);
+    if (pAddresses == NULL)
+        goto error;
+
+    pCurrAddresses = pAddresses;
+
+    while (pCurrAddresses) {
+        py_nic_info = NULL;
+        py_nic_name = NULL;
+
+        SecureZeroMemory(&ifRow, sizeof(ifRow));
+        ifRow.InterfaceIndex = pCurrAddresses->IfIndex;
+
+        Py_BEGIN_ALLOW_THREADS
+        dwRetVal = GetIfEntry2(&ifRow);
+        Py_END_ALLOW_THREADS
+        if (dwRetVal != NO_ERROR) {
+            psutil_debug(
+                "GetIfEntry2() failed for interface %lu (err=%lu); skip it",
+                (unsigned long)ifRow.InterfaceIndex,
+                (unsigned long)dwRetVal
+            );
+            pCurrAddresses = pCurrAddresses->Next;
+            continue;
+        }
+
+        py_nic_info = Py_BuildValue(
+            "(KKKKKKKK)",
+            ifRow.OutOctets,
+            ifRow.InOctets,
+            ifRow.OutUcastPkts + ifRow.OutNUcastPkts,
+            ifRow.InUcastPkts + ifRow.InNUcastPkts,
+            ifRow.InErrors,
+            ifRow.OutErrors,
+            ifRow.InDiscards,
+            ifRow.OutDiscards
+        );
+        if (!py_nic_info)
+            goto error;
+
+        py_nic_name = PyUnicode_FromWideChar(
+            pCurrAddresses->FriendlyName,
+            wcsnlen(pCurrAddresses->FriendlyName, IF_MAX_STRING_SIZE)
+        );
+        if (!py_nic_name)
+            goto error;
+
+        if (PyDict_SetItem(py_retdict, py_nic_name, py_nic_info))
+            goto error;
+
+        Py_CLEAR(py_nic_info);
+        Py_CLEAR(py_nic_name);
+
+        pCurrAddresses = pCurrAddresses->Next;
+    }
+
+    free(pAddresses);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_nic_info);
+    Py_XDECREF(py_nic_name);
+    Py_DECREF(py_retdict);
+    if (pAddresses)
+        free(pAddresses);
+    return NULL;
+}
+
+
+// Return NICs addresses.
+PyObject *
+psutil_net_if_addrs(PyObject *self, PyObject *args) {
+    unsigned int i = 0;
+    ULONG family;
+    PCTSTR intRet;
+    PCTSTR netmaskIntRet;
+    char *ptr;
+    char buff_addr[INET6_ADDRSTRLEN];
+    char buff_macaddr[MAX_ADAPTER_ADDRESS_LENGTH * 3];
+    char buff_netmask[INET_ADDRSTRLEN];
+    DWORD dwRetVal = 0;
+    ULONG converted_netmask;
+    UINT netmask_bits;
+    int n;
+    size_t remaining;
+    struct in_addr in_netmask;
+    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
+    PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
+    PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
+
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_address = NULL;
+    PyObject *py_mac_address = NULL;
+    PyObject *py_nic_name = NULL;
+    PyObject *py_netmask = NULL;
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    pAddresses = psutil_get_nic_addresses(GAA_FLAGS);
+    if (pAddresses == NULL)
+        goto error;
+    pCurrAddresses = pAddresses;
+
+    while (pCurrAddresses) {
+        Py_CLEAR(py_nic_name);
+        Py_CLEAR(py_address);
+        Py_CLEAR(py_mac_address);
+        Py_CLEAR(py_netmask);
+
+        pUnicast = pCurrAddresses->FirstUnicastAddress;
+
+        py_nic_name = PyUnicode_FromWideChar(
+            pCurrAddresses->FriendlyName, wcslen(pCurrAddresses->FriendlyName)
+        );
+        if (py_nic_name == NULL)
+            goto error;
+
+        // MAC address
+        if (pCurrAddresses->PhysicalAddressLength != 0) {
+            ptr = buff_macaddr;
+            remaining = sizeof(buff_macaddr);
+            for (i = 0; i < pCurrAddresses->PhysicalAddressLength; i++) {
+                if (i == pCurrAddresses->PhysicalAddressLength - 1) {
+                    n = str_format(
+                        ptr,
+                        remaining,
+                        "%.2X",
+                        (int)pCurrAddresses->PhysicalAddress[i]
+                    );
+                }
+                else {
+                    n = str_format(
+                        ptr,
+                        remaining,
+                        "%.2X-",
+                        (int)pCurrAddresses->PhysicalAddress[i]
+                    );
+                }
+                if (n < 0) {  // error or truncated
+                    psutil_runtime_error("str_format() error");
+                    goto error;
+                }
+                ptr += n;
+                remaining -= n;
+            }
+
+            py_mac_address = PyUnicode_FromString(buff_macaddr);
+            if (py_mac_address == NULL)
+                goto error;
+
+            if (!pylist_append_fmt(
+                    py_retlist,
+                    "(OiOOOO)",
+                    py_nic_name,
+                    -1,  // this will be converted later to AF_LINK
+                    py_mac_address,
+                    Py_None,  // netmask (not supported)
+                    Py_None,  // broadcast (not supported)
+                    Py_None  // ptp (not supported on Windows)
+                ))
+            {
+                goto error;
+            }
+
+            Py_CLEAR(py_mac_address);
+        }
+
+        // find out the IP address associated with the NIC
+        if (pUnicast != NULL) {
+            for (i = 0; pUnicast != NULL; i++) {
+                netmaskIntRet = NULL;
+                family = pUnicast->Address.lpSockaddr->sa_family;
+                if (family == AF_INET) {
+                    struct sockaddr_in *sa_in = (struct sockaddr_in *)pUnicast
+                                                    ->Address.lpSockaddr;
+                    intRet = inet_ntop(
+                        AF_INET,
+                        &(sa_in->sin_addr),
+                        buff_addr,
+                        sizeof(buff_addr)
+                    );
+                    if (!intRet) {
+                        psutil_oserror_wsyscall("inet_ntop");
+                        goto error;
+                    }
+                    netmask_bits = pUnicast->OnLinkPrefixLength;
+                    dwRetVal = ConvertLengthToIpv4Mask(
+                        netmask_bits, &converted_netmask
+                    );
+                    if (dwRetVal == NO_ERROR) {
+                        in_netmask.s_addr = converted_netmask;
+                        netmaskIntRet = inet_ntop(
+                            AF_INET,
+                            &in_netmask,
+                            buff_netmask,
+                            sizeof(buff_netmask)
+                        );
+                        if (!netmaskIntRet) {
+                            psutil_oserror_wsyscall("inet_ntop");
+                            goto error;
+                        }
+                    }
+                }
+                else if (family == AF_INET6) {
+                    struct sockaddr_in6 *sa_in6 = (struct sockaddr_in6 *)
+                                                      pUnicast->Address
+                                                          .lpSockaddr;
+                    intRet = inet_ntop(
+                        AF_INET6,
+                        &(sa_in6->sin6_addr),
+                        buff_addr,
+                        sizeof(buff_addr)
+                    );
+                    if (!intRet) {
+                        psutil_oserror_wsyscall("inet_ntop");
+                        goto error;
+                    }
+                }
+                else {
+                    // we should never get here
+                    pUnicast = pUnicast->Next;
+                    continue;
+                }
+
+                Py_CLEAR(py_address);
+                Py_CLEAR(py_netmask);
+
+                py_address = PyUnicode_FromString(buff_addr);
+                if (py_address == NULL)
+                    goto error;
+
+                if (netmaskIntRet != NULL) {
+                    py_netmask = PyUnicode_FromString(buff_netmask);
+                }
+                else {
+                    Py_INCREF(Py_None);
+                    py_netmask = Py_None;
+                }
+
+                if (!pylist_append_fmt(
+                        py_retlist,
+                        "(OiOOOO)",
+                        py_nic_name,
+                        family,
+                        py_address,
+                        py_netmask,
+                        Py_None,  // broadcast (not supported)
+                        Py_None  // ptp (not supported on Windows)
+                    ))
+                {
+                    goto error;
+                }
+
+                Py_CLEAR(py_address);
+                Py_CLEAR(py_netmask);
+
+                pUnicast = pUnicast->Next;
+            }
+        }
+
+        Py_CLEAR(py_nic_name);
+        pCurrAddresses = pCurrAddresses->Next;
+    }
+
+    free(pAddresses);
+    return py_retlist;
+
+error:
+    if (pAddresses)
+        free(pAddresses);
+    Py_XDECREF(py_retlist);
+    Py_XDECREF(py_address);
+    Py_XDECREF(py_mac_address);
+    Py_XDECREF(py_nic_name);
+    Py_XDECREF(py_netmask);
+    return NULL;
+}
+
+
+// Provides stats about NIC interfaces installed on the system.
+// TODO: get 'duplex' (currently it's hard coded to '2', aka 'full duplex')
+PyObject *
+psutil_net_if_stats(PyObject *self, PyObject *args) {
+    MIB_IF_ROW2 ifRow;
+    DWORD dwRetVal = 0;
+    PIP_ADAPTER_ADDRESSES pAddresses = NULL;
+    PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
+
+    PyObject *py_nic_name = NULL;
+    PyObject *py_retdict = PyDict_New();
+    PyObject *py_ifc_info = NULL;
+    PyObject *py_is_up = NULL;
+
+    if (py_retdict == NULL)
+        return NULL;
+
+    pAddresses = psutil_get_nic_addresses(GAA_FLAGS_SKIP_UNICAST);
+    if (pAddresses == NULL)
+        goto error;
+
+    pCurrAddresses = pAddresses;
+
+    while (pCurrAddresses) {
+        Py_CLEAR(py_nic_name);
+        Py_CLEAR(py_ifc_info);
+        Py_CLEAR(py_is_up);
+
+        SecureZeroMemory(&ifRow, sizeof(ifRow));
+        ifRow.InterfaceIndex = pCurrAddresses->IfIndex;
+
+        Py_BEGIN_ALLOW_THREADS
+        dwRetVal = GetIfEntry2(&ifRow);
+        Py_END_ALLOW_THREADS
+        if (dwRetVal != NO_ERROR) {
+            psutil_debug(
+                "GetIfEntry2() failed for interface %lu (err=%lu); skip it",
+                (unsigned long)ifRow.InterfaceIndex,
+                (unsigned long)dwRetVal
+            );
+            pCurrAddresses = pCurrAddresses->Next;
+            continue;
+        }
+
+        py_nic_name = PyUnicode_FromWideChar(
+            pCurrAddresses->FriendlyName,
+            wcsnlen(pCurrAddresses->FriendlyName, IF_MAX_STRING_SIZE)
+        );
+        if (py_nic_name == NULL)
+            goto error;
+
+        if (ifRow.OperStatus == IfOperStatusUp
+            && ifRow.AdminStatus == NET_IF_ADMIN_STATUS_UP)
+        {
+            py_is_up = Py_True;
+        }
+        else {
+            py_is_up = Py_False;
+        }
+        Py_INCREF(py_is_up);
+
+        py_ifc_info = Py_BuildValue(
+            "(OiKk)",
+            py_is_up,
+            2,  // duplex is hard coded to 'full'
+            ifRow.TransmitLinkSpeed / 1000000,  // bits/s, we want Mb/s
+            ifRow.Mtu
+        );
+        if (!py_ifc_info)
+            goto error;
+
+        if (PyDict_SetItem(py_retdict, py_nic_name, py_ifc_info))
+            goto error;
+
+        Py_CLEAR(py_ifc_info);
+        Py_CLEAR(py_nic_name);
+
+        pCurrAddresses = pCurrAddresses->Next;
+    }
+
+    free(pAddresses);
+    Py_CLEAR(py_nic_name);
+    Py_CLEAR(py_ifc_info);
+    Py_CLEAR(py_is_up);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_is_up);
+    Py_XDECREF(py_ifc_info);
+    Py_XDECREF(py_nic_name);
+    Py_XDECREF(py_retdict);
+    if (pAddresses)
+        free(pAddresses);
+    return NULL;
+}
diff --git a/psutil/arch/windows/ntextapi.h b/psutil/arch/windows/ntextapi.h
index 74adce2273..2e5a68d049 100644
--- a/psutil/arch/windows/ntextapi.h
+++ b/psutil/arch/windows/ntextapi.h
@@ -3,22 +3,221 @@
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
-#if !defined(__NTEXTAPI_H__)
-#define __NTEXTAPI_H__
-#include <winternl.h>
 
+// Definitions for the NT native API, the ntdll.dll layer below Win32
+// that exposes the Nt* and Rtl* functions. Microsoft documents only
+// part of these APIs, and warns that they may change or become
+// unavailable in future Windows versions. In practice, these
+// interfaces are widely used, and have remained stable for decades.
+//
+// We do not include <winternl.h> because it provides only a subset of
+// the declarations needed here. The missing definitions are provided
+// below.
+//
+// https://learn.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntquerysysteminformation
+// https://www.geoffchappell.com/studies/windows/win32/ntdll/api/native.htm
+
+#ifndef NTEXTAPI_H
+#define NTEXTAPI_H
+#include <iphlpapi.h>
+
+// What <winternl.h> would have given us, declared here instead.
 
-typedef struct {
+typedef LONG NTSTATUS;
+
+#ifndef NT_SUCCESS
+#define NT_SUCCESS(status) (((NTSTATUS)(status)) >= 0)
+#endif
+
+typedef LONG KPRIORITY;
+
+typedef struct _UNICODE_STRING {
+    USHORT Length;
+    USHORT MaximumLength;
+    PWSTR Buffer;
+} UNICODE_STRING, *PUNICODE_STRING;
+
+typedef struct _IO_STATUS_BLOCK {
+    union {
+        NTSTATUS Status;
+        PVOID Pointer;
+    } u;
+    ULONG_PTR Information;
+} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
+
+// Really enums. We only ever pass the constants #defined below, so an
+// integer type does the job.
+typedef ULONG FILE_INFORMATION_CLASS;
+typedef ULONG OBJECT_INFORMATION_CLASS;
+
+NTSYSAPI NTSTATUS NTAPI NtQueryInformationFile(
+    HANDLE FileHandle,
+    PIO_STATUS_BLOCK IoStatusBlock,
+    PVOID FileInformation,
+    ULONG Length,
+    FILE_INFORMATION_CLASS FileInformationClass
+);
+
+// https://github.com/ajkhoury/TestDll/blob/master/nt_ddk.h
+#define STATUS_INFO_LENGTH_MISMATCH ((NTSTATUS)0xC0000004L)
+#define STATUS_BUFFER_TOO_SMALL ((NTSTATUS)0xC0000023L)
+#define STATUS_ACCESS_DENIED ((NTSTATUS)0xC0000022L)
+#define STATUS_NOT_FOUND ((NTSTATUS)0xC0000225L)
+#define STATUS_BUFFER_OVERFLOW ((NTSTATUS)0x80000005L)
+
+// WtsApi32.h
+#define WTS_CURRENT_SERVER_HANDLE ((HANDLE)NULL)
+#define WINSTATIONNAME_LENGTH 32
+#define DOMAIN_LENGTH 17
+#define USERNAME_LENGTH 20
+
+// ================================================================
+// Enums
+// ================================================================
+
+// Members of the FILE_INFORMATION_CLASS, MEMORY_INFORMATION_CLASS,
+// OBJECT_INFORMATION_CLASS, PROCESSINFOCLASS and
+// SYSTEM_INFORMATION_CLASS enums. Values cross-checked against
+// System Informer's phnt (ntexapi.h, ntpsapi.h).
+#define FileBasicInformation 4
+#define FileStandardInformation 5
+#define MemoryWorkingSetInformation 1
+#define ObjectNameInformation 1
+#define ObjectTypesInformation 3
+#define ProcessBasicInformation 0
+#define ProcessCommandLineInformation 60
+#define ProcessHandleInformation 51
+#define ProcessIoPriority 33
+#define ProcessWow64Information 26
+#define SystemInterruptInformation 23
+#define SystemPerformanceInformation 2
+#define SystemProcessIdInformation 88
+#define SystemProcessInformation 5
+#define SystemProcessorPerformanceInformation 8
+#define SystemTimeOfDayInformation 3
+
+
+// process suspend() / resume()
+typedef enum _KTHREAD_STATE {
+    Initialized,
+    Ready,
+    Running,
+    Standby,
+    Terminated,
+    Waiting,
+    Transition,
+    DeferredReady,
+    GateWait,
+    MaximumThreadState
+} KTHREAD_STATE, *PKTHREAD_STATE;
+
+typedef enum _KWAIT_REASON {
+    Executive,
+    FreePage,
+    PageIn,
+    PoolAllocation,
+    DelayExecution,
+    Suspended,
+    UserRequest,
+    WrExecutive,
+    WrFreePage,
+    WrPageIn,
+    WrPoolAllocation,
+    WrDelayExecution,
+    WrSuspended,
+    WrUserRequest,
+    WrEventPair,
+    WrQueue,
+    WrLpcReceive,
+    WrLpcReply,
+    WrVirtualMemory,
+    WrPageOut,
+    WrRendezvous,
+    WrKeyedEvent,
+    WrTerminated,
+    WrProcessInSwap,
+    WrCpuRateControl,
+    WrCalloutStack,
+    WrKernel,
+    WrResource,
+    WrPushLock,
+    WrMutex,
+    WrQuantumEnd,
+    WrDispatchInt,
+    WrPreempted,
+    WrYieldExecution,
+    WrFastMutex,
+    WrGuardedMutex,
+    WrRundown,
+    WrAlertByThreadId,
+    WrDeferredPreempt,
+    MaximumWaitReason
+} KWAIT_REASON, *PKWAIT_REASON;
+
+// users()
+typedef enum _WTS_INFO_CLASS {
+    WTSInitialProgram,
+    WTSApplicationName,
+    WTSWorkingDirectory,
+    WTSOEMId,
+    WTSSessionId,
+    WTSUserName,
+    WTSWinStationName,
+    WTSDomainName,
+    WTSConnectState,
+    WTSClientBuildNumber,
+    WTSClientName,
+    WTSClientDirectory,
+    WTSClientProductId,
+    WTSClientHardwareId,
+    WTSClientAddress,
+    WTSClientDisplay,
+    WTSClientProtocolType,
+    WTSIdleTime,
+    WTSLogonTime,
+    WTSIncomingBytes,
+    WTSOutgoingBytes,
+    WTSIncomingFrames,
+    WTSOutgoingFrames,
+    WTSClientInfo,
+    WTSSessionInfo,
+    WTSSessionInfoEx,
+    WTSConfigInfo,
+    WTSValidationInfo,  // Info Class value used to fetch Validation
+                        // Information through the WTSQuerySessionInformation
+    WTSSessionAddressV4,
+    WTSIsRemoteSession
+} WTS_INFO_CLASS;
+
+typedef enum _WTS_CONNECTSTATE_CLASS {
+    WTSActive,  // User logged on to WinStation
+    WTSConnected,  // WinStation connected to client
+    WTSConnectQuery,  // In the process of connecting to client
+    WTSShadow,  // Shadowing another WinStation
+    WTSDisconnected,  // WinStation logged on without client
+    WTSIdle,  // Waiting for client to connect
+    WTSListen,  // WinStation is listening for connection
+    WTSReset,  // WinStation is being reset
+    WTSDown,  // WinStation is down due to error
+    WTSInit,  // WinStation in initialization
+} WTS_CONNECTSTATE_CLASS;
+
+// ================================================================
+// Structs
+// ================================================================
+
+// cpu_stats(), per_cpu_times()
+typedef struct _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION {
     LARGE_INTEGER IdleTime;
     LARGE_INTEGER KernelTime;
     LARGE_INTEGER UserTime;
     LARGE_INTEGER DpcTime;
     LARGE_INTEGER InterruptTime;
     ULONG InterruptCount;
-} _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
-
+} SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION;
 
-typedef struct {
+// cpu_stats()
+typedef struct _SYSTEM_PERFORMANCE_INFORMATION {
     LARGE_INTEGER IdleProcessTime;
     LARGE_INTEGER IoReadTransferCount;
     LARGE_INTEGER IoWriteTransferCount;
@@ -93,82 +292,95 @@ typedef struct {
     ULONG FirstLevelTbFills;
     ULONG SecondLevelTbFills;
     ULONG SystemCalls;
+} SYSTEM_PERFORMANCE_INFORMATION;
 
-} _SYSTEM_PERFORMANCE_INFORMATION;
-
-
-typedef struct {
+// cpu_stats()
+typedef struct _SYSTEM_INTERRUPT_INFORMATION {
     ULONG ContextSwitches;
     ULONG DpcCount;
     ULONG DpcRate;
     ULONG TimeIncrement;
     ULONG DpcBypassCount;
     ULONG ApcBypassCount;
-} _SYSTEM_INTERRUPT_INFORMATION;
-
-
-typedef enum _KTHREAD_STATE {
-    Initialized,
-    Ready,
-    Running,
-    Standby,
-    Terminated,
-    Waiting,
-    Transition,
-    DeferredReady,
-    GateWait,
-    MaximumThreadState
-} KTHREAD_STATE, *PKTHREAD_STATE;
-
-
-typedef enum _KWAIT_REASON {
-    Executive = 0,
-    FreePage = 1,
-    PageIn = 2,
-    PoolAllocation = 3,
-    DelayExecution = 4,
-    Suspended = 5,
-    UserRequest = 6,
-    WrExecutive = 7,
-    WrFreePage = 8,
-    WrPageIn = 9,
-    WrPoolAllocation = 10,
-    WrDelayExecution = 11,
-    WrSuspended = 12,
-    WrUserRequest = 13,
-    WrEventPair = 14,
-    WrQueue = 15,
-    WrLpcReceive = 16,
-    WrLpcReply = 17,
-    WrVirtualMemory = 18,
-    WrPageOut = 19,
-    WrRendezvous = 20,
-    Spare2 = 21,
-    Spare3 = 22,
-    Spare4 = 23,
-    Spare5 = 24,
-    WrCalloutStack = 25,
-    WrKernel = 26,
-    WrResource = 27,
-    WrPushLock = 28,
-    WrMutex = 29,
-    WrQuantumEnd = 30,
-    WrDispatchInt = 31,
-    WrPreempted = 32,
-    WrYieldExecution = 33,
-    WrFastMutex = 34,
-    WrGuardedMutex = 35,
-    WrRundown = 36,
-    MaximumWaitReason = 37
-} KWAIT_REASON, *PKWAIT_REASON;
-
+} SYSTEM_INTERRUPT_INFORMATION;
+
+// Process.open_files()
+typedef struct _OBJECT_TYPE_INFORMATION {
+    UNICODE_STRING TypeName;
+    ULONG TotalNumberOfObjects;
+    ULONG TotalNumberOfHandles;
+    ULONG TotalPagedPoolUsage;
+    ULONG TotalNonPagedPoolUsage;
+    ULONG TotalNamePoolUsage;
+    ULONG TotalHandleTableUsage;
+    ULONG HighWaterNumberOfObjects;
+    ULONG HighWaterNumberOfHandles;
+    ULONG HighWaterPagedPoolUsage;
+    ULONG HighWaterNonPagedPoolUsage;
+    ULONG HighWaterNamePoolUsage;
+    ULONG HighWaterHandleTableUsage;
+    ULONG InvalidAttributes;
+    GENERIC_MAPPING GenericMapping;
+    ULONG ValidAccessMask;
+    BOOLEAN SecurityRequired;
+    BOOLEAN MaintainHandleCount;
+    UCHAR TypeIndex;  // since Windows 8.1
+    CHAR ReservedByte;
+    ULONG PoolType;
+    ULONG DefaultPagedPoolCharge;
+    ULONG DefaultNonPagedPoolCharge;
+} OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;
+
+typedef struct _OBJECT_TYPES_INFORMATION {
+    ULONG NumberOfTypes;
+} OBJECT_TYPES_INFORMATION, *POBJECT_TYPES_INFORMATION;
+
+typedef struct _FILE_BASIC_INFORMATION {
+    LARGE_INTEGER CreationTime;
+    LARGE_INTEGER LastAccessTime;
+    LARGE_INTEGER LastWriteTime;
+    LARGE_INTEGER ChangeTime;
+    ULONG FileAttributes;
+} FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
+
+typedef struct _FILE_STANDARD_INFORMATION {
+    LARGE_INTEGER AllocationSize;
+    LARGE_INTEGER EndOfFile;
+    ULONG NumberOfLinks;
+    BOOLEAN DeletePending;
+    BOOLEAN Directory;
+} FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
+
+typedef struct _PROCESS_HANDLE_TABLE_ENTRY_INFO {
+    HANDLE HandleValue;
+    SIZE_T HandleCount;
+    SIZE_T PointerCount;
+    ACCESS_MASK GrantedAccess;
+    ULONG ObjectTypeIndex;
+    ULONG HandleAttributes;
+    ULONG Reserved;
+} PROCESS_HANDLE_TABLE_ENTRY_INFO, *PPROCESS_HANDLE_TABLE_ENTRY_INFO;
+
+typedef struct _PROCESS_HANDLE_SNAPSHOT_INFORMATION {
+    ULONG_PTR NumberOfHandles;
+    ULONG_PTR Reserved;
+    PROCESS_HANDLE_TABLE_ENTRY_INFO Handles[1];
+} PROCESS_HANDLE_SNAPSHOT_INFORMATION, *PPROCESS_HANDLE_SNAPSHOT_INFORMATION;
+
+typedef struct _PROCESS_BASIC_INFORMATION {
+    NTSTATUS ExitStatus;
+    PVOID PebBaseAddress;
+    ULONG_PTR AffinityMask;
+    KPRIORITY BasePriority;
+    ULONG_PTR UniqueProcessId;
+    ULONG_PTR InheritedFromUniqueProcessId;
+} PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;
 
 typedef struct _CLIENT_ID {
     HANDLE UniqueProcess;
     HANDLE UniqueThread;
 } CLIENT_ID, *PCLIENT_ID;
 
-
 typedef struct _SYSTEM_THREAD_INFORMATION {
     LARGE_INTEGER KernelTime;
     LARGE_INTEGER UserTime;
@@ -183,94 +395,205 @@ typedef struct _SYSTEM_THREAD_INFORMATION {
     KWAIT_REASON WaitReason;
 } SYSTEM_THREAD_INFORMATION, *PSYSTEM_THREAD_INFORMATION;
 
-
-typedef struct _TEB *PTEB;
-
-
-// private
-typedef struct _SYSTEM_EXTENDED_THREAD_INFORMATION {
-    SYSTEM_THREAD_INFORMATION ThreadInfo;
-    PVOID StackBase;
-    PVOID StackLimit;
-    PVOID Win32StartAddress;
-    PTEB TebBase;
-    ULONG_PTR Reserved2;
-    ULONG_PTR Reserved3;
-    ULONG_PTR Reserved4;
-} SYSTEM_EXTENDED_THREAD_INFORMATION, *PSYSTEM_EXTENDED_THREAD_INFORMATION;
-
-
-typedef struct _SYSTEM_PROCESS_INFORMATION2 {
-    ULONG NextEntryOffset;
-    ULONG NumberOfThreads;
-    LARGE_INTEGER SpareLi1;
-    LARGE_INTEGER SpareLi2;
-    LARGE_INTEGER SpareLi3;
-    LARGE_INTEGER CreateTime;
-    LARGE_INTEGER UserTime;
-    LARGE_INTEGER KernelTime;
+// clang-format off
+typedef struct _SYSTEM_PROCESS_INFORMATION {
+    ULONG NextEntryOffset;                      // The address of the previous item plus the value in the NextEntryOffset member. For the last item in the array, NextEntryOffset is 0.
+    ULONG NumberOfThreads;                      // The NumberOfThreads member contains the number of threads in the process.
+    ULONGLONG WorkingSetPrivateSize;            // The total private memory that a process currently has allocated and is physically resident in memory. // since VISTA
+    ULONG HardFaultCount;                       // The total number of hard faults for data from disk rather than from in-memory pages. // since WIN7
+    ULONG NumberOfThreadsHighWatermark;         // The peak number of threads that were running at any given point in time, indicative of potential performance bottlenecks related to thread management.
+    ULONGLONG CycleTime;                        // The sum of the cycle time of all threads in the process.
+    LARGE_INTEGER CreateTime;                   // Number of 100-nanosecond intervals since the creation time of the process. Not updated during system timezone changes.
+    LARGE_INTEGER UserTime;                     // Number of 100-nanosecond intervals the process has executed in user mode.
+    LARGE_INTEGER KernelTime;                   // Number of 100-nanosecond intervals the process has executed in kernel mode.
+    UNICODE_STRING ImageName;                   // The file name of the executable image.
+    KPRIORITY BasePriority;                     // The starting priority of the process.
+    HANDLE UniqueProcessId;                     // The identifier of the process.
+    HANDLE InheritedFromUniqueProcessId;        // The identifier of the process that created this process. Not updated and incorrectly refers to processes with recycled identifiers.
+    ULONG HandleCount;                          // The current number of open handles used by the process.
+    ULONG SessionId;                            // The identifier of the Remote Desktop Services session under which the specified process is running.
+    ULONG_PTR UniqueProcessKey;                 // since VISTA (requires SystemExtendedProcessInformation)
+    SIZE_T PeakVirtualSize;                     // The peak size, in bytes, of the virtual memory used by the process.
+    SIZE_T VirtualSize;                         // The current size, in bytes, of virtual memory used by the process.
+    ULONG PageFaultCount;                       // The total number of page faults for data that is not currently in memory. The value wraps around to zero on average 24 hours.
+    SIZE_T PeakWorkingSetSize;                  // The peak size, in kilobytes, of the working set of the process.
+    SIZE_T WorkingSetSize;                      // The number of pages visible to the process in physical memory. These pages are resident and available for use without triggering a page fault.
+    SIZE_T QuotaPeakPagedPoolUsage;             // The peak quota charged to the process for pool usage, in bytes.
+    SIZE_T QuotaPagedPoolUsage;                 // The quota charged to the process for paged pool usage, in bytes.
+    SIZE_T QuotaPeakNonPagedPoolUsage;          // The peak quota charged to the process for nonpaged pool usage, in bytes.
+    SIZE_T QuotaNonPagedPoolUsage;              // The current quota charged to the process for nonpaged pool usage.
+    SIZE_T PagefileUsage;                       // The total number of bytes of page file storage in use by the process.
+    SIZE_T PeakPagefileUsage;                   // The maximum number of bytes of page-file storage used by the process.
+    SIZE_T PrivatePageCount;                    // The number of memory pages allocated for the use by the process.
+    LARGE_INTEGER ReadOperationCount;           // The total number of read operations performed.
+    LARGE_INTEGER WriteOperationCount;          // The total number of write operations performed.
+    LARGE_INTEGER OtherOperationCount;          // The total number of I/O operations performed other than read and write operations.
+    LARGE_INTEGER ReadTransferCount;            // The total number of bytes read during a read operation.
+    LARGE_INTEGER WriteTransferCount;           // The total number of bytes written during a write operation.
+    LARGE_INTEGER OtherTransferCount;           // The total number of bytes transferred during operations other than read and write operations.
+    SYSTEM_THREAD_INFORMATION Threads[1];       // This type is not defined in the structure but was added for convenience.
+} SYSTEM_PROCESS_INFORMATION, *PSYSTEM_PROCESS_INFORMATION;
+// clang-format on
+
+// cpu_freq()
+typedef struct _PROCESSOR_POWER_INFORMATION {
+    ULONG Number;
+    ULONG MaxMhz;
+    ULONG CurrentMhz;
+    ULONG MhzLimit;
+    ULONG MaxIdleState;
+    ULONG CurrentIdleState;
+} PROCESSOR_POWER_INFORMATION, *PPROCESSOR_POWER_INFORMATION;
+
+// PEB / cmdline(), cwd(), environ()
+typedef struct _RTL_USER_PROCESS_PARAMETERS {
+    BYTE Reserved1[16];
+    PVOID Reserved2[5];
+    UNICODE_STRING CurrentDirectoryPath;
+    PVOID CurrentDirectoryHandle;
+    UNICODE_STRING DllPath;
+    UNICODE_STRING ImagePathName;
+    UNICODE_STRING CommandLine;
+    LPCWSTR env;
+} RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS;
+
+// users()
+typedef struct _WTS_SESSION_INFOW {
+    DWORD SessionId;
+    LPWSTR pWinStationName;
+    WTS_CONNECTSTATE_CLASS State;
+} WTS_SESSION_INFOW, *PWTS_SESSION_INFOW;
+
+typedef struct _WTS_CLIENT_ADDRESS {
+    DWORD AddressFamily;  // AF_INET, AF_INET6, AF_IPX, AF_NETBIOS, AF_UNSPEC
+    BYTE Address[20];  // client network address
+} WTS_CLIENT_ADDRESS, *PWTS_CLIENT_ADDRESS;
+
+typedef struct _WTSINFOW {
+    WTS_CONNECTSTATE_CLASS State;  // connection state (see enum)
+    DWORD SessionId;  // session id
+    DWORD IncomingBytes;
+    DWORD OutgoingBytes;
+    DWORD IncomingFrames;
+    DWORD OutgoingFrames;
+    DWORD IncomingCompressedBytes;
+    DWORD OutgoingCompressedBytes;
+    WCHAR WinStationName[WINSTATIONNAME_LENGTH];
+    WCHAR Domain[DOMAIN_LENGTH];
+    WCHAR UserName[USERNAME_LENGTH + 1];  // name of WinStation this session is
+                                          // connected to
+    LARGE_INTEGER ConnectTime;
+    LARGE_INTEGER DisconnectTime;
+    LARGE_INTEGER LastInputTime;
+    LARGE_INTEGER LogonTime;
+    LARGE_INTEGER CurrentTime;
+} WTSINFOW, *PWTSINFOW;
+
+// memory_uss()
+typedef struct _MEMORY_WORKING_SET_BLOCK {
+    ULONG_PTR Protection: 5;
+    ULONG_PTR ShareCount: 3;
+    ULONG_PTR Shared: 1;
+    ULONG_PTR Node: 3;
+#ifdef _WIN64
+    ULONG_PTR VirtualPage: 52;
+#else
+    ULONG VirtualPage: 20;
+#endif
+} MEMORY_WORKING_SET_BLOCK, *PMEMORY_WORKING_SET_BLOCK;
+
+// memory_uss()
+typedef struct _MEMORY_WORKING_SET_INFORMATION {
+    ULONG_PTR NumberOfEntries;
+    MEMORY_WORKING_SET_BLOCK WorkingSetInfo[1];
+} MEMORY_WORKING_SET_INFORMATION, *PMEMORY_WORKING_SET_INFORMATION;
+
+// memory_uss()
+typedef struct _PSUTIL_PROCESS_WS_COUNTERS {
+    SIZE_T NumberOfPages;
+    SIZE_T NumberOfPrivatePages;
+    SIZE_T NumberOfSharedPages;
+    SIZE_T NumberOfShareablePages;
+} PSUTIL_PROCESS_WS_COUNTERS, *PPSUTIL_PROCESS_WS_COUNTERS;
+
+// exe()
+typedef struct _SYSTEM_PROCESS_ID_INFORMATION {
+    HANDLE ProcessId;
     UNICODE_STRING ImageName;
-    LONG BasePriority;
-    HANDLE UniqueProcessId;
-    HANDLE InheritedFromUniqueProcessId;
-    ULONG HandleCount;
-    ULONG SessionId;
-    ULONG_PTR PageDirectoryBase;
-    SIZE_T PeakVirtualSize;
-    SIZE_T VirtualSize;
-    DWORD PageFaultCount;
-    SIZE_T PeakWorkingSetSize;
-    SIZE_T WorkingSetSize;
-    SIZE_T QuotaPeakPagedPoolUsage;
-    SIZE_T QuotaPagedPoolUsage;
-    SIZE_T QuotaPeakNonPagedPoolUsage;
-    SIZE_T QuotaNonPagedPoolUsage;
-    SIZE_T PagefileUsage;
-    SIZE_T PeakPagefileUsage;
-    SIZE_T PrivatePageCount;
-    LARGE_INTEGER ReadOperationCount;
-    LARGE_INTEGER WriteOperationCount;
-    LARGE_INTEGER OtherOperationCount;
-    LARGE_INTEGER ReadTransferCount;
-    LARGE_INTEGER WriteTransferCount;
-    LARGE_INTEGER OtherTransferCount;
-    SYSTEM_THREAD_INFORMATION Threads[1];
-} SYSTEM_PROCESS_INFORMATION2, *PSYSTEM_PROCESS_INFORMATION2;
-
-#define SYSTEM_PROCESS_INFORMATION SYSTEM_PROCESS_INFORMATION2
-#define PSYSTEM_PROCESS_INFORMATION PSYSTEM_PROCESS_INFORMATION2
-
-
-// ================================================
-// psutil.users() support
-// ================================================
-
-typedef struct _WINSTATION_INFO {
-    BYTE Reserved1[72];
-    ULONG SessionId;
-    BYTE Reserved2[4];
-    FILETIME ConnectTime;
-    FILETIME DisconnectTime;
-    FILETIME LastInputTime;
-    FILETIME LoginTime;
-    BYTE Reserved3[1096];
-    FILETIME CurrentTime;
-} WINSTATION_INFO, *PWINSTATION_INFO;
-
-
-typedef BOOLEAN (WINAPI * PWINSTATIONQUERYINFORMATIONW)
-                 (HANDLE,ULONG,WINSTATIONINFOCLASS,PVOID,ULONG,PULONG);
-
-
-/*
- * NtQueryInformationProcess code taken from
- * http://wj32.wordpress.com/2009/01/24/howto-get-the-command-line-of-processes/
- * typedefs needed to compile against ntdll functions not exposted in the API
- */
-typedef LONG NTSTATUS;
-
-
-typedef NTSTATUS (NTAPI *_NtQueryInformationProcess)(
+} SYSTEM_PROCESS_ID_INFORMATION, *PSYSTEM_PROCESS_ID_INFORMATION;
+
+// boot_time()
+typedef struct _SYSTEM_TIMEOFDAY_INFORMATION {
+    LARGE_INTEGER BootTime;
+    LARGE_INTEGER CurrentTime;
+    LARGE_INTEGER TimeZoneBias;
+    ULONG TimeZoneId;
+    ULONG Reserved;
+    ULONGLONG BootTimeBias;
+    ULONGLONG SleepTimeBias;
+} SYSTEM_TIMEOFDAY_INFORMATION, *PSYSTEM_TIMEOFDAY_INFORMATION;
+
+// ====================================================================
+// PEB structs for cmdline(), cwd(), environ()
+// ====================================================================
+
+#ifdef _WIN64
+typedef struct _PEB {
+    BYTE Reserved1[2];
+    BYTE BeingDebugged;
+    BYTE Reserved2[21];
+    PVOID LoaderData;
+    PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
+    // more fields...
+} PEB;
+
+// When we are a 64 bit process accessing a 32 bit (WoW64)
+// process we need to use the 32 bit structure layout.
+typedef struct _UNICODE_STRING32 {
+    USHORT Length;
+    USHORT MaxLength;
+    DWORD Buffer;
+} UNICODE_STRING32;
+
+typedef struct _RTL_USER_PROCESS_PARAMETERS32 {
+    BYTE Reserved1[16];
+    DWORD Reserved2[5];
+    UNICODE_STRING32 CurrentDirectoryPath;
+    DWORD CurrentDirectoryHandle;
+    UNICODE_STRING32 DllPath;
+    UNICODE_STRING32 ImagePathName;
+    UNICODE_STRING32 CommandLine;
+    DWORD env;
+} RTL_USER_PROCESS_PARAMETERS32;
+
+typedef struct _PEB32 {
+    BYTE Reserved1[2];
+    BYTE BeingDebugged;
+    BYTE Reserved2[1];
+    DWORD Reserved3[2];
+    DWORD Ldr;
+    DWORD ProcessParameters;
+    // more fields...
+} PEB32;
+#else  // ! _WIN64
+typedef struct _PEB {
+    BYTE Reserved1[2];
+    BYTE BeingDebugged;
+    BYTE Reserved2[1];
+    PVOID Reserved3[2];
+    PVOID Ldr;
+    PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
+    // more fields...
+} PEB;
+#endif  // _WIN64
+
+// ================================================================
+// Functions loaded at runtime.
+// ================================================================
+// The pointers live in init.c; psutil_loadlibs() assigns them on
+// module import.
+
+typedef NTSTATUS(NTAPI *_NtQueryInformationProcess)(
     HANDLE ProcessHandle,
     DWORD ProcessInformationClass,
     PVOID ProcessInformation,
@@ -278,67 +601,93 @@ typedef NTSTATUS (NTAPI *_NtQueryInformationProcess)(
     PDWORD ReturnLength
 );
 
+extern _NtQueryInformationProcess NtQueryInformationProcess;
+
+typedef NTSTATUS(NTAPI *_NtQuerySystemInformation)(
+    ULONG SystemInformationClass,
+    PVOID SystemInformation,
+    ULONG SystemInformationLength,
+    PULONG ReturnLength
+);
 
-typedef NTSTATUS (NTAPI *_NtSetInformationProcess)(
+extern _NtQuerySystemInformation NtQuerySystemInformation;
+
+typedef NTSTATUS(NTAPI *_NtSetInformationProcess)(
     HANDLE ProcessHandle,
     DWORD ProcessInformationClass,
     PVOID ProcessInformation,
     DWORD ProcessInformationLength
 );
 
+extern _NtSetInformationProcess NtSetInformationProcess;
 
-typedef enum _PROCESSINFOCLASS2 {
-    _ProcessBasicInformation,
-    ProcessQuotaLimits,
-    ProcessIoCounters,
-    ProcessVmCounters,
-    ProcessTimes,
-    ProcessBasePriority,
-    ProcessRaisePriority,
-    _ProcessDebugPort,
-    ProcessExceptionPort,
-    ProcessAccessToken,
-    ProcessLdtInformation,
-    ProcessLdtSize,
-    ProcessDefaultHardErrorMode,
-    ProcessIoPortHandlers,
-    ProcessPooledUsageAndLimits,
-    ProcessWorkingSetWatch,
-    ProcessUserModeIOPL,
-    ProcessEnableAlignmentFaultFixup,
-    ProcessPriorityClass,
-    ProcessWx86Information,
-    ProcessHandleCount,
-    ProcessAffinityMask,
-    ProcessPriorityBoost,
-    ProcessDeviceMap,
-    ProcessSessionInformation,
-    ProcessForegroundInformation,
-    _ProcessWow64Information,
-    /* added after XP+ */
-    _ProcessImageFileName,
-    ProcessLUIDDeviceMapsEnabled,
-// MSVC 2015 starts forcing C++11 standard, which does not allow duplicate
-// unscoped enumerations.  It doesn't matter that this is C code, MSVC is a C++ compiler.
-#if _MSC_VER < 1900
-    ProcessBreakOnTermination,
-#endif
-    ProcessDebugObjectHandle=ProcessLUIDDeviceMapsEnabled+2,
-    ProcessDebugFlags,
-    ProcessHandleTracing,
-    ProcessIoPriority,
-    ProcessExecuteFlags,
-    ProcessResourceManagement,
-    ProcessCookie,
-    ProcessImageInformation,
-    MaxProcessInfoClass
-} PROCESSINFOCLASS2;
-
-
-#define PROCESSINFOCLASS PROCESSINFOCLASS2
-#define ProcessBasicInformation _ProcessBasicInformation
-#define ProcessWow64Information _ProcessWow64Information
-#define ProcessDebugPort _ProcessDebugPort
-#define ProcessImageFileName _ProcessImageFileName
-
-#endif // __NTEXTAPI_H__
+typedef NTSTATUS(NTAPI *_NtQueryObject)(
+    HANDLE Handle,
+    OBJECT_INFORMATION_CLASS ObjectInformationClass,
+    PVOID ObjectInformation,
+    ULONG ObjectInformationLength,
+    PULONG ReturnLength
+);
+
+extern _NtQueryObject NtQueryObject;
+
+typedef NTSTATUS(NTAPI *_NtQueryVirtualMemory)(
+    HANDLE ProcessHandle,
+    PVOID BaseAddress,
+    int MemoryInformationClass,
+    PVOID MemoryInformation,
+    SIZE_T MemoryInformationLength,
+    PSIZE_T ReturnLength
+);
+
+extern _NtQueryVirtualMemory NtQueryVirtualMemory;
+
+typedef NTSTATUS(WINAPI *_NtResumeProcess)(HANDLE hProcess);
+
+extern _NtResumeProcess NtResumeProcess;
+
+typedef NTSTATUS(WINAPI *_NtSuspendProcess)(HANDLE hProcess);
+
+extern _NtSuspendProcess NtSuspendProcess;
+
+typedef NTSTATUS(WINAPI *_RtlGetVersion)(
+    PRTL_OSVERSIONINFOW lpVersionInformation
+);
+
+extern _RtlGetVersion RtlGetVersion;
+
+typedef ULONG(WINAPI *_RtlNtStatusToDosErrorNoTeb)(NTSTATUS status);
+
+extern _RtlNtStatusToDosErrorNoTeb RtlNtStatusToDosErrorNoTeb;
+
+typedef BOOL(CALLBACK *_WTSQuerySessionInformationW)(
+    HANDLE hServer,
+    DWORD SessionId,
+    WTS_INFO_CLASS WTSInfoClass,
+    LPWSTR *ppBuffer,
+    DWORD *pBytesReturned
+);
+
+extern _WTSQuerySessionInformationW WTSQuerySessionInformationW;
+
+typedef BOOL(CALLBACK *_WTSEnumerateSessionsW)(
+    HANDLE hServer,
+    DWORD Reserved,
+    DWORD Version,
+    PWTS_SESSION_INFOW *ppSessionInfo,
+    DWORD *pCount
+);
+
+extern _WTSEnumerateSessionsW WTSEnumerateSessionsW;
+
+typedef VOID(CALLBACK *_WTSFreeMemory)(PVOID pMemory);
+
+extern _WTSFreeMemory WTSFreeMemory;
+
+// Declared in <ip2string.h>, which can't be included from user-mode
+// code (it expects kernel types we don't have). Exported by ntdll.lib.
+NTSYSAPI PSTR NTAPI RtlIpv4AddressToStringA(struct in_addr *Addr, PSTR S);
+
+NTSYSAPI PSTR NTAPI RtlIpv6AddressToStringA(struct in6_addr *Addr, PSTR P);
+
+#endif  // NTEXTAPI_H
diff --git a/psutil/arch/windows/pids.c b/psutil/arch/windows/pids.c
new file mode 100644
index 0000000000..8101aaeee8
--- /dev/null
+++ b/psutil/arch/windows/pids.c
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <windows.h>
+#include <psapi.h>
+
+#include "../../arch/all/init.h"
+
+
+int
+_psutil_pids(DWORD **pids_array, int *pids_count) {
+    DWORD *proc_array = NULL;
+    DWORD proc_array_bytes;
+    int proc_array_sz = 0;
+    DWORD enum_return_bytes = 0;
+
+    *pids_array = NULL;
+    *pids_count = 0;
+
+    do {
+        proc_array_sz += 1024;
+        if (proc_array != NULL)
+            free(proc_array);
+
+        proc_array_bytes = proc_array_sz * sizeof(DWORD);
+        proc_array = malloc(proc_array_bytes);
+        if (proc_array == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+
+        if (!EnumProcesses(proc_array, proc_array_bytes, &enum_return_bytes)) {
+            free(proc_array);
+            psutil_oserror();
+            return -1;
+        }
+
+        // Retry if our buffer was too small.
+    } while (enum_return_bytes == proc_array_bytes);
+
+    *pids_count = (int)(enum_return_bytes / sizeof(DWORD));
+    *pids_array = proc_array;
+    return 0;
+}
diff --git a/psutil/arch/windows/proc.c b/psutil/arch/windows/proc.c
new file mode 100644
index 0000000000..6790c2d347
--- /dev/null
+++ b/psutil/arch/windows/proc.c
@@ -0,0 +1,1201 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+/*
+ * Process related functions. Original code was moved in here from
+ * psutil/_psutil_windows.c in 2023. For reference, here's the GIT blame
+ * history before the move:
+ * https://github.com/giampaolo/psutil/blame/59504a5/psutil/_psutil_windows.c
+ */
+
+// Fixes clash between winsock2.h and windows.h
+#define WIN32_LEAN_AND_MEAN
+
+#include <Python.h>
+#include <windows.h>
+#include <Psapi.h>  // memory_info(), memory_maps()
+#include <signal.h>
+
+#include "../../arch/all/init.h"
+
+
+// Raised by Process.wait().
+PyObject *TimeoutExpired;
+PyObject *TimeoutAbandoned;
+
+
+// Return 1 if PID exists in the current process list, else 0.
+PyObject *
+psutil_pid_exists(PyObject *self, PyObject *args) {
+    DWORD pid;
+    int status;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    status = psutil_pid_is_running(pid);
+    if (-1 == status)
+        return NULL;  // exception raised in psutil_pid_is_running()
+    return PyBool_FromLong(status);
+}
+
+
+// Get various process info by using NtQuerySystemInformation. We use
+// this as a fallback when faster functions fail with access denied.
+// This is slower because it iterates over all processes.
+PyObject *
+psutil_proc_oneshot(PyObject *self, PyObject *args) {
+    DWORD pid;
+    PSYSTEM_PROCESS_INFORMATION proc;
+    PVOID buffer = NULL;
+    ULONG i;
+    ULONG ctx_switches = 0;
+    int suspended = 1;  // a process with no threads counts as suspended
+    double user_time;
+    double kernel_time;
+    double create_time;
+    PyObject *dict = PyDict_New();
+
+    if (!dict)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+    if (psutil_proc_table_entry(pid, &proc, &buffer) != 0)
+        goto error;
+
+    for (i = 0; i < proc->NumberOfThreads; i++) {
+        ctx_switches += proc->Threads[i].ContextSwitches;
+        if (proc->Threads[i].ThreadState != Waiting
+            || proc->Threads[i].WaitReason != Suspended)
+        {
+            suspended = 0;
+        }
+    }
+
+    user_time = (double)proc->UserTime.HighPart * HI_T
+                + (double)proc->UserTime.LowPart * LO_T;
+    kernel_time = (double)proc->KernelTime.HighPart * HI_T
+                  + (double)proc->KernelTime.LowPart * LO_T;
+
+    // Convert the LARGE_INTEGER union to a Unix time.
+    // It's the best I could find by googling and borrowing code here
+    // and there. The time returned has a precision of 1 second.
+    if (0 == pid || 4 == pid) {
+        // the python module will translate this into BOOT_TIME later
+        create_time = 0;
+    }
+    else {
+        create_time = psutil_LargeIntegerToUnixTime(proc->CreateTime);
+    }
+
+    // clang-format off
+    if (!pydict_add(dict, "num_handles", "k", proc->HandleCount)) goto error;
+    if (!pydict_add(dict, "ctx_switches", "k", ctx_switches)) goto error;
+    if (!pydict_add(dict, "is_suspended", "i", suspended)) goto error;
+    if (!pydict_add(dict, "user_time", "d", user_time)) goto error;
+    if (!pydict_add(dict, "kernel_time", "d", kernel_time)) goto error;
+    if (!pydict_add(dict, "create_time", "d", create_time)) goto error;
+    if (!pydict_add(dict, "num_threads", "k", proc->NumberOfThreads)) goto error;
+    // I/O
+    if (!pydict_add(dict, "io_rcount", "K", proc->ReadOperationCount.QuadPart)) goto error;
+    if (!pydict_add(dict, "io_wcount", "K", proc->WriteOperationCount.QuadPart)) goto error;
+    if (!pydict_add(dict, "io_rbytes", "K", proc->ReadTransferCount.QuadPart)) goto error;
+    if (!pydict_add(dict, "io_wbytes", "K", proc->WriteTransferCount.QuadPart)) goto error;
+    if (!pydict_add(dict, "io_count_others", "K", proc->OtherOperationCount.QuadPart)) goto error;
+    if (!pydict_add(dict, "io_bytes_others", "K", proc->OtherTransferCount.QuadPart)) goto error;
+    // proc memory
+    if (!pydict_add(dict, "PageFaultCount", "K", (ULONGLONG)proc->PageFaultCount)) goto error;
+    if (!pydict_add(dict, "HardFaultCount", "K", (ULONGLONG)proc->HardFaultCount)) goto error;
+    if (!pydict_add(dict, "PeakWorkingSetSize", "K", (ULONGLONG)proc->PeakWorkingSetSize)) goto error;
+    if (!pydict_add(dict, "WorkingSetSize", "K", (ULONGLONG)proc->WorkingSetSize)) goto error;
+    if (!pydict_add(dict, "QuotaPeakPagedPoolUsage", "K", (ULONGLONG)proc->QuotaPeakPagedPoolUsage)) goto error;
+    if (!pydict_add(dict, "QuotaPagedPoolUsage", "K", (ULONGLONG)proc->QuotaPagedPoolUsage)) goto error;
+    if (!pydict_add(dict, "QuotaPeakNonPagedPoolUsage", "K", (ULONGLONG)proc->QuotaPeakNonPagedPoolUsage)) goto error;
+    if (!pydict_add(dict, "QuotaNonPagedPoolUsage", "K", (ULONGLONG)proc->QuotaNonPagedPoolUsage)) goto error;
+    if (!pydict_add(dict, "PagefileUsage", "K", (ULONGLONG)proc->PagefileUsage)) goto error;
+    if (!pydict_add(dict, "PeakPagefileUsage", "K", (ULONGLONG)proc->PeakPagefileUsage)) goto error;
+    if (!pydict_add(dict, "PrivatePageCount", "K", (ULONGLONG)proc->PrivatePageCount)) goto error;
+    if (!pydict_add(dict, "VirtualSize", "K", (ULONGLONG)proc->VirtualSize)) goto error;
+    if (!pydict_add(dict, "PeakVirtualSize", "K", (ULONGLONG)proc->PeakVirtualSize)) goto error;
+    // clang-format on
+
+    free(buffer);
+    return dict;
+
+error:
+    if (buffer != NULL)
+        free(buffer);
+    Py_DECREF(dict);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_kill(PyObject *self, PyObject *args) {
+    HANDLE hProcess;
+    DWORD pid;
+    DWORD access = PROCESS_TERMINATE | PROCESS_QUERY_LIMITED_INFORMATION;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if (pid == 0)
+        return psutil_oserror_ad("automatically set for PID 0");
+
+    hProcess = psutil_handle_from_pid(pid, access);
+    if (hProcess == NULL) {
+        return NULL;
+    }
+
+    if (!TerminateProcess(hProcess, SIGTERM)) {
+        // ERROR_ACCESS_DENIED may happen if the process already died. See:
+        // https://github.com/giampaolo/psutil/issues/1099
+        // http://bugs.python.org/issue14252
+        if (GetLastError() != ERROR_ACCESS_DENIED) {
+            psutil_oserror_wsyscall("TerminateProcess");
+            CloseHandle(hProcess);
+            return NULL;
+        }
+    }
+
+    CloseHandle(hProcess);
+    Py_RETURN_NONE;
+}
+
+
+PyObject *
+psutil_proc_wait(PyObject *self, PyObject *args) {
+    HANDLE hProcess;
+    DWORD ExitCode;
+    DWORD retVal;
+    DWORD pid;
+    long timeout;
+    int running;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "l", &pid, &timeout))
+        return NULL;
+    if (pid == 0)
+        return psutil_oserror_ad("automatically set for PID 0");
+
+    hProcess = OpenProcess(
+        SYNCHRONIZE | PROCESS_QUERY_INFORMATION, FALSE, pid
+    );
+    if (hProcess == NULL) {
+        if (GetLastError() == ERROR_INVALID_PARAMETER) {
+            // no such process; we do not want to raise NSP but
+            // return None instead.
+            Py_RETURN_NONE;
+        }
+        if (GetLastError() == ERROR_SUCCESS) {
+            // Yeah, it's this bad, see:
+            // https://github.com/giampaolo/psutil/issues/1877
+            running = psutil_pid_is_running(pid);
+            if (running == 0) {
+                psutil_debug("OpenProcess -> ERROR_SUCCESS turned into None");
+                Py_RETURN_NONE;
+            }
+            if (running == 1)
+                return psutil_oserror_ad("OpenProcess -> ERROR_SUCCESS");
+            return NULL;
+        }
+        psutil_oserror_wsyscall("OpenProcess");
+        return NULL;
+    }
+
+    // wait until the process has terminated
+    Py_BEGIN_ALLOW_THREADS
+    retVal = WaitForSingleObject(hProcess, timeout);
+    Py_END_ALLOW_THREADS
+
+    // handle return code
+    if (retVal == WAIT_FAILED) {
+        psutil_oserror_wsyscall("WaitForSingleObject");
+        CloseHandle(hProcess);
+        return NULL;
+    }
+    if (retVal == WAIT_TIMEOUT) {
+        PyErr_SetString(
+            TimeoutExpired, "WaitForSingleObject() returned WAIT_TIMEOUT"
+        );
+        CloseHandle(hProcess);
+        return NULL;
+    }
+    if (retVal == WAIT_ABANDONED) {
+        psutil_debug("WaitForSingleObject() -> WAIT_ABANDONED");
+        PyErr_SetString(
+            TimeoutAbandoned, "WaitForSingleObject() returned WAIT_ABANDONED"
+        );
+        CloseHandle(hProcess);
+        return NULL;
+    }
+
+    // WaitForSingleObject() returned WAIT_OBJECT_0. It means the
+    // process is gone so we can get its process exit code. The PID
+    // may still stick around though but we'll handle that from Python.
+    if (GetExitCodeProcess(hProcess, &ExitCode) == 0) {
+        psutil_oserror_wsyscall("GetExitCodeProcess");
+        CloseHandle(hProcess);
+        return NULL;
+    }
+
+    CloseHandle(hProcess);
+
+    return PyLong_FromLong((long)ExitCode);
+}
+
+
+// Return (user_time, kernel_time, create_time).
+PyObject *
+psutil_proc_times(PyObject *self, PyObject *args) {
+    DWORD pid;
+    HANDLE hProcess;
+    FILETIME ftCreate, ftExit, ftKernel, ftUser;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_LIMITED_INFORMATION);
+
+    if (hProcess == NULL)
+        return NULL;
+    if (!GetProcessTimes(hProcess, &ftCreate, &ftExit, &ftKernel, &ftUser)) {
+        if (GetLastError() == ERROR_ACCESS_DENIED) {
+            // usually means the process has died so we throw a NoSuchProcess
+            // here
+            psutil_oserror_nsp("GetProcessTimes -> ERROR_ACCESS_DENIED");
+        }
+        else {
+            psutil_oserror();
+        }
+        CloseHandle(hProcess);
+        return NULL;
+    }
+
+    CloseHandle(hProcess);
+
+    /*
+     * User and kernel times are represented as a FILETIME structure
+     * which contains a 64-bit value representing the number of
+     * 100-nanosecond intervals since January 1, 1601 (UTC):
+     * http://msdn.microsoft.com/en-us/library/ms724284(VS.85).aspx
+     * To convert it into a float representing the seconds that the
+     * process has executed in user/kernel mode I borrowed the code
+     * below from Python's Modules/posixmodule.c
+     */
+    return Py_BuildValue(
+        "(ddd)",
+        (double)(ftUser.dwHighDateTime * HI_T + ftUser.dwLowDateTime * LO_T),
+        (double)(ftKernel.dwHighDateTime * HI_T + ftKernel.dwLowDateTime * LO_T
+        ),
+        psutil_FiletimeToUnixTime(ftCreate)
+    );
+}
+
+
+// Return process executable path. Works for all processes regardless
+// of privilege. NtQuerySystemInformation has some sort of internal
+// cache, since it succeeds even when a process is gone (but not if a
+// PID never existed).
+PyObject *
+psutil_proc_exe(PyObject *self, PyObject *args) {
+    DWORD pid;
+    NTSTATUS status;
+    PVOID buffer = NULL;
+    ULONG bufferSize = 0x104 * 2;  // WIN_MAX_PATH * sizeof(wchar_t)
+    SYSTEM_PROCESS_ID_INFORMATION processIdInfo;
+    PyObject *py_exe;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    if (pid == 0)
+        return psutil_oserror_ad("automatically set for PID 0");
+
+    // ...because NtQuerySystemInformation can succeed for terminated
+    // processes.
+    if (psutil_check_pid_running(pid) != 0)
+        return NULL;
+
+    buffer = MALLOC_ZERO(bufferSize);
+    if (!buffer) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+
+    processIdInfo.ProcessId = (HANDLE)(ULONG_PTR)pid;
+    processIdInfo.ImageName.Length = 0;
+    processIdInfo.ImageName.MaximumLength = (USHORT)bufferSize;
+    processIdInfo.ImageName.Buffer = buffer;
+
+    status = NtQuerySystemInformation(
+        SystemProcessIdInformation,
+        &processIdInfo,
+        sizeof(SYSTEM_PROCESS_ID_INFORMATION),
+        NULL
+    );
+
+    if ((status == STATUS_INFO_LENGTH_MISMATCH)
+        && (processIdInfo.ImageName.MaximumLength <= bufferSize))
+    {
+        // Required length was NOT stored in MaximumLength (WOW64 issue).
+        ULONG maxBufferSize = 0x7FFF * 2;  // NTFS_MAX_PATH * sizeof(wchar_t)
+        do {
+            // Iteratively double the size of the buffer up to maxBufferSize.
+            // Cap it, or the USHORT MaximumLength would overflow.
+            bufferSize *= 2;
+            if (bufferSize > maxBufferSize)
+                bufferSize = maxBufferSize;
+            FREE(buffer);
+            buffer = MALLOC_ZERO(bufferSize);
+            if (!buffer) {
+                PyErr_NoMemory();
+                return NULL;
+            }
+
+            processIdInfo.ImageName.MaximumLength = (USHORT)bufferSize;
+            processIdInfo.ImageName.Buffer = buffer;
+
+            status = NtQuerySystemInformation(
+                SystemProcessIdInformation,
+                &processIdInfo,
+                sizeof(SYSTEM_PROCESS_ID_INFORMATION),
+                NULL
+            );
+        } while ((status == STATUS_INFO_LENGTH_MISMATCH)
+                 && (bufferSize < maxBufferSize));
+    }
+    else if (status == STATUS_INFO_LENGTH_MISMATCH) {
+        // Required length is stored in MaximumLength.
+        FREE(buffer);
+        buffer = MALLOC_ZERO(processIdInfo.ImageName.MaximumLength);
+        if (!buffer) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+
+        processIdInfo.ImageName.Buffer = buffer;
+
+        status = NtQuerySystemInformation(
+            SystemProcessIdInformation,
+            &processIdInfo,
+            sizeof(SYSTEM_PROCESS_ID_INFORMATION),
+            NULL
+        );
+    }
+
+    if (!NT_SUCCESS(status)) {
+        FREE(buffer);
+        return psutil_raise_for_nt_status(
+            pid, status, "NtQuerySystemInformation(SystemProcessIdInformation)"
+        );
+    }
+
+    if (processIdInfo.ImageName.Buffer == NULL) {
+        // Happens for PID 4.
+        py_exe = PyUnicode_FromString("");
+    }
+    else {
+        py_exe = PyUnicode_FromWideChar(
+            processIdInfo.ImageName.Buffer, processIdInfo.ImageName.Length / 2
+        );
+    }
+    FREE(buffer);
+    return py_exe;
+}
+
+
+PyObject *
+psutil_proc_memory_info(PyObject *self, PyObject *args) {
+    HANDLE hProcess;
+    DWORD pid;
+    PROCESS_MEMORY_COUNTERS_EX cnt;
+    PyObject *dict = PyDict_New();
+
+    if (!dict)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_LIMITED_INFORMATION);
+    if (NULL == hProcess)
+        goto error;
+
+    if (!GetProcessMemoryInfo(
+            hProcess, (PPROCESS_MEMORY_COUNTERS)&cnt, sizeof(cnt)
+        ))
+    {
+        psutil_oserror();
+        CloseHandle(hProcess);
+        goto error;
+    }
+    CloseHandle(hProcess);
+
+    // clang-format off
+    if (!pydict_add(dict, "PageFaultCount", "K", (ULONGLONG)cnt.PageFaultCount)) goto error;
+    if (!pydict_add(dict, "PeakWorkingSetSize", "K", (ULONGLONG)cnt.PeakWorkingSetSize)) goto error;
+    if (!pydict_add(dict, "WorkingSetSize", "K", (ULONGLONG)cnt.WorkingSetSize)) goto error;
+    if (!pydict_add(dict, "QuotaPeakPagedPoolUsage", "K", (ULONGLONG)cnt.QuotaPeakPagedPoolUsage)) goto error;
+    if (!pydict_add(dict, "QuotaPagedPoolUsage", "K", (ULONGLONG)cnt.QuotaPagedPoolUsage)) goto error;
+    if (!pydict_add(dict, "QuotaPeakNonPagedPoolUsage", "K", (ULONGLONG)cnt.QuotaPeakNonPagedPoolUsage)) goto error;
+    if (!pydict_add(dict, "QuotaNonPagedPoolUsage", "K", (ULONGLONG)cnt.QuotaNonPagedPoolUsage)) goto error;
+    if (!pydict_add(dict, "PagefileUsage", "K", (ULONGLONG)cnt.PagefileUsage)) goto error;
+    if (!pydict_add(dict, "PeakPagefileUsage", "K", (ULONGLONG)cnt.PeakPagefileUsage)) goto error;
+    if (!pydict_add(dict, "PrivateUsage", "K", (ULONGLONG)cnt.PrivateUsage)) goto error;
+    // clang-format on
+    return dict;
+
+error:
+    Py_DECREF(dict);
+    return NULL;
+}
+
+
+static int
+psutil_GetProcWsetInformation(
+    DWORD pid, HANDLE hProcess, PMEMORY_WORKING_SET_INFORMATION *wSetInfo
+) {
+    NTSTATUS status;
+    PVOID buffer;
+    SIZE_T bufferSize;
+
+    bufferSize = 0x8000;
+    buffer = MALLOC_ZERO(bufferSize);
+    if (!buffer) {
+        PyErr_NoMemory();
+        return -1;
+    }
+
+    while ((status = NtQueryVirtualMemory(
+                hProcess,
+                NULL,
+                MemoryWorkingSetInformation,
+                buffer,
+                bufferSize,
+                NULL
+            ))
+           == STATUS_INFO_LENGTH_MISMATCH)
+    {
+        FREE(buffer);
+        bufferSize *= 2;
+        // Fail if we're resizing the buffer to something very large.
+        if (bufferSize > 256 * 1024 * 1024) {
+            psutil_runtime_error("NtQueryVirtualMemory bufsize is too large");
+            return -1;
+        }
+        buffer = MALLOC_ZERO(bufferSize);
+        if (!buffer) {
+            PyErr_NoMemory();
+            return -1;
+        }
+    }
+
+    if (!NT_SUCCESS(status)) {
+        if (status == STATUS_ACCESS_DENIED) {
+            psutil_oserror_ad("NtQueryVirtualMemory -> STATUS_ACCESS_DENIED");
+        }
+        else {
+            psutil_raise_for_nt_status(
+                pid,
+                status,
+                "NtQueryVirtualMemory(MemoryWorkingSetInformation)"
+            );
+        }
+        FREE(buffer);
+        return -1;
+    }
+
+    *wSetInfo = (PMEMORY_WORKING_SET_INFORMATION)buffer;
+    return 0;
+}
+
+
+// Returns the USS of the process.
+// Reference:
+// https://dxr.mozilla.org/mozilla-central/source/xpcom/base/nsMemoryReporterManager.cpp
+PyObject *
+psutil_proc_memory_uss(PyObject *self, PyObject *args) {
+    DWORD pid;
+    HANDLE hProcess;
+    PSUTIL_PROCESS_WS_COUNTERS wsCounters;
+    PMEMORY_WORKING_SET_INFORMATION wsInfo;
+    ULONG_PTR i;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_INFORMATION);
+    if (hProcess == NULL)
+        return NULL;
+
+    if (psutil_GetProcWsetInformation(pid, hProcess, &wsInfo) != 0) {
+        CloseHandle(hProcess);
+        return NULL;
+    }
+    memset(&wsCounters, 0, sizeof(PSUTIL_PROCESS_WS_COUNTERS));
+
+    for (i = 0; i < wsInfo->NumberOfEntries; i++) {
+        // This is what ProcessHacker does.
+        /*
+        wsCounters.NumberOfPages++;
+        if (wsInfo->WorkingSetInfo[i].ShareCount > 1)
+            wsCounters.NumberOfSharedPages++;
+        if (wsInfo->WorkingSetInfo[i].ShareCount == 0)
+            wsCounters.NumberOfPrivatePages++;
+        if (wsInfo->WorkingSetInfo[i].Shared)
+            wsCounters.NumberOfShareablePages++;
+        */
+
+        // This is what we do: count shared pages that only one process
+        // is using as private (USS).
+        if (!wsInfo->WorkingSetInfo[i].Shared
+            || wsInfo->WorkingSetInfo[i].ShareCount <= 1)
+        {
+            wsCounters.NumberOfPrivatePages++;
+        }
+    }
+
+    FREE(wsInfo);
+    CloseHandle(hProcess);
+
+    return Py_BuildValue("I", wsCounters.NumberOfPrivatePages);
+}
+
+
+// Resume or suspends a process.
+PyObject *
+psutil_proc_suspend_or_resume(PyObject *self, PyObject *args) {
+    DWORD pid;
+    NTSTATUS status;
+    HANDLE hProcess;
+    DWORD access = PROCESS_SUSPEND_RESUME | PROCESS_QUERY_LIMITED_INFORMATION;
+    int suspend;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "p", &pid, &suspend))
+        return NULL;
+
+    hProcess = psutil_handle_from_pid(pid, access);
+    if (hProcess == NULL)
+        return NULL;
+
+    if (suspend)
+        status = NtSuspendProcess(hProcess);
+    else
+        status = NtResumeProcess(hProcess);
+
+    if (!NT_SUCCESS(status)) {
+        CloseHandle(hProcess);
+        return psutil_SetFromNTStatusErr(status, "NtSuspend|ResumeProcess");
+    }
+
+    CloseHandle(hProcess);
+    Py_RETURN_NONE;
+}
+
+
+PyObject *
+psutil_proc_threads(PyObject *self, PyObject *args) {
+    DWORD pid;
+    ULONG i;
+    PSYSTEM_PROCESS_INFORMATION process;
+    PVOID buffer;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+    if (psutil_proc_table_entry(pid, &process, &buffer) != 0)
+        goto error;
+
+    for (i = 0; i < process->NumberOfThreads; i++) {
+        SYSTEM_THREAD_INFORMATION *thread = &process->Threads[i];
+
+        // Times count 100-nanosecond intervals, turn them into secs.
+        if (!pylist_append_fmt(
+                py_retlist,
+                "kdd",
+                (DWORD)(ULONG_PTR)thread->ClientId.UniqueThread,
+                (double)thread->UserTime.HighPart * HI_T
+                    + (double)thread->UserTime.LowPart * LO_T,
+                (double)thread->KernelTime.HighPart * HI_T
+                    + (double)thread->KernelTime.LowPart * LO_T
+            ))
+        {
+            free(buffer);
+            goto error;
+        }
+    }
+
+    free(buffer);
+    return py_retlist;
+
+error:
+    Py_DECREF(py_retlist);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_open_files(PyObject *self, PyObject *args) {
+    DWORD pid;
+    HANDLE processHandle;
+    DWORD access = PROCESS_DUP_HANDLE | PROCESS_QUERY_INFORMATION;
+    PyObject *py_retlist;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    processHandle = psutil_handle_from_pid(pid, access);
+    if (processHandle == NULL)
+        return NULL;
+
+    py_retlist = psutil_get_open_files(processHandle);
+    CloseHandle(processHandle);
+    return py_retlist;
+}
+
+
+static PTOKEN_USER
+user_token_from_pid(DWORD pid) {
+    HANDLE hProcess = NULL;
+    HANDLE hToken = NULL;
+    PTOKEN_USER userToken = NULL;
+    ULONG bufferSize = 0x100;
+
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_LIMITED_INFORMATION);
+    if (hProcess == NULL)
+        return NULL;
+
+    if (!OpenProcessToken(hProcess, TOKEN_QUERY, &hToken)) {
+        psutil_oserror_wsyscall("OpenProcessToken");
+        goto error;
+    }
+
+    // Get the user SID.
+    while (1) {
+        userToken = malloc(bufferSize);
+        if (userToken == NULL) {
+            PyErr_NoMemory();
+            goto error;
+        }
+        if (!GetTokenInformation(
+                hToken, TokenUser, userToken, bufferSize, &bufferSize
+            ))
+        {
+            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+                free(userToken);
+                userToken = NULL;
+                continue;
+            }
+            else {
+                psutil_oserror_wsyscall("GetTokenInformation");
+                goto error;
+            }
+        }
+        break;
+    }
+
+    CloseHandle(hProcess);
+    CloseHandle(hToken);
+    return userToken;
+
+error:
+    if (userToken != NULL)
+        free(userToken);
+    if (hProcess != NULL)
+        CloseHandle(hProcess);
+    if (hToken != NULL)
+        CloseHandle(hToken);
+    return NULL;
+}
+
+
+// Return process username as a "DOMAIN//USERNAME" string.
+PyObject *
+psutil_proc_username(PyObject *self, PyObject *args) {
+    DWORD pid;
+    PTOKEN_USER userToken = NULL;
+    WCHAR *userName = NULL;
+    WCHAR *domainName = NULL;
+    ULONG nameSize = 0x100;
+    ULONG domainNameSize = 0x100;
+    SID_NAME_USE nameUse;
+    BOOL ok;
+    PyObject *py_username = NULL;
+    PyObject *py_domain = NULL;
+    PyObject *py_tuple = NULL;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    userToken = user_token_from_pid(pid);
+    if (userToken == NULL)
+        return NULL;
+
+    // resolve the SID to a name
+    while (1) {
+        userName = malloc(nameSize * sizeof(WCHAR));
+        if (userName == NULL) {
+            PyErr_NoMemory();
+            goto error;
+        }
+        domainName = malloc(domainNameSize * sizeof(WCHAR));
+        if (domainName == NULL) {
+            PyErr_NoMemory();
+            goto error;
+        }
+        // On a domain member this may go over the wire to a domain
+        // controller, so do it without the GIL.
+        Py_BEGIN_ALLOW_THREADS
+        ok = LookupAccountSidW(
+            NULL,
+            userToken->User.Sid,
+            userName,
+            &nameSize,
+            domainName,
+            &domainNameSize,
+            &nameUse
+        );
+        Py_END_ALLOW_THREADS
+
+        if (!ok) {
+            if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
+                free(userName);
+                free(domainName);
+                // otherwise a failed malloc() on the next iteration
+                // would goto error and free() them again
+                userName = NULL;
+                domainName = NULL;
+                continue;
+            }
+            else if (GetLastError() == ERROR_NONE_MAPPED) {
+                // From MS doc:
+                // https://learn.microsoft.com/en-us/windows/win32/api/winbase/nf-winbase-lookupaccountsida
+                // If the function cannot find an account name for the SID,
+                // GetLastError returns ERROR_NONE_MAPPED. This can occur if
+                // a network time-out prevents the function from finding the
+                // name. It also occurs for SIDs that have no corresponding
+                // account name, such as a logon SID that identifies a logon
+                // session.
+                psutil_oserror_ad("LookupAccountSidW -> ERROR_NONE_MAPPED");
+                goto error;
+            }
+            else {
+                psutil_oserror_wsyscall("LookupAccountSidW");
+                goto error;
+            }
+        }
+        break;
+    }
+
+    py_domain = PyUnicode_FromWideChar(domainName, wcslen(domainName));
+    if (!py_domain)
+        goto error;
+    py_username = PyUnicode_FromWideChar(userName, wcslen(userName));
+    if (!py_username)
+        goto error;
+    py_tuple = Py_BuildValue("OO", py_domain, py_username);
+    if (!py_tuple)
+        goto error;
+    Py_DECREF(py_domain);
+    Py_DECREF(py_username);
+
+    free(userName);
+    free(domainName);
+    free(userToken);
+    return py_tuple;
+
+error:
+    if (userName != NULL)
+        free(userName);
+    if (domainName != NULL)
+        free(domainName);
+    if (userToken != NULL)
+        free(userToken);
+    Py_XDECREF(py_domain);
+    Py_XDECREF(py_username);
+    Py_XDECREF(py_tuple);
+    return NULL;
+}
+
+
+// Get process priority as a Python integer.
+PyObject *
+psutil_proc_priority_get(PyObject *self, PyObject *args) {
+    DWORD pid;
+    DWORD priority;
+    HANDLE hProcess;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_LIMITED_INFORMATION);
+    if (hProcess == NULL)
+        return NULL;
+
+    priority = GetPriorityClass(hProcess);
+    if (priority == 0) {
+        psutil_oserror();
+        CloseHandle(hProcess);
+        return NULL;
+    }
+    CloseHandle(hProcess);
+    return Py_BuildValue("i", priority);
+}
+
+
+// Set process priority.
+PyObject *
+psutil_proc_priority_set(PyObject *self, PyObject *args) {
+    DWORD pid;
+    int priority;
+    int retval;
+    HANDLE hProcess;
+    DWORD access = PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i", &pid, &priority))
+        return NULL;
+    hProcess = psutil_handle_from_pid(pid, access);
+    if (hProcess == NULL)
+        return NULL;
+
+    retval = SetPriorityClass(hProcess, priority);
+    if (retval == 0) {
+        psutil_oserror();
+        CloseHandle(hProcess);
+        return NULL;
+    }
+
+    CloseHandle(hProcess);
+    Py_RETURN_NONE;
+}
+
+
+PyObject *
+psutil_proc_io_priority_get(PyObject *self, PyObject *args) {
+    DWORD pid;
+    HANDLE hProcess;
+    DWORD IoPriority;
+    NTSTATUS status;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_LIMITED_INFORMATION);
+    if (hProcess == NULL)
+        return NULL;
+
+    status = NtQueryInformationProcess(
+        hProcess, ProcessIoPriority, &IoPriority, sizeof(DWORD), NULL
+    );
+
+    CloseHandle(hProcess);
+    if (!NT_SUCCESS(status))
+        return psutil_SetFromNTStatusErr(status, "NtQueryInformationProcess");
+    return Py_BuildValue("i", IoPriority);
+}
+
+
+PyObject *
+psutil_proc_io_priority_set(PyObject *self, PyObject *args) {
+    DWORD pid;
+    DWORD prio;
+    HANDLE hProcess;
+    NTSTATUS status;
+    DWORD access = PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "i", &pid, &prio))
+        return NULL;
+
+    hProcess = psutil_handle_from_pid(pid, access);
+    if (hProcess == NULL)
+        return NULL;
+
+    status = NtSetInformationProcess(
+        hProcess, ProcessIoPriority, (PVOID)&prio, sizeof(DWORD)
+    );
+
+    CloseHandle(hProcess);
+    if (!NT_SUCCESS(status))
+        return psutil_SetFromNTStatusErr(status, "NtSetInformationProcess");
+    Py_RETURN_NONE;
+}
+
+
+PyObject *
+psutil_proc_io_counters(PyObject *self, PyObject *args) {
+    DWORD pid;
+    HANDLE hProcess;
+    IO_COUNTERS IoCounters;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_LIMITED_INFORMATION);
+    if (NULL == hProcess)
+        return NULL;
+
+    if (!GetProcessIoCounters(hProcess, &IoCounters)) {
+        psutil_oserror();
+        CloseHandle(hProcess);
+        return NULL;
+    }
+
+    CloseHandle(hProcess);
+    return Py_BuildValue(
+        "(KKKKKK)",
+        IoCounters.ReadOperationCount,
+        IoCounters.WriteOperationCount,
+        IoCounters.ReadTransferCount,
+        IoCounters.WriteTransferCount,
+        IoCounters.OtherOperationCount,
+        IoCounters.OtherTransferCount
+    );
+}
+
+
+// Return process CPU affinity as a bitmask.
+PyObject *
+psutil_proc_cpu_affinity_get(PyObject *self, PyObject *args) {
+    DWORD pid;
+    HANDLE hProcess;
+    DWORD_PTR proc_mask;
+    DWORD_PTR system_mask;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_LIMITED_INFORMATION);
+    if (hProcess == NULL) {
+        return NULL;
+    }
+    if (GetProcessAffinityMask(hProcess, &proc_mask, &system_mask) == 0) {
+        psutil_oserror();
+        CloseHandle(hProcess);
+        return NULL;
+    }
+
+    CloseHandle(hProcess);
+    return Py_BuildValue("K", (unsigned long long)proc_mask);
+}
+
+
+PyObject *
+psutil_proc_cpu_affinity_set(PyObject *self, PyObject *args) {
+    DWORD pid;
+    HANDLE hProcess;
+    DWORD access = PROCESS_QUERY_INFORMATION | PROCESS_SET_INFORMATION;
+    DWORD_PTR mask;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID "K", &pid, &mask))
+        return NULL;
+    hProcess = psutil_handle_from_pid(pid, access);
+    if (hProcess == NULL)
+        return NULL;
+
+    if (SetProcessAffinityMask(hProcess, mask) == 0) {
+        psutil_oserror();
+        CloseHandle(hProcess);
+        return NULL;
+    }
+
+    CloseHandle(hProcess);
+    Py_RETURN_NONE;
+}
+
+
+PyObject *
+psutil_proc_num_handles(PyObject *self, PyObject *args) {
+    DWORD pid;
+    HANDLE hProcess;
+    DWORD handleCount;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_LIMITED_INFORMATION);
+    if (NULL == hProcess)
+        return NULL;
+    if (!GetProcessHandleCount(hProcess, &handleCount)) {
+        psutil_oserror();
+        CloseHandle(hProcess);
+        return NULL;
+    }
+    CloseHandle(hProcess);
+    return Py_BuildValue("k", handleCount);
+}
+
+
+static char *
+get_region_protection_string(ULONG protection) {
+    switch (protection & 0xff) {
+        case PAGE_NOACCESS:
+            return "";
+        case PAGE_READONLY:
+            return "r";
+        case PAGE_READWRITE:
+            return "rw";
+        case PAGE_WRITECOPY:
+            return "wc";
+        case PAGE_EXECUTE:
+            return "x";
+        case PAGE_EXECUTE_READ:
+            return "xr";
+        case PAGE_EXECUTE_READWRITE:
+            return "xrw";
+        case PAGE_EXECUTE_WRITECOPY:
+            return "xwc";
+        default:
+            return "?";
+    }
+}
+
+
+PyObject *
+psutil_proc_memory_maps(PyObject *self, PyObject *args) {
+    MEMORY_BASIC_INFORMATION basicInfo;
+    DWORD pid;
+    HANDLE hProcess = NULL;
+    PVOID baseAddress;
+    ULONG mappedFileNameSize = 0x7FFF + 1;  // NTFS_MAX_PATH + NUL
+    WCHAR *mappedFileName = NULL;
+    LPVOID maxAddr;
+    // required by GetMappedFileNameW
+    DWORD access = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ;
+    PyObject *py_retlist = PyList_New(0);
+    PyObject *py_str = NULL;
+
+    if (py_retlist == NULL)
+        return NULL;
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        goto error;
+    hProcess = psutil_handle_from_pid(pid, access);
+    if (NULL == hProcess)
+        goto error;
+
+    mappedFileName = malloc(mappedFileNameSize * sizeof(WCHAR));
+    if (mappedFileName == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    maxAddr = PSUTIL_SYSTEM_INFO.lpMaximumApplicationAddress;
+    baseAddress = NULL;
+
+    while (VirtualQueryEx(
+        hProcess, baseAddress, &basicInfo, sizeof(MEMORY_BASIC_INFORMATION)
+    ))
+    {
+        if (baseAddress > maxAddr)
+            break;
+        // nSize is in characters, not bytes.
+        if (GetMappedFileNameW(
+                hProcess, baseAddress, mappedFileName, mappedFileNameSize
+            ))
+        {
+            py_str = PyUnicode_FromWideChar(
+                mappedFileName, wcslen(mappedFileName)
+            );
+            if (py_str == NULL)
+                goto error;
+            if (!pylist_append_fmt(
+                    py_retlist,
+                    "(KsOI)",
+                    (unsigned long long)baseAddress,
+                    get_region_protection_string(basicInfo.Protect),
+                    py_str,
+                    basicInfo.RegionSize
+                ))
+            {
+                goto error;
+            }
+            Py_CLEAR(py_str);
+        }
+        baseAddress = (PCHAR)baseAddress + basicInfo.RegionSize;
+    }
+
+    free(mappedFileName);
+    CloseHandle(hProcess);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_str);
+    Py_DECREF(py_retlist);
+    if (hProcess != NULL)
+        CloseHandle(hProcess);
+    if (mappedFileName != NULL)
+        free(mappedFileName);
+    return NULL;
+}
+
+
+// Return the parent PID. Needs a handle, so it can fail with
+// AccessDenied; the Python layer falls back to ppid_map() then.
+PyObject *
+psutil_proc_ppid(PyObject *self, PyObject *args) {
+    DWORD pid;
+    HANDLE hProcess;
+    NTSTATUS status;
+    PROCESS_BASIC_INFORMATION pbi;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_LIMITED_INFORMATION);
+    if (hProcess == NULL)
+        return NULL;
+
+    status = NtQueryInformationProcess(
+        hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL
+    );
+    CloseHandle(hProcess);
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(
+            status, "NtQueryInformationProcess(ProcessBasicInformation)"
+        );
+        return NULL;
+    }
+
+    return PyLong_FromPid((DWORD)pbi.InheritedFromUniqueProcessId);
+}
+
+
+// Return a {pid:ppid, ...} dict for all running processes.
+PyObject *
+psutil_ppid_map(PyObject *self, PyObject *args) {
+    PyObject *py_pid = NULL;
+    PyObject *py_ppid = NULL;
+    PyObject *py_retdict = PyDict_New();
+    PVOID buffer;
+    PSYSTEM_PROCESS_INFORMATION process;
+
+    if (py_retdict == NULL)
+        return NULL;
+    if (psutil_proc_table(&buffer) != 0) {
+        Py_DECREF(py_retdict);
+        return NULL;
+    }
+
+    process = PSUTIL_FIRST_PROCESS(buffer);
+    do {
+        DWORD pid = (DWORD)(ULONG_PTR)process->UniqueProcessId;
+        DWORD ppid = (DWORD)(ULONG_PTR)process->InheritedFromUniqueProcessId;
+
+        py_pid = PyLong_FromPid(pid);
+        if (py_pid == NULL)
+            goto error;
+        py_ppid = PyLong_FromPid(ppid);
+        if (py_ppid == NULL)
+            goto error;
+        if (PyDict_SetItem(py_retdict, py_pid, py_ppid))
+            goto error;
+        Py_CLEAR(py_pid);
+        Py_CLEAR(py_ppid);
+    } while ((process = PSUTIL_NEXT_PROCESS(process)));
+
+    free(buffer);
+    return py_retdict;
+
+error:
+    Py_XDECREF(py_pid);
+    Py_XDECREF(py_ppid);
+    Py_DECREF(py_retdict);
+    free(buffer);
+    return NULL;
+}
diff --git a/psutil/arch/windows/proc_handles.c b/psutil/arch/windows/proc_handles.c
new file mode 100644
index 0000000000..c55558ce13
--- /dev/null
+++ b/psutil/arch/windows/proc_handles.c
@@ -0,0 +1,548 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// This module retrieves file handles opened by a process. The
+// handle-related calls below are listed in the order in which they
+// are made.
+//
+// call                          | purpose                         | blocks
+// ------------------------------+---------------------------------+-----------
+// NtQueryObject(                | find the object type index for  | no
+//     ObjectTypesInformation)   | "File"; cached until reboot     |
+// ------------------------------+---------------------------------+-----------
+// NtQueryInformationProcess(    | enumerate process handles       | no
+//     ProcessHandleInformation) |                                 |
+// ------------------------------+---------------------------------+-----------
+// DuplicateHandle()             | copy each File handle into this | no
+//                               | process so that we can query it |
+// ------------------------------+---------------------------------+-----------
+// GetFileType()                 | discard non-disk handles        | network
+// ------------------------------+---------------------------------+-----------
+// NtQueryInformationFile(       | reject directories and handles  | lock, wire
+//     FileStandardInformation)  | pending deletion                |
+// ------------------------------+---------------------------------+-----------
+// NtQueryInformationFile(       | reject directory index streams  | lock, wire
+//     FileBasicInformation)     | using FILE_ATTRIBUTE_DIRECTORY  |
+// ------------------------------+---------------------------------+-----------
+// NtQueryObject(                | get the path in device form:    | lock
+//     ObjectNameInformation)    | \Device\HarddiskVolume2\x\y.txt |
+// ------------------------------+---------------------------------+-----------
+//
+//   lock
+//       Waits for the FILE_OBJECT lock. A blocking synchronous read
+//       may hold this lock indefinitely, as with an idle pipe.
+//       DuplicateHandle() creates another handle to the same
+//       FILE_OBJECT, so the duplicate inherits the same wait.
+//
+//   wire
+//       In addition to waiting for the FILE_OBJECT lock, the query
+//       needs an answer from whatever serves the file behind
+//       \Device\Mup: an SMB, WebDAV or NFS server, or a user-mode
+//       filesystem provider. If it stops answering, the query blocks
+//       until the session times out, about a minute for SMB.
+//
+//   network
+//       Blocks on network handles only. NPFS and ConDrv answer
+//       GetFileType() without taking the FILE_OBJECT lock.
+//
+// The first 3 calls run on the main thread. They are cheap and won't
+// block. The rest can block, so they run in a worker thread with a
+// timeout, created lazily and reused for every handle.
+//
+// On timeout, the worker is killed and replaced, or abandoned in the
+// unlikely case it refuses to die. Killing it is safe only because its
+// body is strictly syscalls: it never touches the heap, the Python C
+// API or the CRT, and it never exits on its own. The old code killed
+// a thread that did all of that and deadlocked, see #1967.
+//
+// Note: NtQueryInformationFile(FileVolumeNameInformation) (not used
+// here) is the only syscall that never blocks, on any handle. It
+// cannot replace any of the calls above though, because it returns the
+// backing device (e.g. \Device\Mup) and not the path. Nor can it be
+// used to skip the directory checks on network handles, since a
+// network directory would then be reported as a file.
+//
+// This design mirrors SystemInformer when its kernel driver is not
+// loaded:
+// https://github.com/winsiderss/systeminformer/blob/245c808f011/phlib/hndlinfo.c#L521
+//
+// History:
+// - https://github.com/giampaolo/psutil/pull/597
+// - https://github.com/giampaolo/psutil/pull/2190
+// - https://github.com/giampaolo/psutil/pull/2894
+//
+// CREDITS: the original implementation was written by Jeff Tang and
+// later rewritten by Giampaolo Rodola. Final implementation was
+// adapted using SystemInformer as a guide.
+
+#include <Python.h>
+#include <windows.h>
+
+#include "../../arch/all/init.h"
+
+
+#define THREAD_TIMEOUT 100  // ms
+#define KILL_JOIN_TIMEOUT 1000  // ms
+
+typedef struct {
+    HANDLE hThread;
+    HANDLE hStartEvent;  // auto-reset, main -> worker: work is ready
+    HANDLE hDoneEvent;  // auto-reset, worker -> main: work is done
+    HANDLE hFile;  // in: the handle to query
+    PUNICODE_STRING fileName;  // in: caller-allocated result buffer
+    ULONG bufferSize;  // in
+    ULONG returnLength;  // out
+    NTSTATUS status;  // out
+    int quit;  // main thread asks the worker to exit
+} Worker;
+
+
+// ObjectTypesInformation buffer walking, adapted from SystemInformer's
+// phnt headers. Entries are variable-size: each OBJECT_TYPE_INFORMATION
+// is followed by its type name buffer, padded to pointer alignment.
+// clang-format off
+#define ALIGN_UP_PTR(x) \
+    (((ULONG_PTR)(x) + sizeof(ULONG_PTR) - 1) & ~(sizeof(ULONG_PTR) - 1))
+
+#define FIRST_OBJECT_TYPE(types) \
+    ((POBJECT_TYPE_INFORMATION)ALIGN_UP_PTR( \
+        (ULONG_PTR)(types) + sizeof(OBJECT_TYPES_INFORMATION)))
+
+#define NEXT_OBJECT_TYPE(entry) \
+    ((POBJECT_TYPE_INFORMATION)((ULONG_PTR)(entry) \
+        + sizeof(OBJECT_TYPE_INFORMATION) \
+        + ALIGN_UP_PTR((entry)->TypeName.MaximumLength)))
+// clang-format on
+
+
+// Find the kernel object type index for "File" handles, so that we
+// can tell whether a handle refers to a file without touching it.
+// The index is stable until reboot; resolve it once and cache it.
+// Return 0 on success, -1 on error.
+static int
+get_file_type_index(ULONG *indexOut) {
+    static ULONG cachedIndex = 0;
+    NTSTATUS status;
+    POBJECT_TYPES_INFORMATION typesInfo = NULL;
+    POBJECT_TYPE_INFORMATION entry;
+    ULONG bufferSize = 0x1000;
+    ULONG returnLength = 0;
+    ULONG i;
+    int attempts = 8;
+
+    if (cachedIndex != 0) {
+        *indexOut = cachedIndex;
+        return 0;
+    }
+
+    do {
+        typesInfo = MALLOC_ZERO(bufferSize);
+        if (typesInfo == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        status = NtQueryObject(
+            NULL, ObjectTypesInformation, typesInfo, bufferSize, &returnLength
+        );
+        if (status != STATUS_INFO_LENGTH_MISMATCH)
+            break;
+        FREE(typesInfo);
+        typesInfo = NULL;
+        bufferSize = returnLength + 0x1000;
+    } while (--attempts);
+
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(status, "NtQueryObject");
+        if (typesInfo != NULL)
+            FREE(typesInfo);
+        return -1;
+    }
+
+    entry = FIRST_OBJECT_TYPE(typesInfo);
+    for (i = 0; i < typesInfo->NumberOfTypes; i++) {
+        if (entry->TypeName.Length == 4 * sizeof(WCHAR)
+            && memcmp(entry->TypeName.Buffer, L"File", 4 * sizeof(WCHAR)) == 0)
+        {
+            cachedIndex = entry->TypeIndex;
+            *indexOut = cachedIndex;
+            FREE(typesInfo);
+            return 0;
+        }
+        entry = NEXT_OBJECT_TYPE(entry);
+    }
+
+    FREE(typesInfo);
+    psutil_runtime_error("'File' object type not found");
+    return -1;
+}
+
+
+static int
+enum_process_handles(
+    HANDLE hProcess, PPROCESS_HANDLE_SNAPSHOT_INFORMATION *snapshot
+) {
+    NTSTATUS status;
+    PVOID buffer = NULL;
+    ULONG bufferSize = 0x8000;
+    DWORD returnLength = 0;
+    int attempts = 8;
+
+    do {
+        // Zeroed buffer: some Windows versions return success for
+        // minimal processes without writing anything, so make sure
+        // NumberOfHandles reads as 0 in that case.
+        buffer = MALLOC_ZERO(bufferSize);
+        if (buffer == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+        status = NtQueryInformationProcess(
+            hProcess,
+            ProcessHandleInformation,
+            buffer,
+            bufferSize,
+            &returnLength
+        );
+        if (status != STATUS_INFO_LENGTH_MISMATCH)
+            break;
+        FREE(buffer);
+        buffer = NULL;
+        // The handle table may grow between calls; leave some slack.
+        bufferSize = returnLength + 0x1000;
+    } while (--attempts);
+
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(status, "NtQueryInformationProcess");
+        if (buffer != NULL)
+            FREE(buffer);
+        return -1;
+    }
+
+    *snapshot = (PPROCESS_HANDLE_SNAPSHOT_INFORMATION)buffer;
+    return 0;
+}
+
+
+// Runs in a separate thread. The body is strictly syscalls: no
+// Python, no heap, no CRT. The main thread may TerminateThread()
+// this thread at any point between the two events, so anything that
+// can hold a user-mode lock is off limits. Buffers are allocated and
+// freed by the main thread, which also reports errors.
+static DWORD WINAPI
+worker_loop(LPVOID lpvParam) {
+    Worker *w = (Worker *)lpvParam;
+    FILE_STANDARD_INFORMATION info;
+    FILE_BASIC_INFORMATION basicInfo;
+    IO_STATUS_BLOCK iosb;
+    BOOLEAN wanted;
+
+    while (1) {
+        WaitForSingleObject(w->hStartEvent, INFINITE);
+        if (w->quit)
+            return 0;
+        w->status = 0;  // success
+        // These can block, which is why they run here. When we skip
+        // the name query the buffer is left zeroed, meaning "no
+        // name", and the caller skips the handle.
+        wanted = FALSE;
+        if (GetFileType(w->hFile) == FILE_TYPE_DISK
+            && NT_SUCCESS(NtQueryInformationFile(
+                w->hFile,
+                &iosb,
+                &info,
+                sizeof(info),
+                (FILE_INFORMATION_CLASS)FileStandardInformation
+            ))
+            && !info.Directory && !info.DeletePending)
+        {
+            wanted = TRUE;
+            // A handle to the index stream of a directory reports
+            // Directory = FALSE, e.g.
+            // "C:\$Extend\$ObjId:$O:$INDEX_ALLOCATION". The file
+            // attributes are what os.stat() looks at, and they get it
+            // right.
+            if (NT_SUCCESS(NtQueryInformationFile(
+                    w->hFile,
+                    &iosb,
+                    &basicInfo,
+                    sizeof(basicInfo),
+                    (FILE_INFORMATION_CLASS)FileBasicInformation
+                ))
+                && (basicInfo.FileAttributes & FILE_ATTRIBUTE_DIRECTORY))
+            {
+                wanted = FALSE;
+            }
+        }
+
+        if (wanted) {
+            w->status = NtQueryObject(
+                w->hFile,
+                ObjectNameInformation,
+                w->fileName,
+                w->bufferSize,
+                &w->returnLength
+            );
+        }
+        SetEvent(w->hDoneEvent);
+    }
+}
+
+
+static Worker *
+worker_create(void) {
+    Worker *w;
+
+    w = MALLOC_ZERO(sizeof(Worker));
+    if (w == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    w->hStartEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    w->hDoneEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+    if (w->hStartEvent == NULL || w->hDoneEvent == NULL) {
+        psutil_oserror_wsyscall("CreateEvent");
+        goto error;
+    }
+
+    // Small stack: the thread only issues syscalls. Keeps the cost
+    // down if the worker gets stuck and leaks.
+    w->hThread = CreateThread(
+        NULL, 0x10000, worker_loop, w, STACK_SIZE_PARAM_IS_A_RESERVATION, NULL
+    );
+    if (w->hThread == NULL) {
+        psutil_oserror_wsyscall("CreateThread");
+        goto error;
+    }
+    return w;
+
+error:
+    if (w->hStartEvent != NULL)
+        CloseHandle(w->hStartEvent);
+    if (w->hDoneEvent != NULL)
+        CloseHandle(w->hDoneEvent);
+    FREE(w);
+    return NULL;
+}
+
+
+// Only for a live (not abandoned) worker: it's idle, so it exits
+// right away and the wait is bounded.
+static void
+worker_destroy(Worker *w) {
+    w->quit = 1;
+    SetEvent(w->hStartEvent);
+    Py_BEGIN_ALLOW_THREADS
+    WaitForSingleObject(w->hThread, INFINITE);
+    Py_END_ALLOW_THREADS
+    CloseHandle(w->hThread);
+    CloseHandle(w->hStartEvent);
+    CloseHandle(w->hDoneEvent);
+    FREE(w);
+}
+
+
+// Query the name of hFile on the worker thread, with a timeout. Return
+// 0 on success (*nameOut set, may have Length 0), -1 on error (Python
+// exception set), WAIT_TIMEOUT if the query got stuck. On WAIT_TIMEOUT
+// the worker is killed and hFile is closed (or leaked if the kill
+// fails); either way the caller must not touch hFile. *workerRef is
+// reset to NULL; the next call creates a new worker.
+static DWORD
+worker_get_filename(
+    Worker **workerRef, HANDLE hFile, PUNICODE_STRING *nameOut
+) {
+    Worker *w = NULL;
+    DWORD dwWait;
+    NTSTATUS status = 0;
+    PUNICODE_STRING name = NULL;
+    ULONG bufferSize = 0x200;
+    ULONG attempts = 8;
+
+    *nameOut = NULL;
+
+    // A loop is needed because the I/O subsystem likes to give us the wrong
+    // return lengths... Buffers are (re)allocated in here so that the worker
+    // never touches the heap.
+    do {
+        name = MALLOC_ZERO(bufferSize);
+        if (name == NULL) {
+            PyErr_NoMemory();
+            return -1;
+        }
+
+        w = *workerRef;
+        if (w == NULL) {
+            w = worker_create();
+            if (w == NULL) {
+                FREE(name);
+                return -1;
+            }
+            *workerRef = w;
+        }
+
+        w->hFile = hFile;
+        w->fileName = name;
+        w->bufferSize = bufferSize;
+        SetEvent(w->hStartEvent);
+
+        // The worker may hang on a lock or on the wire, hence the
+        // timeout. Don't make the rest of the interpreter wait with us.
+        Py_BEGIN_ALLOW_THREADS
+        dwWait = WaitForSingleObject(w->hDoneEvent, THREAD_TIMEOUT);
+        Py_END_ALLOW_THREADS
+
+        if (dwWait != WAIT_OBJECT_0) {
+            if (dwWait == WAIT_FAILED)
+                psutil_debug("WaitForSingleObject -> WAIT_FAILED");
+            psutil_debug(
+                "get handle name thread timed out after %i ms; killing it",
+                THREAD_TIMEOUT
+            );
+            // The worker is stuck in the kernel. Kill it: its body is strictly
+            // syscalls, so there is no user-mode lock it can orphan.
+            if (!TerminateThread(w->hThread, 0))
+                psutil_debug("TerminateThread -> FALSE");
+            Py_BEGIN_ALLOW_THREADS
+            dwWait = WaitForSingleObject(w->hThread, KILL_JOIN_TIMEOUT);
+            Py_END_ALLOW_THREADS
+            if (dwWait == WAIT_OBJECT_0) {
+                // Worker is gone. Closing our duplicate won't block.
+                CloseHandle(w->hThread);
+                CloseHandle(w->hStartEvent);
+                CloseHandle(w->hDoneEvent);
+                CloseHandle(w->hFile);
+                FREE(w->fileName);
+                FREE(w);
+            }
+            else {
+                // Should not happen: the thread is stuck in an unkillable
+                // kernel wait. Leak it, along with hFile, the events and the
+                // name buffer, which the kernel may still write to. The
+                // pending termination will kill the thread before it ever runs
+                // user code again.
+                psutil_debug("killed worker did not exit; leaking it");
+                CloseHandle(w->hThread);
+            }
+            *workerRef = NULL;
+            return WAIT_TIMEOUT;
+        }
+
+        status = w->status;
+        if (status == STATUS_BUFFER_OVERFLOW
+            || status == STATUS_INFO_LENGTH_MISMATCH
+            || status == STATUS_BUFFER_TOO_SMALL)
+        {
+            FREE(name);
+            name = NULL;
+            bufferSize = w->returnLength;
+        }
+        else {
+            break;
+        }
+    } while (--attempts);
+
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(status, "NtQueryObject");
+        if (name != NULL)
+            FREE(name);
+        return -1;
+    }
+    *nameOut = name;
+    return 0;
+}
+
+
+PyObject *
+psutil_get_open_files(HANDLE hProcess) {
+    PPROCESS_HANDLE_SNAPSHOT_INFORMATION snapshot = NULL;
+    PPROCESS_HANDLE_TABLE_ENTRY_INFO entry = NULL;
+    Worker *worker = NULL;
+    HANDLE hFile = NULL;
+    PUNICODE_STRING fileName = NULL;
+    ULONG_PTR i = 0;
+    ULONG fileTypeIndex = 0;
+    BOOLEAN errorOccurred = FALSE;
+    DWORD dwRet;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (!py_retlist)
+        return NULL;
+
+    if (get_file_type_index(&fileTypeIndex) != 0)
+        goto error;
+    if (enum_process_handles(hProcess, &snapshot) != 0)
+        goto error;
+
+    for (i = 0; i < snapshot->NumberOfHandles; i++) {
+        entry = &snapshot->Handles[i];
+        // Skip anything that is not a File object (events, keys,
+        // threads, ...), which is usually most of the handles.
+        if (entry->ObjectTypeIndex != fileTypeIndex)
+            continue;
+        if (!DuplicateHandle(
+                hProcess,
+                entry->HandleValue,
+                GetCurrentProcess(),
+                &hFile,
+                0,
+                TRUE,
+                DUPLICATE_SAME_ACCESS
+            ))
+        {
+            // The process may have closed it in the meantime.
+            continue;
+        }
+
+        dwRet = worker_get_filename(&worker, hFile, &fileName);
+        if (dwRet == WAIT_TIMEOUT) {
+            // Already closed (or deliberately leaked) along with the
+            // killed worker; skip this handle.
+            hFile = NULL;
+            continue;
+        }
+        if (dwRet != 0)
+            goto error;
+
+        if ((fileName != NULL) && (fileName->Length > 0)) {
+            if (!pylist_append_obj(
+                    py_retlist,
+                    PyUnicode_FromWideChar(
+                        fileName->Buffer, wcslen(fileName->Buffer)
+                    )
+                ))
+                goto error;
+        }
+
+        // Loop cleanup section.
+        if (fileName != NULL) {
+            FREE(fileName);
+            fileName = NULL;
+        }
+        CloseHandle(hFile);
+        hFile = NULL;
+    }
+
+    goto exit;
+
+error:
+    Py_XDECREF(py_retlist);
+    errorOccurred = TRUE;
+    goto exit;
+
+exit:
+    if (worker != NULL)
+        worker_destroy(worker);
+    if (hFile != NULL)
+        CloseHandle(hFile);
+    if (fileName != NULL)
+        FREE(fileName);
+    if (snapshot != NULL)
+        FREE(snapshot);
+
+    if (errorOccurred == TRUE)
+        return NULL;
+    return py_retlist;
+}
diff --git a/psutil/arch/windows/proc_peb.c b/psutil/arch/windows/proc_peb.c
new file mode 100644
index 0000000000..f99c931231
--- /dev/null
+++ b/psutil/arch/windows/proc_peb.c
@@ -0,0 +1,468 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Process cmdline(), cwd() and environ() implementations. All three
+// live in the process PEB (Process Environment Block), which we read
+// with ReadProcessMemory(). cmdline() can also avoid the PEB and use
+// NtQueryInformationProcess() instead, see psutil_proc_cmdline().
+
+#include <Python.h>
+#include <windows.h>
+
+#include "../../arch/all/init.h"
+
+
+enum peb_kind {
+    PEB_CMDLINE,
+    PEB_CWD,
+    PEB_ENVIRON,
+};
+
+
+// Given a pointer into a process's memory, figure out how much data
+// can be read from it.
+static int
+get_proc_region_size(HANDLE hProcess, LPCVOID src, SIZE_T *psize) {
+    MEMORY_BASIC_INFORMATION info;
+
+    if (!VirtualQueryEx(hProcess, src, &info, sizeof(info))) {
+        psutil_oserror_wsyscall("VirtualQueryEx");
+        return -1;
+    }
+
+    *psize = info.RegionSize - ((char *)src - (char *)info.BaseAddress);
+    return 0;
+}
+
+
+// Read a chunk of another process's memory. On error set a Python
+// exception and return -1. May fail with ERROR_NOACCESS (turned into
+// AccessDenied) or ERROR_PARTIAL_COPY, see:
+// https://github.com/giampaolo/psutil/issues/875
+static int
+read_proc_mem(HANDLE hProcess, LPCVOID src, LPVOID dst, SIZE_T size) {
+    if (!ReadProcessMemory(hProcess, src, dst, size, NULL)) {
+        if (GetLastError() == ERROR_NOACCESS) {
+            psutil_debug("ReadProcessMemory -> ERROR_NOACCESS");
+            psutil_oserror_ad("ReadProcessMemory -> ERROR_NOACCESS");
+        }
+        else {
+            psutil_oserror_wsyscall("ReadProcessMemory");
+        }
+        return -1;
+    }
+    return 0;
+}
+
+
+// Get data from the process with the given pid.  The data is returned
+// in the pdata output member as a nul terminated string which must be
+// freed on success. On success 0 is returned.  On error the output
+// parameter is not touched, -1 is returned, and an appropriate Python
+// exception is set.
+static int
+get_proc_data(DWORD pid, enum peb_kind kind, WCHAR **pdata, SIZE_T *psize) {
+    /* Several cases to consider:
+
+       We (i.e. the python interpreter) and the target process are of
+       the same bitness: the memory layout of the structures matches
+       up and all is well.
+
+       We are 64 bit and the target process is 32 bit (WoW64): we use
+       custom 32 bit versions of the structures.
+
+       We are 32 bit and the target process is 64 bit: we give up and
+       raise AccessDenied (it would require the undocumented NtWow64*
+       APIs).
+
+       See: https://github.com/giampaolo/psutil/issues/2889
+
+       Additional help came from:
+
+         https://github.com/kohsuke/winp
+         http://wj32.org/wp/2009/01/24/howto-get-the-command-line-of-processes/
+     */
+    SIZE_T size = 0;
+    HANDLE hProcess = NULL;
+    LPCVOID src;
+    WCHAR *buffer = NULL;
+#ifdef _WIN64
+    LPVOID ppeb32 = NULL;
+#else
+    BOOL weAreWow64;
+    BOOL theyAreWow64;
+#endif
+    DWORD access = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ;
+    NTSTATUS status;
+
+    hProcess = psutil_handle_from_pid(pid, access);
+    if (hProcess == NULL)
+        return -1;
+
+#ifdef _WIN64
+    // 64 bit case.  Check if the target is a 32 bit process running in
+    // WoW64 mode.
+    status = NtQueryInformationProcess(
+        hProcess, ProcessWow64Information, &ppeb32, sizeof(LPVOID), NULL
+    );
+
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(
+            status, "NtQueryInformationProcess(ProcessWow64Information)"
+        );
+        goto error;
+    }
+
+    if (ppeb32 != NULL) {
+        // We are 64 bit.  Target process is 32 bit running in WoW64 mode.
+        PEB32 peb32;
+        RTL_USER_PROCESS_PARAMETERS32 procParameters32;
+
+        // read PEB
+        if (read_proc_mem(hProcess, ppeb32, &peb32, sizeof(peb32)) != 0)
+            goto error;
+
+        // read process parameters
+        if (read_proc_mem(
+                hProcess,
+                UlongToPtr(peb32.ProcessParameters),
+                &procParameters32,
+                sizeof(procParameters32)
+            )
+            != 0)
+        {
+            goto error;
+        }
+
+        switch (kind) {
+            case PEB_CMDLINE:
+                src = UlongToPtr(procParameters32.CommandLine.Buffer),
+                size = procParameters32.CommandLine.Length;
+                break;
+            case PEB_CWD:
+                src = UlongToPtr(procParameters32.CurrentDirectoryPath.Buffer);
+                size = procParameters32.CurrentDirectoryPath.Length;
+                break;
+            case PEB_ENVIRON:
+                src = UlongToPtr(procParameters32.env);
+                break;
+        }
+    }
+    else
+#else  // #ifdef _WIN64
+    // We are 32 bit. If the target is 64 bit we give up: reading its
+    // memory would require the undocumented NtWow64* APIs.
+    if (!IsWow64Process(GetCurrentProcess(), &weAreWow64)
+        || !IsWow64Process(hProcess, &theyAreWow64))
+    {
+        psutil_oserror_wsyscall("IsWow64Process");
+        goto error;
+    }
+
+    if (weAreWow64 && !theyAreWow64) {
+        psutil_oserror_ad("can't query 64-bit process from 32-bit psutil");
+        goto error;
+    }
+#endif
+    // Target process is of the same bitness as us.
+    {
+        PROCESS_BASIC_INFORMATION pbi;
+        PEB peb;
+        RTL_USER_PROCESS_PARAMETERS procParameters;
+
+        status = NtQueryInformationProcess(
+            hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL
+        );
+
+        if (!NT_SUCCESS(status)) {
+            psutil_SetFromNTStatusErr(
+                status, "NtQueryInformationProcess(ProcessBasicInformation)"
+            );
+            goto error;
+        }
+
+
+        // read peb
+        if (read_proc_mem(hProcess, pbi.PebBaseAddress, &peb, sizeof(peb))
+            != 0)
+        {
+            goto error;
+        }
+
+        // read process parameters
+        if (read_proc_mem(
+                hProcess,
+                peb.ProcessParameters,
+                &procParameters,
+                sizeof(procParameters)
+            )
+            != 0)
+        {
+            goto error;
+        }
+
+        switch (kind) {
+            case PEB_CMDLINE:
+                src = procParameters.CommandLine.Buffer;
+                size = procParameters.CommandLine.Length;
+                break;
+            case PEB_CWD:
+                src = procParameters.CurrentDirectoryPath.Buffer;
+                size = procParameters.CurrentDirectoryPath.Length;
+                break;
+            case PEB_ENVIRON:
+                src = procParameters.env;
+                break;
+        }
+    }
+
+    if (kind == PEB_ENVIRON) {
+        if (get_proc_region_size(hProcess, src, &size) != 0)
+            goto error;
+    }
+
+    buffer = calloc(size + 2, 1);
+    if (buffer == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    if (read_proc_mem(hProcess, src, buffer, size) != 0)
+        goto error;
+
+    CloseHandle(hProcess);
+
+    *pdata = buffer;
+    *psize = size;
+
+    return 0;
+
+error:
+    if (hProcess != NULL)
+        CloseHandle(hProcess);
+    if (buffer != NULL)
+        free(buffer);
+    return -1;
+}
+
+
+// Get process cmdline by using NtQueryInformationProcess. This is a
+// method alternative to PEB which is less likely to result in
+// AccessDenied.
+static int
+get_cmdline_nopeb(DWORD pid, WCHAR **pdata, SIZE_T *psize) {
+    HANDLE hProcess = NULL;
+    ULONG bufLen = 0;
+    NTSTATUS status;
+    char *buffer = NULL;
+    WCHAR *bufWchar = NULL;
+    PUNICODE_STRING tmp = NULL;
+    size_t size;
+
+    hProcess = psutil_handle_from_pid(pid, PROCESS_QUERY_LIMITED_INFORMATION);
+    if (hProcess == NULL)
+        goto error;
+
+    // get the right buf size
+    status = NtQueryInformationProcess(
+        hProcess, ProcessCommandLineInformation, NULL, 0, &bufLen
+    );
+
+    // https://github.com/giampaolo/psutil/issues/1501
+    if (status == STATUS_NOT_FOUND) {
+        psutil_oserror_ad(
+            "NtQueryInformationProcess(ProcessCommandLineInformation) -> "
+            "STATUS_NOT_FOUND"
+        );
+        goto error;
+    }
+
+    if (status != STATUS_BUFFER_OVERFLOW && status != STATUS_BUFFER_TOO_SMALL
+        && status != STATUS_INFO_LENGTH_MISMATCH)
+    {
+        psutil_SetFromNTStatusErr(
+            status, "NtQueryInformationProcess(ProcessCommandLineInformation)"
+        );
+        goto error;
+    }
+
+    // allocate memory
+    buffer = calloc(bufLen, 1);
+    if (buffer == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    // get the cmdline
+    status = NtQueryInformationProcess(
+        hProcess, ProcessCommandLineInformation, buffer, bufLen, &bufLen
+    );
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(
+            status, "NtQueryInformationProcess(ProcessCommandLineInformation)"
+        );
+        goto error;
+    }
+
+    // build the string
+    tmp = (PUNICODE_STRING)buffer;
+    size = wcslen(tmp->Buffer) + 1;
+    bufWchar = (WCHAR *)calloc(size, sizeof(WCHAR));
+    if (bufWchar == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+    wcscpy_s(bufWchar, size, tmp->Buffer);
+    *pdata = bufWchar;
+    *psize = size * sizeof(WCHAR);
+    free(buffer);
+    CloseHandle(hProcess);
+    return 0;
+
+error:
+    if (buffer != NULL)
+        free(buffer);
+    if (bufWchar != NULL)
+        free(bufWchar);
+    if (hProcess != NULL)
+        CloseHandle(hProcess);
+    return -1;
+}
+
+
+// --------------------------------------------------------------------
+
+
+PyObject *
+psutil_proc_cmdline(PyObject *self, PyObject *args, PyObject *kwdict) {
+    WCHAR *data = NULL;
+    LPWSTR *szArglist = NULL;
+    SIZE_T size;
+    int nArgs;
+    int i;
+    int func_ret;
+    DWORD pid;
+    int use_peb = 1;
+    PyObject *py_retlist = NULL;
+    PyObject *py_unicode = NULL;
+    static char *keywords[] = {"pid", "use_peb", NULL};
+
+    if (!PyArg_ParseTupleAndKeywords(
+            args, kwdict, _Py_PARSE_PID "|p", keywords, &pid, &use_peb
+        ))
+    {
+        return NULL;
+    }
+    if ((pid == 0) || (pid == 4))
+        return Py_BuildValue("[]");
+
+    if (psutil_check_pid_running(pid) != 0)
+        return NULL;
+
+    // Reading the PEB to get the cmdline seem to be the best method if
+    // somebody has tampered with the parameters after creating the
+    // process. For instance, create a process as suspended, patch the
+    // command line in its PEB and unfreeze it. It requires more
+    // privileges than NtQueryInformationProcess though (the fallback):
+    // - https://github.com/giampaolo/psutil/pull/1398
+    // - https://blog.xpnsec.com/how-to-argue-like-cobalt-strike/
+    if (use_peb == 1)
+        func_ret = get_proc_data(pid, PEB_CMDLINE, &data, &size);
+    else
+        func_ret = get_cmdline_nopeb(pid, &data, &size);
+    if (func_ret != 0)
+        goto error;
+
+    // attempt to parse the command line using Win32 API
+    szArglist = CommandLineToArgvW(data, &nArgs);
+    if (szArglist == NULL) {
+        psutil_oserror_wsyscall("CommandLineToArgvW");
+        goto error;
+    }
+
+    // arglist parsed as array of UNICODE_STRING, so convert each to
+    // Python string object and add to arg list
+    py_retlist = PyList_New(nArgs);
+    if (py_retlist == NULL)
+        goto error;
+    for (i = 0; i < nArgs; i++) {
+        py_unicode = PyUnicode_FromWideChar(
+            szArglist[i], wcslen(szArglist[i])
+        );
+        if (py_unicode == NULL)
+            goto error;
+        PyList_SetItem(py_retlist, i, py_unicode);
+        py_unicode = NULL;
+    }
+
+    LocalFree(szArglist);
+    free(data);
+    return py_retlist;
+
+error:
+    if (szArglist != NULL)
+        LocalFree(szArglist);
+    if (data != NULL)
+        free(data);
+    Py_XDECREF(py_unicode);
+    Py_XDECREF(py_retlist);
+    return NULL;
+}
+
+
+PyObject *
+psutil_proc_cwd(PyObject *self, PyObject *args) {
+    DWORD pid;
+    PyObject *ret = NULL;
+    WCHAR *data = NULL;
+    SIZE_T size;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+
+    if (psutil_check_pid_running(pid) != 0)
+        return NULL;
+
+    if (get_proc_data(pid, PEB_CWD, &data, &size) != 0)
+        goto out;
+
+    // convert wchar array to a Python unicode string
+    ret = PyUnicode_FromWideChar(data, wcslen(data));
+
+out:
+    if (data != NULL)
+        free(data);
+
+    return ret;
+}
+
+
+PyObject *
+psutil_proc_environ(PyObject *self, PyObject *args) {
+    DWORD pid;
+    WCHAR *data = NULL;
+    SIZE_T size;
+    PyObject *ret = NULL;
+
+    if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid))
+        return NULL;
+    if ((pid == 0) || (pid == 4))
+        return PyUnicode_FromString("");
+
+    if (psutil_check_pid_running(pid) != 0)
+        return NULL;
+
+    if (get_proc_data(pid, PEB_ENVIRON, &data, &size) != 0)
+        goto out;
+
+    // convert wchar array to a Python unicode string
+    ret = PyUnicode_FromWideChar(data, size / 2);
+
+out:
+    if (data != NULL)
+        free(data);
+    return ret;
+}
diff --git a/psutil/arch/windows/proc_utils.c b/psutil/arch/windows/proc_utils.c
new file mode 100644
index 0000000000..321e9d2d73
--- /dev/null
+++ b/psutil/arch/windows/proc_utils.c
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ *
+ * Helper process functions.
+ */
+
+#include <Python.h>
+#include <windows.h>
+#include <Psapi.h>  // EnumProcesses
+
+#include "../../arch/all/init.h"
+
+
+// Return 1 if PID exists, 0 if not, -1 on error.
+static int
+pid_in_pids(DWORD pid) {
+    DWORD *pids_array = NULL;
+    int pids_count = 0;
+    int i;
+
+    if (_psutil_pids(&pids_array, &pids_count) != 0)
+        return -1;
+
+    for (i = 0; i < pids_count; i++) {
+        if (pids_array[i] == pid) {
+            free(pids_array);
+            return 1;
+        }
+    }
+
+    free(pids_array);
+    return 0;
+}
+
+
+// Check whether the process behind an open handle is still alive.
+// Return 1 if it is, 0 if it's gone, -1 on error with a Python
+// exception set. The handle is left open in all cases.
+static int
+phandle_is_running(HANDLE hProcess, DWORD pid) {
+    DWORD exitCode;
+
+    if (!GetExitCodeProcess(hProcess, &exitCode)) {
+        if (GetLastError() == ERROR_ACCESS_DENIED) {
+            // Can't query the handle, but it's open, so the process
+            // exists.
+            psutil_debug("GetExitCodeProcess -> ERROR_ACCESS_DENIED (ignored)"
+            );
+            SetLastError(0);
+            return 1;
+        }
+        psutil_oserror_wsyscall("GetExitCodeProcess");
+        return -1;
+    }
+
+    // XXX - maybe STILL_ACTIVE is not fully reliable as per:
+    // http://stackoverflow.com/questions/1591342/#comment47830782_1591379
+    if (exitCode == STILL_ACTIVE)
+        return 1;
+
+    // The process appears to be gone; double check against the full
+    // PID list.
+    return pid_in_pids(pid);
+}
+
+
+// A wrapper around OpenProcess setting NSP exception if process no
+// longer exists. *pid* is the process PID, *access* is the first
+// argument to OpenProcess.
+// Return a process handle or NULL with exception set.
+HANDLE
+psutil_handle_from_pid(DWORD pid, DWORD access) {
+    HANDLE hProcess;
+    int running;
+    int in_list;
+
+    if (pid == 0) {
+        // otherwise we'd get NoSuchProcess
+        return psutil_oserror_ad("automatically set for PID 0");
+    }
+
+    hProcess = OpenProcess(access, FALSE, pid);
+    if (hProcess == NULL) {
+        if (GetLastError() == ERROR_INVALID_PARAMETER) {
+            // Yeah, this is the actual error code in case of
+            // "no such process".
+            psutil_oserror_nsp("OpenProcess -> ERROR_INVALID_PARAMETER");
+        }
+        else if (GetLastError() == ERROR_SUCCESS) {
+            // Yeah, it's this bad.
+            // https://github.com/giampaolo/psutil/issues/1877
+            in_list = pid_in_pids(pid);
+            if (in_list == 1) {
+                psutil_debug("OpenProcess -> ERROR_SUCCESS turned into AD");
+                psutil_oserror_ad("OpenProcess -> ERROR_SUCCESS");
+            }
+            else if (in_list == 0) {
+                psutil_debug("OpenProcess -> ERROR_SUCCESS turned into NSP");
+                psutil_oserror_nsp("OpenProcess -> ERROR_SUCCESS");
+            }
+            // on -1 the exception is already set
+        }
+        else {
+            psutil_oserror_wsyscall("OpenProcess");
+        }
+        return NULL;
+    }
+
+    running = phandle_is_running(hProcess, pid);
+    if (running == 1)
+        return hProcess;
+    CloseHandle(hProcess);
+    if (running == 0)
+        psutil_oserror_nsp("GetExitCodeProcess != STILL_ACTIVE");
+    return NULL;
+}
+
+
+// Check for PID existence. Return 1 if pid exists, 0 if not, -1 on error.
+int
+psutil_pid_is_running(DWORD pid) {
+    HANDLE hProcess;
+    int running;
+
+    // Special case for PID 0 System Idle Process
+    if (pid == 0)
+        return 1;
+
+    hProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid);
+    if (hProcess == NULL) {
+        // Can't tell from the error code alone; check the PID list.
+        return pid_in_pids(pid);
+    }
+
+    running = phandle_is_running(hProcess, pid);
+    CloseHandle(hProcess);
+    // 0 means phandle_is_running() already vetted the PID list.
+    if (running != -1)
+        return running;
+    PyErr_Clear();
+    return pid_in_pids(pid);
+}
+
+
+// Return 0 if the process is running, else -1 with NoSuchProcess or
+// another exception set.
+int
+psutil_check_pid_running(DWORD pid) {
+    int ret = psutil_pid_is_running(pid);
+
+    if (ret == 1)
+        return 0;
+    if (ret == 0)
+        psutil_oserror_nsp("psutil_pid_is_running -> 0");
+    return -1;
+}
+
+
+// A syscall against pid failed with an NTSTATUS. Raise NoSuchProcess
+// if the process is gone, else convert the status into the
+// appropriate Python exception. Always return NULL.
+PyObject *
+psutil_raise_for_nt_status(DWORD pid, NTSTATUS status, const char *syscall) {
+    int running = psutil_pid_is_running(pid);
+
+    if (running == 0)
+        return psutil_oserror_nsp("psutil_pid_is_running -> 0");
+    if (running == -1) {
+        // report the original NTSTATUS failure instead
+        PyErr_Clear();
+    }
+    return psutil_SetFromNTStatusErr(status, syscall);
+}
+
+
+// Fetch the whole process table via NtQuerySystemInformation. Walk it
+// with the PSUTIL_FIRST_PROCESS / PSUTIL_NEXT_PROCESS macros. The
+// caller owns *retBuffer and must free() it. Return 0 on success, else
+// -1 with Python exception set.
+int
+psutil_proc_table(PVOID *retBuffer) {
+    static ULONG initialBufferSize = 0x4000;
+    NTSTATUS status;
+    PVOID buffer;
+    ULONG bufferSize;
+
+    bufferSize = initialBufferSize;
+    buffer = malloc(bufferSize);
+    if (buffer == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+
+    while (TRUE) {
+        status = NtQuerySystemInformation(
+            SystemProcessInformation, buffer, bufferSize, &bufferSize
+        );
+        if (status == STATUS_BUFFER_TOO_SMALL
+            || status == STATUS_INFO_LENGTH_MISMATCH)
+        {
+            free(buffer);
+            buffer = malloc(bufferSize);
+            if (buffer == NULL) {
+                PyErr_NoMemory();
+                return -1;
+            }
+        }
+        else {
+            break;
+        }
+    }
+
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(
+            status, "NtQuerySystemInformation(SystemProcessInformation)"
+        );
+        free(buffer);
+        return -1;
+    }
+
+    if (bufferSize <= 0x20000)
+        initialBufferSize = bufferSize;
+
+    *retBuffer = buffer;
+    return 0;
+}
+
+
+// Find one process in the table. *retProcess points into *retBuffer,
+// which the caller owns and must free(). We use this as a fallback
+// when faster functions fail with access denied: it's slower because
+// it fetches all processes, but requires no privilege and works for
+// PID 0 too. Return 0 on success, else -1 with Python exception set.
+int
+psutil_proc_table_entry(
+    DWORD pid, PSYSTEM_PROCESS_INFORMATION *retProcess, PVOID *retBuffer
+) {
+    PVOID buffer;
+    PSYSTEM_PROCESS_INFORMATION process;
+
+    if (psutil_proc_table(&buffer) != 0)
+        return -1;
+
+    process = PSUTIL_FIRST_PROCESS(buffer);
+    do {
+        if ((ULONG_PTR)process->UniqueProcessId == pid) {
+            *retProcess = process;
+            *retBuffer = buffer;
+            return 0;
+        }
+    } while ((process = PSUTIL_NEXT_PROCESS(process)));
+
+    free(buffer);
+    psutil_oserror_nsp("NtQuerySystemInformation (no PID found)");
+    return -1;
+}
diff --git a/psutil/arch/windows/process_handles.c b/psutil/arch/windows/process_handles.c
deleted file mode 100644
index 433da3497a..0000000000
--- a/psutil/arch/windows/process_handles.c
+++ /dev/null
@@ -1,534 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- */
-#include "process_handles.h"
-
-static _NtQuerySystemInformation __NtQuerySystemInformation = NULL;
-static _NtQueryObject __NtQueryObject = NULL;
-
-CRITICAL_SECTION g_cs;
-BOOL g_initialized = FALSE;
-NTSTATUS g_status;
-HANDLE g_hFile = NULL;
-HANDLE g_hEvtStart = NULL;
-HANDLE g_hEvtFinish = NULL;
-HANDLE g_hThread = NULL;
-PUNICODE_STRING g_pNameBuffer = NULL;
-ULONG g_dwSize = 0;
-ULONG g_dwLength = 0;
-PVOID g_fiber = NULL;
-
-
-PVOID
-GetLibraryProcAddress(PSTR LibraryName, PSTR ProcName) {
-    return GetProcAddress(GetModuleHandleA(LibraryName), ProcName);
-}
-
-
-PyObject *
-psutil_get_open_files(long dwPid, HANDLE hProcess) {
-    OSVERSIONINFO osvi;
-
-    ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
-    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
-    GetVersionEx(&osvi);
-
-    // Threaded version only works for Vista+
-    if (osvi.dwMajorVersion >= 6)
-        return psutil_get_open_files_ntqueryobject(dwPid, hProcess);
-    else
-        return psutil_get_open_files_getmappedfilename(dwPid, hProcess);
-}
-
-
-VOID
-psutil_get_open_files_init(BOOL threaded) {
-    if (g_initialized == TRUE)
-        return;
-
-    // Resolve the Windows API calls
-    __NtQuerySystemInformation =
-        GetLibraryProcAddress("ntdll.dll", "NtQuerySystemInformation");
-    __NtQueryObject = GetLibraryProcAddress("ntdll.dll", "NtQueryObject");
-
-    // Create events for signalling work between threads
-    if (threaded == TRUE) {
-        g_hEvtStart = CreateEvent(NULL, FALSE, FALSE, NULL);
-        g_hEvtFinish = CreateEvent(NULL, FALSE, FALSE, NULL);
-        InitializeCriticalSection(&g_cs);
-    }
-
-    g_initialized = TRUE;
-}
-
-
-PyObject *
-psutil_get_open_files_ntqueryobject(long dwPid, HANDLE hProcess) {
-    NTSTATUS                            status;
-    PSYSTEM_HANDLE_INFORMATION_EX       pHandleInfo = NULL;
-    DWORD                               dwInfoSize = 0x10000;
-    DWORD                               dwRet = 0;
-    PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX  hHandle = NULL;
-    DWORD                               i = 0;
-    BOOLEAN                             error = FALSE;
-    DWORD                               dwWait = 0;
-    PyObject*                           py_retlist = NULL;
-    PyObject*                           py_path = NULL;
-
-    if (g_initialized == FALSE)
-        psutil_get_open_files_init(TRUE);
-
-    // Due to the use of global variables, ensure only 1 call
-    // to psutil_get_open_files() is running
-    EnterCriticalSection(&g_cs);
-
-    if (__NtQuerySystemInformation == NULL ||
-        __NtQueryObject == NULL ||
-        g_hEvtStart == NULL ||
-        g_hEvtFinish == NULL)
-
-    {
-        PyErr_SetFromWindowsErr(0);
-        error = TRUE;
-        goto cleanup;
-    }
-
-    // Py_BuildValue raises an exception if NULL is returned
-    py_retlist = PyList_New(0);
-    if (py_retlist == NULL) {
-        error = TRUE;
-        goto cleanup;
-    }
-
-    do {
-        if (pHandleInfo != NULL) {
-            HeapFree(GetProcessHeap(), 0, pHandleInfo);
-            pHandleInfo = NULL;
-        }
-
-        // NtQuerySystemInformation won't give us the correct buffer size,
-        // so we guess by doubling the buffer size.
-        dwInfoSize *= 2;
-        pHandleInfo = HeapAlloc(GetProcessHeap(),
-                                HEAP_ZERO_MEMORY,
-                                dwInfoSize);
-
-        if (pHandleInfo == NULL) {
-            PyErr_NoMemory();
-            error = TRUE;
-            goto cleanup;
-        }
-    } while ((status = __NtQuerySystemInformation(
-                            SystemExtendedHandleInformation,
-                            pHandleInfo,
-                            dwInfoSize,
-                            &dwRet)) == STATUS_INFO_LENGTH_MISMATCH);
-
-    // NtQuerySystemInformation stopped giving us STATUS_INFO_LENGTH_MISMATCH
-    if (!NT_SUCCESS(status)) {
-        PyErr_SetFromWindowsErr(HRESULT_FROM_NT(status));
-        error = TRUE;
-        goto cleanup;
-    }
-
-    for (i = 0; i < pHandleInfo->NumberOfHandles; i++) {
-        hHandle = &pHandleInfo->Handles[i];
-
-        // Check if this hHandle belongs to the PID the user specified.
-        if (hHandle->UniqueProcessId != (HANDLE)dwPid ||
-            hHandle->ObjectTypeIndex != HANDLE_TYPE_FILE)
-            goto loop_cleanup;
-
-        if (!DuplicateHandle(hProcess,
-                             hHandle->HandleValue,
-                             GetCurrentProcess(),
-                             &g_hFile,
-                             0,
-                             TRUE,
-                             DUPLICATE_SAME_ACCESS))
-        {
-            /*
-            printf("[%d] DuplicateHandle (%#x): %#x \n",
-                   dwPid,
-                   hHandle->HandleValue,
-                   GetLastError());
-            */
-            goto loop_cleanup;
-        }
-
-        // Guess buffer size is MAX_PATH + 1
-        g_dwLength = (MAX_PATH+1) * sizeof(WCHAR);
-
-        do {
-            // Release any previously allocated buffer
-            if (g_pNameBuffer != NULL) {
-                HeapFree(GetProcessHeap(), 0, g_pNameBuffer);
-                g_pNameBuffer = NULL;
-                g_dwSize = 0;
-            }
-
-            // NtQueryObject puts the required buffer size in g_dwLength
-            // WinXP edge case puts g_dwLength == 0, just skip this handle
-            if (g_dwLength == 0)
-                goto loop_cleanup;
-
-            g_dwSize = g_dwLength;
-            if (g_dwSize > 0) {
-                g_pNameBuffer = HeapAlloc(GetProcessHeap(),
-                                          HEAP_ZERO_MEMORY,
-                                          g_dwSize);
-
-                if (g_pNameBuffer == NULL)
-                    goto loop_cleanup;
-            }
-
-            dwWait = psutil_NtQueryObject();
-
-            // If the call does not return, skip this handle
-            if (dwWait != WAIT_OBJECT_0)
-                goto loop_cleanup;
-
-        } while (g_status == STATUS_INFO_LENGTH_MISMATCH);
-
-        // NtQueryObject stopped returning STATUS_INFO_LENGTH_MISMATCH
-        if (!NT_SUCCESS(g_status))
-            goto loop_cleanup;
-
-        // Convert to PyUnicode and append it to the return list
-        if (g_pNameBuffer->Length > 0) {
-            /*
-            printf("[%d] Filename (%#x) %#d bytes: %S\n",
-                   dwPid,
-                   hHandle->HandleValue,
-                   g_pNameBuffer->Length,
-                   g_pNameBuffer->Buffer);
-            */
-
-            py_path = PyUnicode_FromWideChar(g_pNameBuffer->Buffer,
-                                                g_pNameBuffer->Length/2);
-            if (py_path == NULL) {
-                /*
-                printf("[%d] PyUnicode_FromWideChar (%#x): %#x \n",
-                       dwPid,
-                       hHandle->HandleValue,
-                       GetLastError());
-                */
-                error = TRUE;
-                goto loop_cleanup;
-            }
-
-            if (PyList_Append(py_retlist, py_path)) {
-                /*
-                printf("[%d] PyList_Append (%#x): %#x \n",
-                       dwPid,
-                       hHandle->HandleValue,
-                       GetLastError());
-                */
-                error = TRUE;
-                goto loop_cleanup;
-            }
-        }
-
-loop_cleanup:
-        Py_XDECREF(py_path);
-        py_path = NULL;
-
-        if (g_pNameBuffer != NULL)
-            HeapFree(GetProcessHeap(), 0, g_pNameBuffer);
-        g_pNameBuffer = NULL;
-        g_dwSize = 0;
-        g_dwLength = 0;
-
-        if (g_hFile != NULL)
-            CloseHandle(g_hFile);
-        g_hFile = NULL;
-    }
-
-cleanup:
-    if (g_pNameBuffer != NULL)
-        HeapFree(GetProcessHeap(), 0, g_pNameBuffer);
-    g_pNameBuffer = NULL;
-    g_dwSize = 0;
-    g_dwLength = 0;
-
-    if (g_hFile != NULL)
-        CloseHandle(g_hFile);
-    g_hFile = NULL;
-
-    if (pHandleInfo != NULL)
-        HeapFree(GetProcessHeap(), 0, pHandleInfo);
-    pHandleInfo = NULL;
-
-    if (error) {
-        Py_XDECREF(py_retlist);
-        py_retlist = NULL;
-    }
-
-    LeaveCriticalSection(&g_cs);
-
-    return py_retlist;
-}
-
-
-DWORD
-psutil_NtQueryObject() {
-    DWORD dwWait = 0;
-
-    if (g_hThread == NULL)
-        g_hThread = CreateThread(
-            NULL,
-            0,
-            (LPTHREAD_START_ROUTINE)psutil_NtQueryObjectThread,
-            NULL,
-            0,
-            NULL);
-    if (g_hThread == NULL)
-        return GetLastError();
-
-    // Signal the worker thread to start
-    SetEvent(g_hEvtStart);
-
-    // Wait for the worker thread to finish
-    dwWait = WaitForSingleObject(g_hEvtFinish, NTQO_TIMEOUT);
-
-    // If the thread hangs, kill it and cleanup
-    if (dwWait == WAIT_TIMEOUT) {
-        SuspendThread(g_hThread);
-        TerminateThread(g_hThread, 1);
-        WaitForSingleObject(g_hThread, INFINITE);
-        CloseHandle(g_hThread);
-
-        // Cleanup Fiber
-        if (g_fiber != NULL)
-            DeleteFiber(g_fiber);
-        g_fiber = NULL;
-
-        g_hThread = NULL;
-    }
-
-    return dwWait;
-}
-
-
-void
-psutil_NtQueryObjectThread() {
-    // Prevent the thread stack from leaking when this
-    // thread gets terminated due to NTQueryObject hanging
-    g_fiber = ConvertThreadToFiber(NULL);
-
-    // Loop infinitely waiting for work
-    while (TRUE) {
-        WaitForSingleObject(g_hEvtStart, INFINITE);
-
-        g_status = __NtQueryObject(g_hFile,
-                                   ObjectNameInformation,
-                                   g_pNameBuffer,
-                                   g_dwSize,
-                                   &g_dwLength);
-        SetEvent(g_hEvtFinish);
-    }
-}
-
-
-PyObject *
-psutil_get_open_files_getmappedfilename(long dwPid, HANDLE hProcess) {
-    NTSTATUS                            status;
-    PSYSTEM_HANDLE_INFORMATION_EX       pHandleInfo = NULL;
-    DWORD                               dwInfoSize = 0x10000;
-    DWORD                               dwRet = 0;
-    PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX  hHandle = NULL;
-    HANDLE                              hFile = NULL;
-    HANDLE                              hMap = NULL;
-    DWORD                               i = 0;
-    BOOLEAN                             error = FALSE;
-    PyObject*                           py_retlist = NULL;
-    PyObject*                           py_path = NULL;
-    ULONG                               dwSize = 0;
-    LPVOID                              pMem = NULL;
-    TCHAR                               pszFilename[MAX_PATH+1];
-
-    if (g_initialized == FALSE)
-        psutil_get_open_files_init(FALSE);
-
-    if (__NtQuerySystemInformation == NULL || __NtQueryObject == NULL) {
-        PyErr_SetFromWindowsErr(0);
-        error = TRUE;
-        goto cleanup;
-    }
-
-    // Py_BuildValue raises an exception if NULL is returned
-    py_retlist = PyList_New(0);
-    if (py_retlist == NULL) {
-        error = TRUE;
-        goto cleanup;
-    }
-
-    do {
-        if (pHandleInfo != NULL) {
-            HeapFree(GetProcessHeap(), 0, pHandleInfo);
-            pHandleInfo = NULL;
-        }
-
-        // NtQuerySystemInformation won't give us the correct buffer size,
-        // so we guess by doubling the buffer size.
-        dwInfoSize *= 2;
-        pHandleInfo = HeapAlloc(GetProcessHeap(),
-                                HEAP_ZERO_MEMORY,
-                                dwInfoSize);
-
-        if (pHandleInfo == NULL) {
-            PyErr_NoMemory();
-            error = TRUE;
-            goto cleanup;
-        }
-    } while ((status = __NtQuerySystemInformation(
-                            SystemExtendedHandleInformation,
-                            pHandleInfo,
-                            dwInfoSize,
-                            &dwRet)) == STATUS_INFO_LENGTH_MISMATCH);
-
-    // NtQuerySystemInformation stopped giving us STATUS_INFO_LENGTH_MISMATCH
-    if (!NT_SUCCESS(status)) {
-        PyErr_SetFromWindowsErr(HRESULT_FROM_NT(status));
-        error = TRUE;
-        goto cleanup;
-    }
-
-    for (i = 0; i < pHandleInfo->NumberOfHandles; i++) {
-        hHandle = &pHandleInfo->Handles[i];
-
-        // Check if this hHandle belongs to the PID the user specified.
-        if (hHandle->UniqueProcessId != (HANDLE)dwPid ||
-            hHandle->ObjectTypeIndex != HANDLE_TYPE_FILE)
-            goto loop_cleanup;
-
-        if (!DuplicateHandle(hProcess,
-                             hHandle->HandleValue,
-                             GetCurrentProcess(),
-                             &hFile,
-                             0,
-                             TRUE,
-                             DUPLICATE_SAME_ACCESS))
-        {
-            /*
-            printf("[%d] DuplicateHandle (%#x): %#x \n",
-                   dwPid,
-                   hHandle->HandleValue,
-                   GetLastError());
-            */
-            goto loop_cleanup;
-        }
-
-        hMap = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
-        if (hMap == NULL) {
-            /*
-            printf("[%d] CreateFileMapping (%#x): %#x \n",
-                   dwPid,
-                   hHandle->HandleValue,
-                   GetLastError());
-            */
-            goto loop_cleanup;
-        }
-
-        pMem = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 1);
-
-        if (pMem == NULL) {
-            /*
-            printf("[%d] MapViewOfFile (%#x): %#x \n",
-                   dwPid,
-                   hHandle->HandleValue,
-                   GetLastError());
-            */
-            goto loop_cleanup;
-        }
-
-        dwSize = GetMappedFileName(
-            GetCurrentProcess(), pMem, pszFilename, MAX_PATH);
-        if (dwSize == 0) {
-            /*
-            printf("[%d] GetMappedFileName (%#x): %#x \n",
-                   dwPid,
-                   hHandle->HandleValue,
-                   GetLastError());
-            */
-            goto loop_cleanup;
-        }
-
-        pszFilename[dwSize] = '\0';
-        /*
-        printf("[%d] Filename (%#x) %#d bytes: %S\n",
-               dwPid,
-               hHandle->HandleValue,
-               dwSize,
-               pszFilename);
-        */
-
-        py_path = PyUnicode_FromWideChar(pszFilename, dwSize);
-        if (py_path == NULL) {
-            /*
-            printf("[%d] PyUnicode_FromStringAndSize (%#x): %#x \n",
-                   dwPid,
-                   hHandle->HandleValue,
-                   GetLastError());
-            */
-            error = TRUE;
-            goto loop_cleanup;
-        }
-
-        if (PyList_Append(py_retlist, py_path)) {
-            /*
-            printf("[%d] PyList_Append (%#x): %#x \n",
-                   dwPid,
-                   hHandle->HandleValue,
-                   GetLastError());
-            */
-            error = TRUE;
-            goto loop_cleanup;
-        }
-
-loop_cleanup:
-        Py_XDECREF(py_path);
-        py_path = NULL;
-
-        if (pMem != NULL)
-            UnmapViewOfFile(pMem);
-        pMem = NULL;
-
-        if (hMap != NULL)
-            CloseHandle(hMap);
-        hMap = NULL;
-
-        if (hFile != NULL)
-            CloseHandle(hFile);
-        hFile = NULL;
-
-        dwSize = 0;
-    }
-
-cleanup:
-    if (pMem != NULL)
-        UnmapViewOfFile(pMem);
-    pMem = NULL;
-
-    if (hMap != NULL)
-        CloseHandle(hMap);
-    hMap = NULL;
-
-    if (hFile != NULL)
-        CloseHandle(hFile);
-    hFile = NULL;
-
-    if (pHandleInfo != NULL)
-        HeapFree(GetProcessHeap(), 0, pHandleInfo);
-    pHandleInfo = NULL;
-
-    if (error) {
-        Py_XDECREF(py_retlist);
-        py_retlist = NULL;
-    }
-
-    return py_retlist;
-}
diff --git a/psutil/arch/windows/process_handles.h b/psutil/arch/windows/process_handles.h
deleted file mode 100644
index ea5fbdbeb8..0000000000
--- a/psutil/arch/windows/process_handles.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
- * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef __PROCESS_HANDLES_H__
-#define __PROCESS_HANDLES_H__
-
-#ifndef UNICODE
-#define UNICODE
-#endif
-
-#include <Python.h>
-#include <stdio.h>
-#include <windows.h>
-#include <strsafe.h>
-#include <winternl.h>
-#include <psapi.h>
-
-
-#ifndef NT_SUCCESS
-#define NT_SUCCESS(x) ((x) >= 0)
-#endif
-
-#define STATUS_INFO_LENGTH_MISMATCH 0xc0000004
-#define ObjectBasicInformation 0
-#define ObjectNameInformation 1
-#define ObjectTypeInformation 2
-#define HANDLE_TYPE_FILE 28
-#define NTQO_TIMEOUT 100
-
-typedef NTSTATUS (NTAPI *_NtQuerySystemInformation)(
-    ULONG SystemInformationClass,
-    PVOID SystemInformation,
-    ULONG SystemInformationLength,
-    PULONG ReturnLength
-);
-
-typedef NTSTATUS (NTAPI *_NtQueryObject)(
-    HANDLE ObjectHandle,
-    ULONG ObjectInformationClass,
-    PVOID ObjectInformation,
-    ULONG ObjectInformationLength,
-    PULONG ReturnLength
-);
-
-// Undocumented FILE_INFORMATION_CLASS: FileNameInformation
-static const SYSTEM_INFORMATION_CLASS SystemExtendedHandleInformation = (SYSTEM_INFORMATION_CLASS)64;
-
-typedef struct _SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX {
-    PVOID Object;
-    HANDLE UniqueProcessId;
-    HANDLE HandleValue;
-    ULONG GrantedAccess;
-    USHORT CreatorBackTraceIndex;
-    USHORT ObjectTypeIndex;
-    ULONG HandleAttributes;
-    ULONG Reserved;
-} SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX, *PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX;
-
-typedef struct _SYSTEM_HANDLE_INFORMATION_EX {
-    ULONG_PTR NumberOfHandles;
-    ULONG_PTR Reserved;
-    SYSTEM_HANDLE_TABLE_ENTRY_INFO_EX Handles[1];
-} SYSTEM_HANDLE_INFORMATION_EX, *PSYSTEM_HANDLE_INFORMATION_EX;
-
-typedef enum _POOL_TYPE {
-    NonPagedPool,
-    PagedPool,
-    NonPagedPoolMustSucceed,
-    DontUseThisType,
-    NonPagedPoolCacheAligned,
-    PagedPoolCacheAligned,
-    NonPagedPoolCacheAlignedMustS
-} POOL_TYPE, *PPOOL_TYPE;
-
-typedef struct _OBJECT_TYPE_INFORMATION {
-    UNICODE_STRING Name;
-    ULONG TotalNumberOfObjects;
-    ULONG TotalNumberOfHandles;
-    ULONG TotalPagedPoolUsage;
-    ULONG TotalNonPagedPoolUsage;
-    ULONG TotalNamePoolUsage;
-    ULONG TotalHandleTableUsage;
-    ULONG HighWaterNumberOfObjects;
-    ULONG HighWaterNumberOfHandles;
-    ULONG HighWaterPagedPoolUsage;
-    ULONG HighWaterNonPagedPoolUsage;
-    ULONG HighWaterNamePoolUsage;
-    ULONG HighWaterHandleTableUsage;
-    ULONG InvalidAttributes;
-    GENERIC_MAPPING GenericMapping;
-    ULONG ValidAccess;
-    BOOLEAN SecurityRequired;
-    BOOLEAN MaintainHandleCount;
-    USHORT MaintainTypeList;
-    POOL_TYPE PoolType;
-    ULONG PagedPoolUsage;
-    ULONG NonPagedPoolUsage;
-} OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;
-
-PVOID GetLibraryProcAddress(PSTR LibraryName, PSTR ProcName);
-VOID psutil_get_open_files_init(BOOL threaded);
-PyObject* psutil_get_open_files(long pid, HANDLE processHandle);
-PyObject* psutil_get_open_files_ntqueryobject(long dwPid, HANDLE hProcess);
-PyObject* psutil_get_open_files_getmappedfilename(long dwPid, HANDLE hProcess);
-DWORD psutil_NtQueryObject(void);
-void psutil_NtQueryObjectThread(void);
-
-#endif // __PROCESS_HANDLES_H__
diff --git a/psutil/arch/windows/process_info.c b/psutil/arch/windows/process_info.c
deleted file mode 100644
index c127258174..0000000000
--- a/psutil/arch/windows/process_info.c
+++ /dev/null
@@ -1,857 +0,0 @@
-/*
- * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Helper functions related to fetching process information. Used by
- * _psutil_windows module methods.
- */
-
-#include <Python.h>
-#include <windows.h>
-#include <Psapi.h>
-#include <tlhelp32.h>
-
-#include "security.h"
-#include "process_info.h"
-#include "ntextapi.h"
-#include "../../_psutil_common.h"
-
-
-/*
- * A wrapper around OpenProcess setting NSP exception if process
- * no longer exists.
- * "pid" is the process pid, "dwDesiredAccess" is the first argument
- * exptected by OpenProcess.
- * Return a process handle or NULL.
- */
-HANDLE
-psutil_handle_from_pid_waccess(DWORD pid, DWORD dwDesiredAccess) {
-    HANDLE hProcess;
-    DWORD processExitCode = 0;
-
-    if (pid == 0) {
-        // otherwise we'd get NoSuchProcess
-        return AccessDenied();
-    }
-
-    hProcess = OpenProcess(dwDesiredAccess, FALSE, pid);
-    if (hProcess == NULL) {
-        if (GetLastError() == ERROR_INVALID_PARAMETER)
-            NoSuchProcess();
-        else
-            PyErr_SetFromWindowsErr(0);
-        return NULL;
-    }
-
-    // make sure the process is running
-    GetExitCodeProcess(hProcess, &processExitCode);
-    if (processExitCode == 0) {
-        NoSuchProcess();
-        CloseHandle(hProcess);
-        return NULL;
-    }
-    return hProcess;
-}
-
-
-/*
- * Same as psutil_handle_from_pid_waccess but implicitly uses
- * PROCESS_QUERY_INFORMATION | PROCESS_VM_READ as dwDesiredAccess
- * parameter for OpenProcess.
- */
-HANDLE
-psutil_handle_from_pid(DWORD pid) {
-    DWORD dwDesiredAccess = PROCESS_QUERY_INFORMATION | PROCESS_VM_READ;
-    return psutil_handle_from_pid_waccess(pid, dwDesiredAccess);
-}
-
-
-DWORD *
-psutil_get_pids(DWORD *numberOfReturnedPIDs) {
-    // Win32 SDK says the only way to know if our process array
-    // wasn't large enough is to check the returned size and make
-    // sure that it doesn't match the size of the array.
-    // If it does we allocate a larger array and try again
-
-    // Stores the actual array
-    DWORD *procArray = NULL;
-    DWORD procArrayByteSz;
-    int procArraySz = 0;
-
-    // Stores the byte size of the returned array from enumprocesses
-    DWORD enumReturnSz = 0;
-
-    do {
-        procArraySz += 1024;
-        free(procArray);
-        procArrayByteSz = procArraySz * sizeof(DWORD);
-        procArray = malloc(procArrayByteSz);
-        if (procArray == NULL) {
-            PyErr_NoMemory();
-            return NULL;
-        }
-        if (! EnumProcesses(procArray, procArrayByteSz, &enumReturnSz)) {
-            free(procArray);
-            PyErr_SetFromWindowsErr(0);
-            return NULL;
-        }
-    } while (enumReturnSz == procArraySz * sizeof(DWORD));
-
-    // The number of elements is the returned size / size of each element
-    *numberOfReturnedPIDs = enumReturnSz / sizeof(DWORD);
-
-    return procArray;
-}
-
-
-int
-psutil_pid_is_running(DWORD pid) {
-    HANDLE hProcess;
-    DWORD exitCode;
-
-    // Special case for PID 0 System Idle Process
-    if (pid == 0)
-        return 1;
-    if (pid < 0)
-        return 0;
-
-    hProcess = OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ,
-                           FALSE, pid);
-    if (NULL == hProcess) {
-        // invalid parameter is no such process
-        if (GetLastError() == ERROR_INVALID_PARAMETER) {
-            CloseHandle(hProcess);
-            return 0;
-        }
-
-        // access denied obviously means there's a process to deny access to...
-        if (GetLastError() == ERROR_ACCESS_DENIED) {
-            CloseHandle(hProcess);
-            return 1;
-        }
-
-        CloseHandle(hProcess);
-        PyErr_SetFromWindowsErr(0);
-        return -1;
-    }
-
-    if (GetExitCodeProcess(hProcess, &exitCode)) {
-        CloseHandle(hProcess);
-        return (exitCode == STILL_ACTIVE);
-    }
-
-    // access denied means there's a process there so we'll assume
-    // it's running
-    if (GetLastError() == ERROR_ACCESS_DENIED) {
-        CloseHandle(hProcess);
-        return 1;
-    }
-
-    PyErr_SetFromWindowsErr(0);
-    CloseHandle(hProcess);
-    return -1;
-}
-
-
-int
-psutil_pid_in_proclist(DWORD pid) {
-    DWORD *proclist = NULL;
-    DWORD numberOfReturnedPIDs;
-    DWORD i;
-
-    proclist = psutil_get_pids(&numberOfReturnedPIDs);
-    if (proclist == NULL)
-        return -1;
-    for (i = 0; i < numberOfReturnedPIDs; i++) {
-        if (pid == proclist[i]) {
-            free(proclist);
-            return 1;
-        }
-    }
-
-    free(proclist);
-    return 0;
-}
-
-
-// Check exit code from a process handle. Return FALSE on an error also
-// XXX - not used anymore
-int
-handlep_is_running(HANDLE hProcess) {
-    DWORD dwCode;
-
-    if (NULL == hProcess)
-        return 0;
-    if (GetExitCodeProcess(hProcess, &dwCode)) {
-        if (dwCode == STILL_ACTIVE)
-            return 1;
-    }
-    return 0;
-}
-
-// Helper structures to access the memory correctly.  Some of these might also
-// be defined in the winternl.h header file but unfortunately not in a usable
-// way.
-
-// see http://msdn2.microsoft.com/en-us/library/aa489609.aspx
-#ifndef NT_SUCCESS
-#define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)
-#endif
-
-// http://msdn.microsoft.com/en-us/library/aa813741(VS.85).aspx
-typedef struct {
-    BYTE Reserved1[16];
-    PVOID Reserved2[5];
-    UNICODE_STRING CurrentDirectoryPath;
-    PVOID CurrentDirectoryHandle;
-    UNICODE_STRING DllPath;
-    UNICODE_STRING ImagePathName;
-    UNICODE_STRING CommandLine;
-    LPCWSTR env;
-} RTL_USER_PROCESS_PARAMETERS_, *PRTL_USER_PROCESS_PARAMETERS_;
-
-// https://msdn.microsoft.com/en-us/library/aa813706(v=vs.85).aspx
-#ifdef _WIN64
-typedef struct {
-    BYTE Reserved1[2];
-    BYTE BeingDebugged;
-    BYTE Reserved2[21];
-    PVOID LoaderData;
-    PRTL_USER_PROCESS_PARAMETERS_ ProcessParameters;
-    /* More fields ...  */
-} PEB_;
-#else
-typedef struct {
-    BYTE Reserved1[2];
-    BYTE BeingDebugged;
-    BYTE Reserved2[1];
-    PVOID Reserved3[2];
-    PVOID Ldr;
-    PRTL_USER_PROCESS_PARAMETERS_ ProcessParameters;
-    /* More fields ...  */
-} PEB_;
-#endif
-
-#ifdef _WIN64
-/* When we are a 64 bit process accessing a 32 bit (WoW64) process we need to
-   use the 32 bit structure layout. */
-typedef struct {
-    USHORT Length;
-    USHORT MaxLength;
-    DWORD Buffer;
-} UNICODE_STRING32;
-
-typedef struct {
-    BYTE Reserved1[16];
-    DWORD Reserved2[5];
-    UNICODE_STRING32 CurrentDirectoryPath;
-    DWORD CurrentDirectoryHandle;
-    UNICODE_STRING32 DllPath;
-    UNICODE_STRING32 ImagePathName;
-    UNICODE_STRING32 CommandLine;
-    DWORD env;
-} RTL_USER_PROCESS_PARAMETERS32;
-
-typedef struct {
-    BYTE Reserved1[2];
-    BYTE BeingDebugged;
-    BYTE Reserved2[1];
-    DWORD Reserved3[2];
-    DWORD Ldr;
-    DWORD ProcessParameters;
-    /* More fields ...  */
-} PEB32;
-#else
-/* When we are a 32 bit (WoW64) process accessing a 64 bit process we need to
-   use the 64 bit structure layout and a special function to read its memory.
-   */
-typedef NTSTATUS (NTAPI *_NtWow64ReadVirtualMemory64)(
-        IN HANDLE ProcessHandle,
-        IN PVOID64 BaseAddress,
-        OUT PVOID Buffer,
-        IN ULONG64 Size,
-        OUT PULONG64 NumberOfBytesRead);
-
-typedef enum {
-    MemoryInformationBasic
-} MEMORY_INFORMATION_CLASS;
-
-typedef NTSTATUS (NTAPI *_NtWow64QueryVirtualMemory64)(
-    IN HANDLE ProcessHandle,
-    IN PVOID64 BaseAddress,
-    IN MEMORY_INFORMATION_CLASS MemoryInformationClass,
-    OUT PMEMORY_BASIC_INFORMATION64 MemoryInformation,
-    IN ULONG64 Size,
-    OUT PULONG64 ReturnLength OPTIONAL);
-
-typedef struct {
-    PVOID Reserved1[2];
-    PVOID64 PebBaseAddress;
-    PVOID Reserved2[4];
-    PVOID UniqueProcessId[2];
-    PVOID Reserved3[2];
-} PROCESS_BASIC_INFORMATION64;
-
-typedef struct {
-    USHORT Length;
-    USHORT MaxLength;
-    PVOID64 Buffer;
-} UNICODE_STRING64;
-
-typedef struct {
-    BYTE Reserved1[16];
-    PVOID64 Reserved2[5];
-    UNICODE_STRING64 CurrentDirectoryPath;
-    PVOID64 CurrentDirectoryHandle;
-    UNICODE_STRING64 DllPath;
-    UNICODE_STRING64 ImagePathName;
-    UNICODE_STRING64 CommandLine;
-    PVOID64 env;
-} RTL_USER_PROCESS_PARAMETERS64;
-
-typedef struct {
-    BYTE Reserved1[2];
-    BYTE BeingDebugged;
-    BYTE Reserved2[21];
-    PVOID64 LoaderData;
-    PVOID64 ProcessParameters;
-    /* More fields ...  */
-} PEB64;
-#endif
-
-/* Given a pointer into a process's memory, figure out how much data can be
- * read from it. */
-static int psutil_get_process_region_size(HANDLE hProcess,
-                                          LPCVOID src,
-                                          SIZE_T *psize) {
-    MEMORY_BASIC_INFORMATION info;
-
-    if (!VirtualQueryEx(hProcess, src, &info, sizeof(info))) {
-        PyErr_SetFromWindowsErr(0);
-        return -1;
-    }
-
-    *psize = info.RegionSize - ((char*)src - (char*)info.BaseAddress);
-    return 0;
-}
-
-
-#ifndef _WIN64
-/* Given a pointer into a process's memory, figure out how much data can be
- * read from it. */
-static int psutil_get_process_region_size64(HANDLE hProcess,
-                                           const PVOID64 src64,
-                                           PULONG64 psize) {
-    static _NtWow64QueryVirtualMemory64 NtWow64QueryVirtualMemory64 = NULL;
-    MEMORY_BASIC_INFORMATION64 info64;
-
-    if (NtWow64QueryVirtualMemory64 == NULL) {
-        NtWow64QueryVirtualMemory64 =
-            (_NtWow64QueryVirtualMemory64)GetProcAddress(
-                    GetModuleHandleA("ntdll.dll"),
-                    "NtWow64QueryVirtualMemory64");
-
-        if (NtWow64QueryVirtualMemory64 == NULL) {
-            PyErr_SetString(PyExc_NotImplementedError,
-                    "NtWow64QueryVirtualMemory64 missing");
-            return -1;
-        }
-    }
-
-    if (!NT_SUCCESS(NtWow64QueryVirtualMemory64(
-                    hProcess,
-                    src64,
-                    0,
-                    &info64,
-                    sizeof(info64),
-                    NULL))) {
-        PyErr_SetFromWindowsErr(0);
-        return -1;
-    }
-
-    *psize = info64.RegionSize - ((char*)src64 - (char*)info64.BaseAddress);
-    return 0;
-}
-#endif
-
-
-enum psutil_process_data_kind {
-    KIND_CMDLINE,
-    KIND_CWD,
-    KIND_ENVIRON,
-};
-
-/* Get data from the process with the given pid.  The data is returned in the
-   pdata output member as a nul terminated string which must be freed on
-   success.
-
-   On success 0 is returned.  On error the output parameter is not touched, -1
-   is returned, and an appropriate Python exception is set. */
-static int psutil_get_process_data(long pid,
-                                   enum psutil_process_data_kind kind,
-                                   WCHAR **pdata,
-                                   SIZE_T *psize) {
-    /* This function is quite complex because there are several cases to be
-       considered:
-
-       Two cases are really simple:  we (i.e. the python interpreter) and the
-       target process are both 32 bit or both 64 bit.  In that case the memory
-       layout of the structures matches up and all is well.
-
-       When we are 64 bit and the target process is 32 bit we need to use
-       custom 32 bit versions of the structures.
-
-       When we are 32 bit and the target process is 64 bit we need to use
-       custom 64 bit version of the structures.  Also we need to use separate
-       Wow64 functions to get the information.
-
-       A few helper structs are defined above so that the compiler can handle
-       calculating the correct offsets.
-
-       Additional help also came from the following sources:
-
-         https://github.com/kohsuke/winp and
-         http://wj32.org/wp/2009/01/24/howto-get-the-command-line-of-processes/
-         http://stackoverflow.com/a/14012919
-         http://www.drdobbs.com/embracing-64-bit-windows/184401966
-     */
-    static _NtQueryInformationProcess NtQueryInformationProcess = NULL;
-#ifndef _WIN64
-    static _NtQueryInformationProcess NtWow64QueryInformationProcess64 = NULL;
-    static _NtWow64ReadVirtualMemory64 NtWow64ReadVirtualMemory64 = NULL;
-#endif
-    HANDLE hProcess = NULL;
-    LPCVOID src;
-    SIZE_T size;
-    WCHAR *buffer = NULL;
-#ifdef _WIN64
-    LPVOID ppeb32 = NULL;
-#else
-    PVOID64 src64;
-    BOOL weAreWow64;
-    BOOL theyAreWow64;
-#endif
-
-    hProcess = psutil_handle_from_pid(pid);
-    if (hProcess == NULL)
-        return -1;
-
-    if (NtQueryInformationProcess == NULL) {
-        NtQueryInformationProcess = (_NtQueryInformationProcess)GetProcAddress(
-                GetModuleHandleA("ntdll.dll"), "NtQueryInformationProcess");
-    }
-
-#ifdef _WIN64
-    /* 64 bit case.  Check if the target is a 32 bit process running in WoW64
-     * mode. */
-    if (!NT_SUCCESS(NtQueryInformationProcess(hProcess,
-                                              ProcessWow64Information,
-                                              &ppeb32,
-                                              sizeof(LPVOID),
-                                              NULL))) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    if (ppeb32 != NULL) {
-        /* We are 64 bit.  Target process is 32 bit running in WoW64 mode. */
-        PEB32 peb32;
-        RTL_USER_PROCESS_PARAMETERS32 procParameters32;
-
-        // read PEB
-        if (!ReadProcessMemory(hProcess, ppeb32, &peb32, sizeof(peb32), NULL)) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-
-        // read process parameters
-        if (!ReadProcessMemory(hProcess,
-                              UlongToPtr(peb32.ProcessParameters),
-                              &procParameters32,
-                              sizeof(procParameters32),
-                              NULL)) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-
-        switch (kind) {
-            case KIND_CMDLINE:
-                src = UlongToPtr(procParameters32.CommandLine.Buffer),
-                size = procParameters32.CommandLine.Length;
-                break;
-            case KIND_CWD:
-                src = UlongToPtr(procParameters32.CurrentDirectoryPath.Buffer);
-                size = procParameters32.CurrentDirectoryPath.Length;
-                break;
-            case KIND_ENVIRON:
-                src = UlongToPtr(procParameters32.env);
-                break;
-        }
-    } else
-#else
-    /* 32 bit case.  Check if the target is also 32 bit. */
-    if (!IsWow64Process(GetCurrentProcess(), &weAreWow64) ||
-        !IsWow64Process(hProcess, &theyAreWow64)) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    if (weAreWow64 && !theyAreWow64) {
-        /* We are 32 bit running in WoW64 mode.  Target process is 64 bit. */
-        PROCESS_BASIC_INFORMATION64 pbi64;
-        PEB64 peb64;
-        RTL_USER_PROCESS_PARAMETERS64 procParameters64;
-
-        if (NtWow64QueryInformationProcess64 == NULL) {
-            NtWow64QueryInformationProcess64 =
-                (_NtQueryInformationProcess)GetProcAddress(
-                        GetModuleHandleA("ntdll.dll"),
-                        "NtWow64QueryInformationProcess64");
-
-            if (NtWow64QueryInformationProcess64 == NULL) {
-                PyErr_SetString(PyExc_NotImplementedError,
-                                "NtWow64QueryInformationProcess64 missing");
-                goto error;
-            }
-        }
-
-        if (!NT_SUCCESS(NtWow64QueryInformationProcess64(
-                        hProcess,
-                        ProcessBasicInformation,
-                        &pbi64,
-                        sizeof(pbi64),
-                        NULL))) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-
-        // read peb
-        if (NtWow64ReadVirtualMemory64 == NULL) {
-            NtWow64ReadVirtualMemory64 =
-                (_NtWow64ReadVirtualMemory64)GetProcAddress(
-                        GetModuleHandleA("ntdll.dll"),
-                        "NtWow64ReadVirtualMemory64");
-
-            if (NtWow64ReadVirtualMemory64 == NULL) {
-                PyErr_SetString(PyExc_NotImplementedError,
-                                "NtWow64ReadVirtualMemory64 missing");
-                goto error;
-            }
-        }
-
-        if (!NT_SUCCESS(NtWow64ReadVirtualMemory64(hProcess,
-                                                   pbi64.PebBaseAddress,
-                                                   &peb64,
-                                                   sizeof(peb64),
-                                                   NULL))) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-
-        // read process parameters
-        if (!NT_SUCCESS(NtWow64ReadVirtualMemory64(hProcess,
-                                                   peb64.ProcessParameters,
-                                                   &procParameters64,
-                                                   sizeof(procParameters64),
-                                                   NULL))) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-
-        switch (kind) {
-            case KIND_CMDLINE:
-                src64 = procParameters64.CommandLine.Buffer;
-                size = procParameters64.CommandLine.Length;
-                break;
-            case KIND_CWD:
-                src64 = procParameters64.CurrentDirectoryPath.Buffer,
-                size = procParameters64.CurrentDirectoryPath.Length;
-                break;
-            case KIND_ENVIRON:
-                src64 = procParameters64.env;
-                break;
-        }
-    } else
-#endif
-
-    /* Target process is of the same bitness as us. */
-    {
-        PROCESS_BASIC_INFORMATION pbi;
-        PEB_ peb;
-        RTL_USER_PROCESS_PARAMETERS_ procParameters;
-
-        if (!NT_SUCCESS(NtQueryInformationProcess(hProcess,
-                                                  ProcessBasicInformation,
-                                                  &pbi,
-                                                  sizeof(pbi),
-                                                  NULL))) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-
-        // read peb
-        if (!ReadProcessMemory(hProcess,
-                               pbi.PebBaseAddress,
-                               &peb,
-                               sizeof(peb),
-                               NULL)) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-
-        // read process parameters
-        if (!ReadProcessMemory(hProcess,
-                               peb.ProcessParameters,
-                               &procParameters,
-                               sizeof(procParameters),
-                               NULL)) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-
-        switch (kind) {
-            case KIND_CMDLINE:
-                src = procParameters.CommandLine.Buffer;
-                size = procParameters.CommandLine.Length;
-                break;
-            case KIND_CWD: 
-                src = procParameters.CurrentDirectoryPath.Buffer;
-                size = procParameters.CurrentDirectoryPath.Length;
-                break;
-            case KIND_ENVIRON:
-                src = procParameters.env;
-                break;
-        }
-    }
-
-    if (kind == KIND_ENVIRON) {
-#ifndef _WIN64
-        if (weAreWow64 && !theyAreWow64) {
-            ULONG64 size64;
-
-            if (psutil_get_process_region_size64(hProcess, src64, &size64) != 0)
-                goto error;
-
-            size = (SIZE_T)size64;
-        }
-        else
-#endif
-        if (psutil_get_process_region_size(hProcess, src, &size) != 0)
-            goto error;
-    }
-
-    buffer = calloc(size + 2, 1);
-
-    if (buffer == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-#ifndef _WIN64
-    if (weAreWow64 && !theyAreWow64) {
-        if (!NT_SUCCESS(NtWow64ReadVirtualMemory64(hProcess,
-                                                   src64,
-                                                   buffer,
-                                                   size,
-                                                   NULL))) {
-            PyErr_SetFromWindowsErr(0);
-            goto error;
-        }
-    } else
-#endif
-    if (!ReadProcessMemory(hProcess, src, buffer, size, NULL)) {
-        PyErr_SetFromWindowsErr(0);
-        goto error;
-    }
-
-    CloseHandle(hProcess);
-
-    *pdata = buffer;
-    *psize = size;
-
-    return 0;
-
-error:
-    if (hProcess != NULL)
-        CloseHandle(hProcess);
-    if (buffer != NULL)
-        free(buffer);
-    return -1;
-}
-
-/*
- * returns a Python list representing the arguments for the process
- * with given pid or NULL on error.
- */
-PyObject *
-psutil_get_cmdline(long pid) {
-    PyObject *ret = NULL;
-    WCHAR *data = NULL;
-    SIZE_T size;
-    PyObject *py_retlist = NULL;
-    PyObject *py_unicode = NULL;
-    LPWSTR *szArglist = NULL;
-    int nArgs, i;
-
-    if (psutil_get_process_data(pid, KIND_CMDLINE, &data, &size) != 0)
-        goto out;
-
-    // attempt to parse the command line using Win32 API
-    szArglist = CommandLineToArgvW(data, &nArgs);
-    if (szArglist == NULL) {
-        PyErr_SetFromWindowsErr(0);
-        goto out;
-    }
-
-    // arglist parsed as array of UNICODE_STRING, so convert each to
-    // Python string object and add to arg list
-    py_retlist = PyList_New(nArgs);
-    if (py_retlist == NULL)
-        goto out;
-    for (i = 0; i < nArgs; i++) {
-        py_unicode = PyUnicode_FromWideChar(szArglist[i],
-                                            wcslen(szArglist[i]));
-        if (py_unicode == NULL)
-            goto out;
-        PyList_SET_ITEM(py_retlist, i, py_unicode);
-        py_unicode = NULL;
-    }
-
-    ret = py_retlist;
-    py_retlist = NULL;
-
-out:
-    LocalFree(szArglist);
-    free(data);
-    Py_XDECREF(py_unicode);
-    Py_XDECREF(py_retlist);
-
-    return ret;
-}
-
-PyObject *psutil_get_cwd(long pid) {
-    PyObject *ret = NULL;
-    WCHAR *data = NULL;
-    SIZE_T size;
-
-    if (psutil_get_process_data(pid, KIND_CWD, &data, &size) != 0)
-        goto out;
-
-    // convert wchar array to a Python unicode string
-    ret = PyUnicode_FromWideChar(data, wcslen(data));
-
-out:
-    free(data);
-
-    return ret;
-}
-
-/*
- * returns a Python string containing the environment variable data for the
- * process with given pid or NULL on error.
- */
-PyObject *psutil_get_environ(long pid) {
-    PyObject *ret = NULL;
-    WCHAR *data = NULL;
-    SIZE_T size;
-
-    if (psutil_get_process_data(pid, KIND_ENVIRON, &data, &size) != 0)
-        goto out;
-
-    // convert wchar array to a Python unicode string
-    ret = PyUnicode_FromWideChar(data, size / 2);
-
-out:
-    free(data);
-
-    return ret;
-}
-
-#define PH_FIRST_PROCESS(Processes) ((PSYSTEM_PROCESS_INFORMATION)(Processes))
-#define PH_NEXT_PROCESS(Process) ( \
-   ((PSYSTEM_PROCESS_INFORMATION)(Process))->NextEntryOffset ? \
-   (PSYSTEM_PROCESS_INFORMATION)((PCHAR)(Process) + \
-        ((PSYSTEM_PROCESS_INFORMATION)(Process))->NextEntryOffset) : \
-   NULL)
-
-const int STATUS_INFO_LENGTH_MISMATCH = 0xC0000004;
-const int STATUS_BUFFER_TOO_SMALL = 0xC0000023L;
-
-/*
- * Given a process PID and a PSYSTEM_PROCESS_INFORMATION structure
- * fills the structure with various process information by using
- * NtQuerySystemInformation.
- * We use this as a fallback when faster functions fail with access
- * denied. This is slower because it iterates over all processes.
- * On success return 1, else 0 with Python exception already set.
- */
-int
-psutil_get_proc_info(DWORD pid, PSYSTEM_PROCESS_INFORMATION *retProcess,
-                     PVOID *retBuffer) {
-    static ULONG initialBufferSize = 0x4000;
-    NTSTATUS status;
-    PVOID buffer;
-    ULONG bufferSize;
-    PSYSTEM_PROCESS_INFORMATION process;
-
-    // get NtQuerySystemInformation
-    typedef DWORD (_stdcall * NTQSI_PROC) (int, PVOID, ULONG, PULONG);
-    NTQSI_PROC NtQuerySystemInformation;
-    HINSTANCE hNtDll;
-    hNtDll = LoadLibrary(TEXT("ntdll.dll"));
-    NtQuerySystemInformation = (NTQSI_PROC)GetProcAddress(
-        hNtDll, "NtQuerySystemInformation");
-
-    bufferSize = initialBufferSize;
-    buffer = malloc(bufferSize);
-    if (buffer == NULL) {
-        PyErr_NoMemory();
-        goto error;
-    }
-
-    while (TRUE) {
-        status = NtQuerySystemInformation(SystemProcessInformation, buffer,
-                                          bufferSize, &bufferSize);
-
-        if (status == STATUS_BUFFER_TOO_SMALL ||
-                status == STATUS_INFO_LENGTH_MISMATCH)
-        {
-            free(buffer);
-            buffer = malloc(bufferSize);
-            if (buffer == NULL) {
-                PyErr_NoMemory();
-                goto error;
-            }
-        }
-        else {
-            break;
-        }
-    }
-
-    if (status != 0) {
-        PyErr_Format(PyExc_RuntimeError, "NtQuerySystemInformation() failed");
-        goto error;
-    }
-
-    if (bufferSize <= 0x20000)
-        initialBufferSize = bufferSize;
-
-    process = PH_FIRST_PROCESS(buffer);
-    do {
-        if (process->UniqueProcessId == (HANDLE)pid) {
-            *retProcess = process;
-            *retBuffer = buffer;
-            return 1;
-        }
-    } while ( (process = PH_NEXT_PROCESS(process)) );
-
-    NoSuchProcess();
-    goto error;
-
-error:
-    FreeLibrary(hNtDll);
-    if (buffer != NULL)
-        free(buffer);
-    return 0;
-}
diff --git a/psutil/arch/windows/process_info.h b/psutil/arch/windows/process_info.h
deleted file mode 100644
index f9af7765bc..0000000000
--- a/psutil/arch/windows/process_info.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#if !defined(__PROCESS_INFO_H)
-#define __PROCESS_INFO_H
-
-#include <Python.h>
-#include <windows.h>
-#include "security.h"
-#include "ntextapi.h"
-
-DWORD* psutil_get_pids(DWORD *numberOfReturnedPIDs);
-HANDLE psutil_handle_from_pid(DWORD pid);
-HANDLE psutil_handle_from_pid_waccess(DWORD pid, DWORD dwDesiredAccess);
-int psutil_handlep_is_running(HANDLE hProcess);
-int psutil_pid_in_proclist(DWORD pid);
-int psutil_pid_is_running(DWORD pid);
-PyObject* psutil_get_cmdline(long pid);
-PyObject* psutil_get_cwd(long pid);
-PyObject* psutil_get_environ(long pid);
-int psutil_get_proc_info(DWORD pid, PSYSTEM_PROCESS_INFORMATION *retProcess,
-                         PVOID *retBuffer);
-
-#endif
diff --git a/psutil/arch/windows/security.c b/psutil/arch/windows/security.c
index 331d96223c..09bed0660a 100644
--- a/psutil/arch/windows/security.c
+++ b/psutil/arch/windows/security.c
@@ -2,137 +2,53 @@
  * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
- *
- * Security related functions for Windows platform (Set privileges such as
- * SeDebug), as well as security helper functions.
  */
 
-#include <windows.h>
-#include <Python.h>
-
-
-/*
- * Convert a process handle to a process token handle.
- */
-HANDLE
-psutil_token_from_handle(HANDLE hProcess) {
-    HANDLE hToken = NULL;
-
-    if (! OpenProcessToken(hProcess, TOKEN_QUERY, &hToken))
-        return PyErr_SetFromWindowsErr(0);
-    return hToken;
-}
-
-
-/*
- * http://www.ddj.com/windows/184405986
- *
- * There's a way to determine whether we're running under the Local System
- * account. However (you guessed it), we have to call more Win32 functions to
- * determine this. Backing up through the code listing, we need to make another
- * call to GetTokenInformation, but instead of passing through the TOKEN_USER
- * constant, we pass through the TOKEN_PRIVILEGES constant. This value returns
- * an array of privileges that the account has in the environment. Iterating
- * through the array, we call the function LookupPrivilegeName looking for the
- * string “SeTcbPrivilege. If the function returns this string, then this
- * account has Local System privileges
- */
-int
-psutil_has_system_privilege(HANDLE hProcess) {
-    DWORD i;
-    DWORD dwSize = 0;
-    DWORD dwRetval = 0;
-    TCHAR privName[256];
-    DWORD dwNameSize = 256;
-    // PTOKEN_PRIVILEGES tp = NULL;
-    BYTE *pBuffer = NULL;
-    TOKEN_PRIVILEGES *tp = NULL;
-    HANDLE hToken = psutil_token_from_handle(hProcess);
-
-    if (NULL == hToken)
-        return -1;
-    // call GetTokenInformation first to get the buffer size
-    if (! GetTokenInformation(hToken, TokenPrivileges, NULL, 0, &dwSize)) {
-        dwRetval = GetLastError();
-        // if it failed for a reason other than the buffer, bail out
-        if (dwRetval != ERROR_INSUFFICIENT_BUFFER ) {
-            PyErr_SetFromWindowsErr(dwRetval);
-            return 0;
-        }
-    }
-
-    // allocate buffer and call GetTokenInformation again
-    // tp = (PTOKEN_PRIVILEGES) GlobalAlloc(GPTR, dwSize);
-    pBuffer = (BYTE *) malloc(dwSize);
-    if (pBuffer == NULL) {
-        PyErr_NoMemory();
-        return -1;
-    }
-
-    if (! GetTokenInformation(hToken, TokenPrivileges, pBuffer,
-                              dwSize, &dwSize))
-    {
-        PyErr_SetFromWindowsErr(0);
-        free(pBuffer);
-        return -1;
-    }
-
-    // convert the BYTE buffer to a TOKEN_PRIVILEGES struct pointer
-    tp = (TOKEN_PRIVILEGES *)pBuffer;
-
-    // check all the privileges looking for SeTcbPrivilege
-    for (i = 0; i < tp->PrivilegeCount; i++) {
-        // reset the buffer contents and the buffer size
-        strcpy(privName, "");
-        dwNameSize = sizeof(privName) / sizeof(TCHAR);
-        if (! LookupPrivilegeName(NULL,
-                                  &tp->Privileges[i].Luid,
-                                  (LPTSTR)privName,
-                                  &dwNameSize))
-        {
-            PyErr_SetFromWindowsErr(0);
-            free(pBuffer);
-            return -1;
-        }
+// Security related functions for Windows platform (Set privileges such
+// as SE DEBUG).
 
-        // if we find the SeTcbPrivilege then it's a LocalSystem process
-        if (! lstrcmpi(privName, TEXT("SeTcbPrivilege"))) {
-            free(pBuffer);
-            return 1;
-        }
-    }
+#include <Python.h>
+#include <windows.h>
 
-    free(pBuffer);
-    return 0;
-}
+#include "../../arch/all/init.h"
 
 
-BOOL
+// Enable or disable `Privilege` on `hToken`. Return 0 on success, else
+// the Win32 error code.
+static DWORD
 psutil_set_privilege(HANDLE hToken, LPCTSTR Privilege, BOOL bEnablePrivilege) {
     TOKEN_PRIVILEGES tp;
     LUID luid;
-    TOKEN_PRIVILEGES tpPrevious;
+    // Zeroed because AdjustTokenPrivileges() leaves Privileges[0]
+    // untouched when the token doesn't hold the privilege, and we OR
+    // into its Attributes below.
+    TOKEN_PRIVILEGES tpPrevious = {0};
     DWORD cbPrevious = sizeof(TOKEN_PRIVILEGES);
 
-    if (!LookupPrivilegeValue( NULL, Privilege, &luid )) return FALSE;
+    if (!LookupPrivilegeValue(NULL, Privilege, &luid)) {
+        psutil_debug("LookupPrivilegeValue() failed");
+        return GetLastError();
+    }
 
     // first pass.  get current privilege setting
     tp.PrivilegeCount = 1;
     tp.Privileges[0].Luid = luid;
     tp.Privileges[0].Attributes = 0;
 
-    AdjustTokenPrivileges(
-        hToken,
-        FALSE,
-        &tp,
-        sizeof(TOKEN_PRIVILEGES),
-        &tpPrevious,
-        &cbPrevious
-    );
-
-    if (GetLastError() != ERROR_SUCCESS) return FALSE;
+    if (!AdjustTokenPrivileges(
+            hToken,
+            FALSE,
+            &tp,
+            sizeof(TOKEN_PRIVILEGES),
+            &tpPrevious,
+            &cbPrevious
+        ))
+    {
+        psutil_debug("AdjustTokenPrivileges() failed (1/2)");
+        return GetLastError();
+    }
 
-    // second pass. set privilege based on previous setting
+    // Second pass. Set privilege based on previous setting.
     tpPrevious.PrivilegeCount = 1;
     tpPrevious.Privileges[0].Luid = luid;
 
@@ -142,84 +58,90 @@ psutil_set_privilege(HANDLE hToken, LPCTSTR Privilege, BOOL bEnablePrivilege) {
         tpPrevious.Privileges[0].Attributes ^=
             (SE_PRIVILEGE_ENABLED & tpPrevious.Privileges[0].Attributes);
 
-    AdjustTokenPrivileges(
-        hToken,
-        FALSE,
-        &tpPrevious,
-        cbPrevious,
-        NULL,
-        NULL
-    );
-
-    if (GetLastError() != ERROR_SUCCESS) return FALSE;
+    if (!AdjustTokenPrivileges(
+            hToken, FALSE, &tpPrevious, cbPrevious, NULL, NULL
+        ))
+    {
+        psutil_debug("AdjustTokenPrivileges() failed (2/2)");
+        return GetLastError();
+    }
 
-    return TRUE;
+    return 0;
 }
 
 
-int
-psutil_set_se_debug() {
-    HANDLE hToken;
-    if (! OpenThreadToken(GetCurrentThread(),
-                          TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
-                          FALSE,
-                          &hToken)
-       ) {
+// Return the token of the current process, or NULL, in which case
+// `err` is set to the Win32 error code.
+static HANDLE
+psutil_get_thisproc_token(DWORD *err) {
+    HANDLE hToken = NULL;
+    HANDLE me = GetCurrentProcess();
+
+    if (!OpenProcessToken(me, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
+    {
+        // ERROR_NO_TOKEN means "the thread is not impersonating", which
+        // is an OpenThreadToken condition. A process always has a
+        // primary token, so this branch is likely unreachable.
         if (GetLastError() == ERROR_NO_TOKEN) {
             if (!ImpersonateSelf(SecurityImpersonation)) {
-                CloseHandle(hToken);
-                return 0;
+                psutil_debug("ImpersonateSelf() failed");
+                *err = GetLastError();
+                return NULL;
             }
-            if (!OpenThreadToken(GetCurrentThread(),
-                                 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
-                                 FALSE,
-                                 &hToken)
-               ) {
+            if (!OpenProcessToken(
+                    me, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken
+                ))
+            {
+                psutil_debug("OpenProcessToken() failed");
+                *err = GetLastError();
                 RevertToSelf();
-                CloseHandle(hToken);
-                return 0;
+                return NULL;
             }
         }
+        else {
+            psutil_debug("OpenProcessToken() failed");
+            *err = GetLastError();
+            return NULL;
+        }
     }
 
-    // enable SeDebugPrivilege (open any process)
-    if (! psutil_set_privilege(hToken, SE_DEBUG_NAME, TRUE)) {
-        RevertToSelf();
-        CloseHandle(hToken);
-        return 0;
-    }
+    return hToken;
+}
 
-    RevertToSelf();
-    CloseHandle(hToken);
-    return 1;
+
+static void
+sedebug_warn(DWORD err) {
+    char *msg =
+        "psutil module couldn't set SE DEBUG mode for this process; "
+        "please file an issue against psutil bug tracker";
+
+    if (err != ERROR_ACCESS_DENIED)
+        psutil_warn("%s (err=%lu)", msg, (unsigned long)err);
+    else
+        psutil_debug("%s (err=%lu)", msg, (unsigned long)err);
 }
 
 
+// Set this process in SE DEBUG mode so that we have more chances of
+// querying processes owned by other users, including many owned by
+// Administrator and Local System.
+// https://docs.microsoft.com/windows-hardware/drivers/debugger/debug-privilege
+// This is executed on module import and we don't crash on error.
 int
-psutil_unset_se_debug() {
+psutil_set_se_debug() {
     HANDLE hToken;
-    if (! OpenThreadToken(GetCurrentThread(),
-                          TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
-                          FALSE,
-                          &hToken)
-       ) {
-        if (GetLastError() == ERROR_NO_TOKEN) {
-            if (! ImpersonateSelf(SecurityImpersonation))
-                return 0;
-            if (!OpenThreadToken(GetCurrentThread(),
-                                 TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
-                                 FALSE,
-                                 &hToken))
-            {
-                return 0;
-            }
-        }
-    }
+    DWORD err = 0;
 
-    // now disable SeDebug
-    if (! psutil_set_privilege(hToken, SE_DEBUG_NAME, FALSE))
+    if ((hToken = psutil_get_thisproc_token(&err)) == NULL) {
+        sedebug_warn(err);
         return 0;
+    }
+
+    err = psutil_set_privilege(hToken, SE_DEBUG_NAME, TRUE);
+    if (err != 0)
+        sedebug_warn(err);
 
+    RevertToSelf();  // in case psutil_get_thisproc_token() impersonated
     CloseHandle(hToken);
-    return 1;
+    return 0;
 }
diff --git a/psutil/arch/windows/security.h b/psutil/arch/windows/security.h
deleted file mode 100644
index aa8a22ad1a..0000000000
--- a/psutil/arch/windows/security.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Security related functions for Windows platform (Set privileges such as
- * SeDebug), as well as security helper functions.
- */
-
-#include <windows.h>
-
-BOOL psutil_set_privilege(HANDLE hToken, LPCTSTR Privilege, BOOL bEnablePrivilege);
-HANDLE psutil_token_from_handle(HANDLE hProcess);
-int psutil_has_system_privilege(HANDLE hProcess);
-int psutil_set_se_debug();
-int psutil_unset_se_debug();
-
diff --git a/psutil/arch/windows/sensors.c b/psutil/arch/windows/sensors.c
new file mode 100644
index 0000000000..80db6e1a7e
--- /dev/null
+++ b/psutil/arch/windows/sensors.c
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <Python.h>
+#include <windows.h>
+
+#include "../../arch/all/init.h"
+
+
+// Added in https://github.com/giampaolo/psutil/commit/109f873 in 2017.
+// Moved in here in 2023.
+PyObject *
+psutil_sensors_battery(PyObject *self, PyObject *args) {
+    SYSTEM_POWER_STATUS sps;
+
+    if (GetSystemPowerStatus(&sps) == 0) {
+        psutil_oserror();
+        return NULL;
+    }
+    return Py_BuildValue(
+        "iidi",
+        sps.ACLineStatus,  // whether AC is connected: 0=no, 1=yes, 255=unknown
+        // status flag:
+        // 1, 2, 4 = high, low, critical
+        // 8 = charging
+        // 128 = no battery
+        sps.BatteryFlag,
+        (double)sps.BatteryLifePercent,  // percent
+        (int)sps.BatteryLifeTime
+    );
+}
diff --git a/psutil/arch/windows/services.c b/psutil/arch/windows/services.c
index 4b048e7a9f..8707df43e4 100644
--- a/psutil/arch/windows/services.c
+++ b/psutil/arch/windows/services.c
@@ -8,37 +8,75 @@
 #include <windows.h>
 #include <Winsvc.h>
 
-#include "services.h"
+#include "../../arch/all/init.h"
 
 
 // ==================================================================
 // utils
 // ==================================================================
 
-SC_HANDLE
-psutil_get_service_handler(char *service_name, DWORD scm_access, DWORD access)
-{
-    ENUM_SERVICE_STATUS_PROCESS *lpService = NULL;
+
+static SC_HANDLE
+psutil_get_service_handler(
+    const wchar_t *service_name, DWORD scm_access, DWORD access
+) {
     SC_HANDLE sc = NULL;
     SC_HANDLE hService = NULL;
-    SERVICE_DESCRIPTION *scd = NULL;
 
-    sc = OpenSCManager(NULL, NULL, scm_access);
+    // SCM calls are RPC to services.exe, they may be slow.
+    Py_BEGIN_ALLOW_THREADS
+    sc = OpenSCManagerW(NULL, NULL, scm_access);
+    Py_END_ALLOW_THREADS
     if (sc == NULL) {
-        PyErr_SetFromWindowsErr(0);
+        psutil_oserror_wsyscall("OpenSCManagerW");
         return NULL;
     }
-    hService = OpenService(sc, service_name, access);
+
+    Py_BEGIN_ALLOW_THREADS
+    hService = OpenServiceW(sc, service_name, access);
+    Py_END_ALLOW_THREADS
     if (hService == NULL) {
+        psutil_oserror_wsyscall("OpenServiceW");
         CloseServiceHandle(sc);
-        PyErr_SetFromWindowsErr(0);
         return NULL;
     }
+
     CloseServiceHandle(sc);
     return hService;
 }
 
 
+// helper: parse args, convert to wchar, and open service
+// returns NULL on error. On success, fills *service_name_out.
+static SC_HANDLE
+psutil_get_service_from_args(
+    PyObject *args, DWORD scm_access, DWORD access, wchar_t **service_name_out
+) {
+    PyObject *py_service_name = NULL;
+    wchar_t *service_name = NULL;
+    Py_ssize_t wlen;
+    SC_HANDLE hService = NULL;
+
+    if (!PyArg_ParseTuple(args, "U", &py_service_name)) {
+        return NULL;
+    }
+
+    service_name = PyUnicode_AsWideCharString(py_service_name, &wlen);
+    if (service_name == NULL) {
+        return NULL;
+    }
+
+    hService = psutil_get_service_handler(service_name, scm_access, access);
+    if (hService == NULL) {
+        PyMem_Free(service_name);
+        return NULL;
+    }
+
+    *service_name_out = service_name;
+    return hService;
+}
+
+
 // XXX - expose these as constants?
 static const char *
 get_startup_string(DWORD startup) {
@@ -49,14 +87,12 @@ get_startup_string(DWORD startup) {
             return "manual";
         case SERVICE_DISABLED:
             return "disabled";
-/*
         // drivers only (since we use EnumServicesStatusEx() with
         // SERVICE_WIN32)
-        case SERVICE_BOOT_START:
-            return "boot-start";
-        case SERVICE_SYSTEM_START:
-            return "system-start";
-*/
+        // case SERVICE_BOOT_START:
+        //     return "boot-start";
+        // case SERVICE_SYSTEM_START:
+        //     return "system-start";
         default:
             return "unknown";
     }
@@ -91,34 +127,37 @@ get_state_string(DWORD state) {
 // APIs
 // ==================================================================
 
-/*
- * Enumerate all services.
- */
+// Enumerate all services.
 PyObject *
 psutil_winservice_enumerate(PyObject *self, PyObject *args) {
-    ENUM_SERVICE_STATUS_PROCESS *lpService = NULL;
+    ENUM_SERVICE_STATUS_PROCESSW *lpService = NULL;
     BOOL ok;
     SC_HANDLE sc = NULL;
     DWORD bytesNeeded = 0;
-    DWORD srvCount;
+    DWORD srvCount = 0;
     DWORD resumeHandle = 0;
     DWORD dwBytes = 0;
     DWORD i;
     PyObject *py_retlist = PyList_New(0);
-    PyObject *py_tuple = NULL;
-    PyObject *py_unicode_display_name = NULL;
+    PyObject *py_name = NULL;
+    PyObject *py_display_name = NULL;
 
     if (py_retlist == NULL)
         return NULL;
 
+    // SCM calls are RPC to services.exe, they may be slow.
+    Py_BEGIN_ALLOW_THREADS
     sc = OpenSCManager(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE);
+    Py_END_ALLOW_THREADS
     if (sc == NULL) {
-        PyErr_SetFromWindowsErr(0);
+        psutil_oserror_wsyscall("OpenSCManager");
+        Py_DECREF(py_retlist);
         return NULL;
     }
 
     for (;;) {
-        ok = EnumServicesStatusEx(
+        Py_BEGIN_ALLOW_THREADS
+        ok = EnumServicesStatusExW(
             sc,
             SC_ENUM_PROCESS_INFO,
             SERVICE_WIN32,  // XXX - extend this to include drivers etc.?
@@ -128,38 +167,47 @@ psutil_winservice_enumerate(PyObject *self, PyObject *args) {
             &bytesNeeded,
             &srvCount,
             &resumeHandle,
-            NULL);
+            NULL
+        );
+        Py_END_ALLOW_THREADS
         if (ok || (GetLastError() != ERROR_MORE_DATA))
             break;
         if (lpService)
             free(lpService);
         dwBytes = bytesNeeded;
-        lpService = (ENUM_SERVICE_STATUS_PROCESS*)malloc(dwBytes);
+        lpService = (ENUM_SERVICE_STATUS_PROCESSW *)malloc(dwBytes);
+        if (lpService == NULL) {
+            PyErr_NoMemory();
+            goto error;
+        }
+    }
+
+    if (!ok) {
+        psutil_oserror_wsyscall("EnumServicesStatusExW");
+        goto error;
     }
 
     for (i = 0; i < srvCount; i++) {
-        // Get unicode display name.
-        py_unicode_display_name = NULL;
-        py_unicode_display_name = PyUnicode_Decode(
-            lpService[i].lpDisplayName,
-            _tcslen(lpService[i].lpDisplayName),
-            Py_FileSystemDefaultEncoding,
-            "replace");
-        if (py_unicode_display_name == NULL)
+        // Get unicode name / display name.
+        py_name = NULL;
+        py_name = PyUnicode_FromWideChar(
+            lpService[i].lpServiceName, wcslen(lpService[i].lpServiceName)
+        );
+        if (py_name == NULL)
             goto error;
 
-        // Construct the result.
-        py_tuple = Py_BuildValue(
-            "(sO)",
-            lpService[i].lpServiceName,  // name
-            py_unicode_display_name  // display_name
+        py_display_name = NULL;
+        py_display_name = PyUnicode_FromWideChar(
+            lpService[i].lpDisplayName, wcslen(lpService[i].lpDisplayName)
         );
-        if (py_tuple == NULL)
+        if (py_display_name == NULL)
             goto error;
-        if (PyList_Append(py_retlist, py_tuple))
+
+        // Construct the result.
+        if (!pylist_append_fmt(py_retlist, "(OO)", py_name, py_display_name))
             goto error;
-        Py_DECREF(py_unicode_display_name);
-        Py_DECREF(py_tuple);
+        Py_DECREF(py_display_name);
+        Py_DECREF(py_name);
     }
 
     // Free resources.
@@ -168,8 +216,8 @@ psutil_winservice_enumerate(PyObject *self, PyObject *args) {
     return py_retlist;
 
 error:
-    Py_XDECREF(py_unicode_display_name);
-    Py_XDECREF(py_tuple);
+    Py_XDECREF(py_name);
+    Py_XDECREF(py_display_name);
     Py_DECREF(py_retlist);
     if (sc != NULL)
         CloseServiceHandle(sc);
@@ -179,73 +227,69 @@ psutil_winservice_enumerate(PyObject *self, PyObject *args) {
 }
 
 
-/*
- * Get service config information. Returns:
- * - display_name
- * - binpath
- * - username
- * - startup_type
- */
+// Get service config information. Returns:
+// (display_name, binpath, username, startup_type)
 PyObject *
 psutil_winservice_query_config(PyObject *self, PyObject *args) {
-    char *service_name;
+    wchar_t *service_name = NULL;
     SC_HANDLE hService = NULL;
     BOOL ok;
     DWORD bytesNeeded = 0;
-    DWORD resumeHandle = 0;
-    DWORD dwBytes = 0;
-    QUERY_SERVICE_CONFIG *qsc = NULL;
+    QUERY_SERVICE_CONFIGW *qsc = NULL;
     PyObject *py_tuple = NULL;
     PyObject *py_unicode_display_name = NULL;
     PyObject *py_unicode_binpath = NULL;
     PyObject *py_unicode_username = NULL;
 
-    if (!PyArg_ParseTuple(args, "s", &service_name))
-        return NULL;
-    hService = psutil_get_service_handler(
-        service_name, SC_MANAGER_ENUMERATE_SERVICE, SERVICE_QUERY_CONFIG);
+    hService = psutil_get_service_from_args(
+        args, SC_MANAGER_ENUMERATE_SERVICE, SERVICE_QUERY_CONFIG, &service_name
+    );
     if (hService == NULL)
-        goto error;
+        return NULL;
 
-    // First call to QueryServiceConfig() is necessary to get the
+    // First call to QueryServiceConfigW() is necessary to get the
     // right size.
     bytesNeeded = 0;
-    QueryServiceConfig(hService, NULL, 0, &bytesNeeded);
+    Py_BEGIN_ALLOW_THREADS
+    QueryServiceConfigW(hService, NULL, 0, &bytesNeeded);
+    Py_END_ALLOW_THREADS
     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
-        PyErr_SetFromWindowsErr(0);
+        psutil_oserror_wsyscall("QueryServiceConfigW");
         goto error;
     }
-    qsc = (QUERY_SERVICE_CONFIG *)malloc(bytesNeeded);
-    ok = QueryServiceConfig(hService, qsc, bytesNeeded, &bytesNeeded);
-    if (ok == 0) {
-        PyErr_SetFromWindowsErr(0);
+
+    qsc = (QUERY_SERVICE_CONFIGW *)malloc(bytesNeeded);
+    if (qsc == NULL) {
+        PyErr_NoMemory();
+        goto error;
+    }
+
+    Py_BEGIN_ALLOW_THREADS
+    ok = QueryServiceConfigW(hService, qsc, bytesNeeded, &bytesNeeded);
+    Py_END_ALLOW_THREADS
+    if (!ok) {
+        psutil_oserror_wsyscall("QueryServiceConfigW");
         goto error;
     }
 
     // Get unicode display name.
-    py_unicode_display_name = PyUnicode_Decode(
-        qsc->lpDisplayName,
-        _tcslen(qsc->lpDisplayName),
-        Py_FileSystemDefaultEncoding,
-        "replace");
+    py_unicode_display_name = PyUnicode_FromWideChar(
+        qsc->lpDisplayName, wcslen(qsc->lpDisplayName)
+    );
     if (py_unicode_display_name == NULL)
         goto error;
 
     // Get unicode bin path.
-    py_unicode_binpath = PyUnicode_Decode(
-        qsc->lpBinaryPathName,
-        _tcslen(qsc->lpBinaryPathName),
-        Py_FileSystemDefaultEncoding,
-        "replace");
+    py_unicode_binpath = PyUnicode_FromWideChar(
+        qsc->lpBinaryPathName, wcslen(qsc->lpBinaryPathName)
+    );
     if (py_unicode_binpath == NULL)
         goto error;
 
     // Get unicode username.
-    py_unicode_username = PyUnicode_Decode(
-        qsc->lpServiceStartName,
-        _tcslen(qsc->lpServiceStartName),
-        Py_FileSystemDefaultEncoding,
-        "replace");
+    py_unicode_username = PyUnicode_FromWideChar(
+        qsc->lpServiceStartName, wcslen(qsc->lpServiceStartName)
+    );
     if (py_unicode_username == NULL)
         goto error;
 
@@ -266,6 +310,7 @@ psutil_winservice_query_config(PyObject *self, PyObject *args) {
     Py_DECREF(py_unicode_username);
     free(qsc);
     CloseServiceHandle(hService);
+    PyMem_Free(service_name);
     return py_tuple;
 
 error:
@@ -273,211 +318,242 @@ psutil_winservice_query_config(PyObject *self, PyObject *args) {
     Py_XDECREF(py_unicode_binpath);
     Py_XDECREF(py_unicode_username);
     Py_XDECREF(py_tuple);
-    if (hService != NULL)
+    if (hService)
         CloseServiceHandle(hService);
-    if (qsc != NULL)
+    if (qsc)
         free(qsc);
+    if (service_name)
+        PyMem_Free(service_name);
     return NULL;
 }
 
 
-/*
- * Get service status information. Returns:
- * - status
- * - pid
- */
+// Get service status information. Returns (status, pid)
 PyObject *
 psutil_winservice_query_status(PyObject *self, PyObject *args) {
-    char *service_name;
+    wchar_t *service_name = NULL;
     SC_HANDLE hService = NULL;
     BOOL ok;
     DWORD bytesNeeded = 0;
-    DWORD resumeHandle = 0;
-    DWORD dwBytes = 0;
-    SERVICE_STATUS_PROCESS  *ssp = NULL;
+    SERVICE_STATUS_PROCESS *ssp = NULL;
     PyObject *py_tuple = NULL;
 
-    if (!PyArg_ParseTuple(args, "s", &service_name))
-        return NULL;
-    hService = psutil_get_service_handler(
-        service_name, SC_MANAGER_ENUMERATE_SERVICE, SERVICE_QUERY_STATUS);
+    hService = psutil_get_service_from_args(
+        args, SC_MANAGER_ENUMERATE_SERVICE, SERVICE_QUERY_STATUS, &service_name
+    );
     if (hService == NULL)
-        goto error;
+        return NULL;
 
     // First call to QueryServiceStatusEx() is necessary to get the
     // right size.
-    QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, NULL, 0,
-                         &bytesNeeded);
+    Py_BEGIN_ALLOW_THREADS
+    QueryServiceStatusEx(
+        hService, SC_STATUS_PROCESS_INFO, NULL, 0, &bytesNeeded
+    );
+    Py_END_ALLOW_THREADS
     if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
-        PyErr_SetFromWindowsErr(0);
+        psutil_oserror_wsyscall("QueryServiceStatusEx");
         goto error;
     }
-    ssp = (SERVICE_STATUS_PROCESS *)HeapAlloc(
-        GetProcessHeap(), 0, bytesNeeded);
+
+    ssp = (SERVICE_STATUS_PROCESS *)MALLOC(bytesNeeded);
     if (ssp == NULL) {
         PyErr_NoMemory();
         goto error;
     }
 
     // Actual call.
-    ok = QueryServiceStatusEx(hService, SC_STATUS_PROCESS_INFO, (LPBYTE)ssp,
-                              bytesNeeded, &bytesNeeded);
-    if (ok == 0) {
-        PyErr_SetFromWindowsErr(0);
+    Py_BEGIN_ALLOW_THREADS
+    ok = QueryServiceStatusEx(
+        hService,
+        SC_STATUS_PROCESS_INFO,
+        (LPBYTE)ssp,
+        bytesNeeded,
+        &bytesNeeded
+    );
+    Py_END_ALLOW_THREADS
+    if (!ok) {
+        psutil_oserror_wsyscall("QueryServiceStatusEx");
         goto error;
     }
 
     py_tuple = Py_BuildValue(
-        "(sk)",
-        get_state_string(ssp->dwCurrentState),
-        ssp->dwProcessId
+        "(sk)", get_state_string(ssp->dwCurrentState), ssp->dwProcessId
     );
     if (py_tuple == NULL)
         goto error;
 
     CloseServiceHandle(hService);
-    HeapFree(GetProcessHeap(), 0, ssp);
+    FREE(ssp);
+    PyMem_Free(service_name);
     return py_tuple;
 
 error:
     Py_XDECREF(py_tuple);
-    if (hService != NULL)
+    if (hService)
         CloseServiceHandle(hService);
-    if (ssp != NULL)
-        HeapFree(GetProcessHeap(), 0, ssp);
+    if (ssp)
+        FREE(ssp);
+    if (service_name)
+        PyMem_Free(service_name);
     return NULL;
 }
 
-
-/*
- * Get service description.
- */
 PyObject *
 psutil_winservice_query_descr(PyObject *self, PyObject *args) {
-    ENUM_SERVICE_STATUS_PROCESS *lpService = NULL;
     BOOL ok;
     DWORD bytesNeeded = 0;
-    DWORD resumeHandle = 0;
-    DWORD dwBytes = 0;
+    DWORD err;
     SC_HANDLE hService = NULL;
-    SERVICE_DESCRIPTION *scd = NULL;
-    char *service_name;
+    SERVICE_DESCRIPTIONW *scd = NULL;
+    wchar_t *service_name = NULL;
     PyObject *py_retstr = NULL;
 
-    if (!PyArg_ParseTuple(args, "s", &service_name))
-        return NULL;
-    hService = psutil_get_service_handler(
-        service_name, SC_MANAGER_ENUMERATE_SERVICE, SERVICE_QUERY_CONFIG);
+    hService = psutil_get_service_from_args(
+        args, SC_MANAGER_ENUMERATE_SERVICE, SERVICE_QUERY_CONFIG, &service_name
+    );
     if (hService == NULL)
+        return NULL;
+
+    Py_BEGIN_ALLOW_THREADS
+    QueryServiceConfig2W(
+        hService, SERVICE_CONFIG_DESCRIPTION, NULL, 0, &bytesNeeded
+    );
+    Py_END_ALLOW_THREADS
+    err = GetLastError();
+
+    if ((err == ERROR_NOT_FOUND) || (err == ERROR_FILE_NOT_FOUND)
+        || (err == ERROR_MUI_FILE_NOT_FOUND))
+    {
+        psutil_debug(
+            "no description for service (err=%lu)", (unsigned long)err
+        );
+        CloseServiceHandle(hService);
+        PyMem_Free(service_name);
+        return PyUnicode_FromString("");
+    }
+
+    if (err != ERROR_INSUFFICIENT_BUFFER) {
+        psutil_oserror_wsyscall("QueryServiceConfig2W");
         goto error;
+    }
 
-    // This first call to QueryServiceConfig2() is necessary in order
-    // to get the right size.
-    bytesNeeded = 0;
-    QueryServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION, NULL, 0,
-                        &bytesNeeded);
-    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) {
-        PyErr_SetFromWindowsErr(0);
+    scd = (SERVICE_DESCRIPTIONW *)malloc(bytesNeeded);
+    if (scd == NULL) {
+        PyErr_NoMemory();
         goto error;
     }
 
-    scd = (SERVICE_DESCRIPTION *)malloc(bytesNeeded);
-    ok = QueryServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION,
-                             (LPBYTE)scd, bytesNeeded, &bytesNeeded);
-    if (ok == 0) {
-        PyErr_SetFromWindowsErr(0);
+    Py_BEGIN_ALLOW_THREADS
+    ok = QueryServiceConfig2W(
+        hService,
+        SERVICE_CONFIG_DESCRIPTION,
+        (LPBYTE)scd,
+        bytesNeeded,
+        &bytesNeeded
+    );
+    Py_END_ALLOW_THREADS
+    if (!ok) {
+        psutil_oserror_wsyscall("QueryServiceConfig2W");
         goto error;
     }
 
     if (scd->lpDescription == NULL) {
-        py_retstr = Py_BuildValue("s", "");
+        py_retstr = PyUnicode_FromString("");
     }
     else {
-        py_retstr = PyUnicode_Decode(
-            scd->lpDescription,
-            _tcslen(scd->lpDescription),
-            Py_FileSystemDefaultEncoding,
-            "replace");
+        py_retstr = PyUnicode_FromWideChar(
+            scd->lpDescription, wcslen(scd->lpDescription)
+        );
     }
+
     if (!py_retstr)
         goto error;
 
     free(scd);
+    CloseServiceHandle(hService);
+    PyMem_Free(service_name);
     return py_retstr;
 
 error:
-    if (hService != NULL)
+    if (hService)
         CloseServiceHandle(hService);
-    if (lpService != NULL)
-        free(lpService);
+    if (scd)
+        free(scd);
+    if (service_name)
+        PyMem_Free(service_name);
     return NULL;
 }
 
 
-/*
- * Start service.
- * XXX - note: this is exposed but not used.
- */
+// Start service.
+// XXX - note: this is exposed but not used.
 PyObject *
 psutil_winservice_start(PyObject *self, PyObject *args) {
-    char *service_name;
     BOOL ok;
     SC_HANDLE hService = NULL;
+    wchar_t *service_name = NULL;
 
-    if (!PyArg_ParseTuple(args, "s", &service_name))
+    hService = psutil_get_service_from_args(
+        args, SC_MANAGER_ALL_ACCESS, SERVICE_START, &service_name
+    );
+    if (hService == NULL)
         return NULL;
-    hService = psutil_get_service_handler(
-        service_name, SC_MANAGER_ALL_ACCESS, SERVICE_START);
-    if (hService == NULL) {
-        goto error;
-    }
+
+    // Starts a process and waits for it to report back.
+    Py_BEGIN_ALLOW_THREADS
     ok = StartService(hService, 0, NULL);
-    if (ok == 0) {
-        PyErr_SetFromWindowsErr(0);
+    Py_END_ALLOW_THREADS
+    if (!ok) {
+        psutil_oserror_wsyscall("StartService");
         goto error;
     }
 
+    CloseServiceHandle(hService);
+    PyMem_Free(service_name);
     Py_RETURN_NONE;
 
 error:
-    if (hService != NULL)
+    if (hService)
         CloseServiceHandle(hService);
+    if (service_name)
+        PyMem_Free(service_name);
     return NULL;
 }
 
 
-/*
- * Stop service.
- * XXX - note: this is exposed but not used.
- */
+// Stop service.
+// XXX - note: this is exposed but not used.
 PyObject *
 psutil_winservice_stop(PyObject *self, PyObject *args) {
-    char *service_name;
+    wchar_t *service_name = NULL;
     BOOL ok;
     SC_HANDLE hService = NULL;
     SERVICE_STATUS ssp;
 
-    if (!PyArg_ParseTuple(args, "s", &service_name))
-        return NULL;
-    hService = psutil_get_service_handler(
-        service_name, SC_MANAGER_ALL_ACCESS, SERVICE_STOP);
+    hService = psutil_get_service_from_args(
+        args, SC_MANAGER_ALL_ACCESS, SERVICE_STOP, &service_name
+    );
     if (hService == NULL)
-        goto error;
+        return NULL;
 
     // Note: this can hang for 30 secs.
     Py_BEGIN_ALLOW_THREADS
     ok = ControlService(hService, SERVICE_CONTROL_STOP, &ssp);
     Py_END_ALLOW_THREADS
-    if (ok == 0) {
-        PyErr_SetFromWindowsErr(0);
+    if (!ok) {
+        psutil_oserror_wsyscall("ControlService");
         goto error;
     }
 
     CloseServiceHandle(hService);
+    PyMem_Free(service_name);
     Py_RETURN_NONE;
 
 error:
-    if (hService != NULL)
+    if (hService)
         CloseServiceHandle(hService);
+    if (service_name)
+        PyMem_Free(service_name);
     return NULL;
 }
diff --git a/psutil/arch/windows/services.h b/psutil/arch/windows/services.h
deleted file mode 100644
index 286ed232c9..0000000000
--- a/psutil/arch/windows/services.h
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include <Python.h>
-#include <Winsvc.h>
-
-SC_HANDLE psutil_get_service_handle(
-char service_name, DWORD scm_access, DWORD access);
-PyObject *psutil_winservice_enumerate(PyObject *self, PyObject *args);
-PyObject *psutil_winservice_query_config(PyObject *self, PyObject *args);
-PyObject *psutil_winservice_query_status(PyObject *self, PyObject *args);
-PyObject *psutil_winservice_query_descr(PyObject *self, PyObject *args);
-PyObject *psutil_winservice_start(PyObject *self, PyObject *args);
-PyObject *psutil_winservice_stop(PyObject *self, PyObject *args);
diff --git a/psutil/arch/windows/socks.c b/psutil/arch/windows/socks.c
new file mode 100644
index 0000000000..1e12f6f0ff
--- /dev/null
+++ b/psutil/arch/windows/socks.c
@@ -0,0 +1,482 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Fixes clash between winsock2.h and windows.h
+#define WIN32_LEAN_AND_MEAN
+
+#include <Python.h>
+#include <windows.h>
+#include <ws2tcpip.h>
+
+#include "../../arch/all/init.h"
+
+
+#define BYTESWAP_USHORT(x) ((((USHORT)(x) << 8) | ((USHORT)(x) >> 8)) & 0xffff)
+#define STATUS_UNSUCCESSFUL 0xC0000001
+#define MAX_TRIES 3
+
+
+// Note about GetExtended[Tcp|Udp]Table syscalls: due to other processes
+// being active on the machine, it's possible that the size of the table
+// increases between the moment we query the size and the moment we query
+// the data. Therefore we retry if that happens. See:
+// https://github.com/giampaolo/psutil/pull/1335
+// https://github.com/giampaolo/psutil/issues/1294
+
+
+static PVOID
+__GetExtendedTcpTable(ULONG family) {
+    DWORD err;
+    PVOID table;
+    ULONG size;
+    int attempt;
+    TCP_TABLE_CLASS class = TCP_TABLE_OWNER_PID_ALL;
+
+    // The table can grow between the call asking for its size and the
+    // one reading it, hence the retry.
+    for (attempt = 0; attempt < MAX_TRIES; attempt++) {
+        size = 0;
+        // Snapshots the whole TCP table from the network stack.
+        Py_BEGIN_ALLOW_THREADS
+        err = GetExtendedTcpTable(NULL, &size, FALSE, family, class, 0);
+        Py_END_ALLOW_THREADS
+        if (err != ERROR_INSUFFICIENT_BUFFER) {
+            psutil_runtime_error(
+                "GetExtendedTcpTable() failed to determine the buffer size "
+                "(err=%lu)",
+                (unsigned long)err
+            );
+            return NULL;
+        }
+        // reserve 25% more space to be sure
+        size = size + (size / 2 / 2);
+
+        table = malloc(size);
+        if (table == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+
+        Py_BEGIN_ALLOW_THREADS
+        err = GetExtendedTcpTable(table, &size, FALSE, family, class, 0);
+        Py_END_ALLOW_THREADS
+        if (err == NO_ERROR)
+            return table;
+
+        free(table);
+        if (err != ERROR_INSUFFICIENT_BUFFER && err != STATUS_UNSUCCESSFUL) {
+            psutil_runtime_error(
+                "GetExtendedTcpTable() failed (err=%lu)", (unsigned long)err
+            );
+            return NULL;
+        }
+        psutil_debug(
+            "GetExtendedTcpTable: retry (err=%lu)", (unsigned long)err
+        );
+    }
+
+    psutil_runtime_error(
+        "GetExtendedTcpTable() failed %d times in a row (last err=%lu)",
+        MAX_TRIES,
+        (unsigned long)err
+    );
+    return NULL;
+}
+
+
+static PVOID
+__GetExtendedUdpTable(ULONG family) {
+    DWORD err;
+    PVOID table;
+    ULONG size;
+    int attempt;
+    UDP_TABLE_CLASS class = UDP_TABLE_OWNER_PID;
+
+    // The table can grow between the call asking for its size and the
+    // one reading it, hence the retry.
+    for (attempt = 0; attempt < MAX_TRIES; attempt++) {
+        size = 0;
+        // Snapshots the whole UDP table from the network stack.
+        Py_BEGIN_ALLOW_THREADS
+        err = GetExtendedUdpTable(NULL, &size, FALSE, family, class, 0);
+        Py_END_ALLOW_THREADS
+        if (err != ERROR_INSUFFICIENT_BUFFER) {
+            psutil_runtime_error(
+                "GetExtendedUdpTable() failed to determine the buffer size "
+                "(err=%lu)",
+                (unsigned long)err
+            );
+            return NULL;
+        }
+        // reserve 25% more space to be sure
+        size = size + (size / 2 / 2);
+
+        table = malloc(size);
+        if (table == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+
+        Py_BEGIN_ALLOW_THREADS
+        err = GetExtendedUdpTable(table, &size, FALSE, family, class, 0);
+        Py_END_ALLOW_THREADS
+        if (err == NO_ERROR)
+            return table;
+
+        free(table);
+        if (err != ERROR_INSUFFICIENT_BUFFER && err != STATUS_UNSUCCESSFUL) {
+            psutil_runtime_error(
+                "GetExtendedUdpTable() failed (err=%lu)", (unsigned long)err
+            );
+            return NULL;
+        }
+        psutil_debug(
+            "GetExtendedUdpTable: retry (err=%lu)", (unsigned long)err
+        );
+    }
+
+    psutil_runtime_error(
+        "GetExtendedUdpTable() failed %d times in a row (last err=%lu)",
+        MAX_TRIES,
+        (unsigned long)err
+    );
+    return NULL;
+}
+
+
+/*
+ * Return a list of network connections opened by a process
+ */
+PyObject *
+psutil_net_connections(PyObject *self, PyObject *args) {
+    static long null_address[4] = {0, 0, 0, 0};
+    DWORD pid;
+    PVOID table = NULL;
+    PMIB_TCPTABLE_OWNER_PID tcp4Table;
+    PMIB_UDPTABLE_OWNER_PID udp4Table;
+    PMIB_TCP6TABLE_OWNER_PID tcp6Table;
+    PMIB_UDP6TABLE_OWNER_PID udp6Table;
+    ULONG i;
+    int ok;
+    psutil_conn_filters filters;
+    CHAR addressBufferLocal[65];
+    CHAR addressBufferRemote[65];
+
+    PyObject *py_retlist = NULL;
+    PyObject *py_af_filter = NULL;
+    PyObject *py_type_filter = NULL;
+    PyObject *py_addr_tuple_local = NULL;
+    PyObject *py_addr_tuple_remote = NULL;
+
+    if (!PyArg_ParseTuple(
+            args, _Py_PARSE_PID "OO", &pid, &py_af_filter, &py_type_filter
+        ))
+    {
+        return NULL;
+    }
+
+    if (psutil_parse_conn_filters(py_af_filter, py_type_filter, &filters) != 0)
+        return NULL;
+
+    if (pid != -1) {
+        if (psutil_check_pid_running(pid) != 0)
+            return NULL;
+    }
+
+    py_retlist = PyList_New(0);
+    if (py_retlist == NULL)
+        return NULL;
+
+    // TCP IPv4
+
+    if (filters.tcp && filters.v4) {
+        table = NULL;
+        py_addr_tuple_local = NULL;
+        py_addr_tuple_remote = NULL;
+
+        table = __GetExtendedTcpTable(AF_INET);
+        if (table == NULL)
+            goto error;
+        tcp4Table = table;
+        for (i = 0; i < tcp4Table->dwNumEntries; i++) {
+            if (pid != -1) {
+                if (tcp4Table->table[i].dwOwningPid != pid) {
+                    continue;
+                }
+            }
+
+            if (tcp4Table->table[i].dwLocalAddr != 0
+                || tcp4Table->table[i].dwLocalPort != 0)
+            {
+                struct in_addr addr;
+
+                addr.S_un.S_addr = tcp4Table->table[i].dwLocalAddr;
+                RtlIpv4AddressToStringA(&addr, addressBufferLocal);
+                py_addr_tuple_local = Py_BuildValue(
+                    "(si)",
+                    addressBufferLocal,
+                    BYTESWAP_USHORT(tcp4Table->table[i].dwLocalPort)
+                );
+            }
+            else {
+                py_addr_tuple_local = PyTuple_New(0);
+            }
+
+            if (py_addr_tuple_local == NULL)
+                goto error;
+
+            // On Windows <= XP, remote addr is filled even if socket
+            // is in LISTEN mode in which case we just ignore it.
+            if ((tcp4Table->table[i].dwRemoteAddr != 0
+                 || tcp4Table->table[i].dwRemotePort != 0)
+                && (tcp4Table->table[i].dwState != MIB_TCP_STATE_LISTEN))
+            {
+                struct in_addr addr;
+
+                addr.S_un.S_addr = tcp4Table->table[i].dwRemoteAddr;
+                RtlIpv4AddressToStringA(&addr, addressBufferRemote);
+                py_addr_tuple_remote = Py_BuildValue(
+                    "(si)",
+                    addressBufferRemote,
+                    BYTESWAP_USHORT(tcp4Table->table[i].dwRemotePort)
+                );
+            }
+            else {
+                py_addr_tuple_remote = PyTuple_New(0);
+            }
+
+            if (py_addr_tuple_remote == NULL)
+                goto error;
+
+            ok = pylist_append_fmt(
+                py_retlist,
+                "(iiiNNiI)",
+                -1,
+                AF_INET,
+                SOCK_STREAM,
+                py_addr_tuple_local,
+                py_addr_tuple_remote,
+                tcp4Table->table[i].dwState,
+                tcp4Table->table[i].dwOwningPid
+            );
+            // "N" consumes the references, whether it succeeds or not.
+            py_addr_tuple_local = NULL;
+            py_addr_tuple_remote = NULL;
+            if (!ok)
+                goto error;
+        }
+
+        free(table);
+        table = NULL;
+    }
+
+    // TCP IPv6
+    if (filters.tcp && filters.v6) {
+        table = NULL;
+        py_addr_tuple_local = NULL;
+        py_addr_tuple_remote = NULL;
+
+        table = __GetExtendedTcpTable(AF_INET6);
+        if (table == NULL)
+            goto error;
+        tcp6Table = table;
+        for (i = 0; i < tcp6Table->dwNumEntries; i++) {
+            if (pid != -1) {
+                if (tcp6Table->table[i].dwOwningPid != pid) {
+                    continue;
+                }
+            }
+
+            if (memcmp(tcp6Table->table[i].ucLocalAddr, null_address, 16) != 0
+                || tcp6Table->table[i].dwLocalPort != 0)
+            {
+                struct in6_addr addr;
+
+                memcpy(&addr, tcp6Table->table[i].ucLocalAddr, 16);
+                RtlIpv6AddressToStringA(&addr, addressBufferLocal);
+                py_addr_tuple_local = Py_BuildValue(
+                    "(si)",
+                    addressBufferLocal,
+                    BYTESWAP_USHORT(tcp6Table->table[i].dwLocalPort)
+                );
+            }
+            else {
+                py_addr_tuple_local = PyTuple_New(0);
+            }
+
+            if (py_addr_tuple_local == NULL)
+                goto error;
+
+            // On Windows <= XP, remote addr is filled even if socket
+            // is in LISTEN mode in which case we just ignore it.
+            if ((memcmp(tcp6Table->table[i].ucRemoteAddr, null_address, 16)
+                     != 0
+                 || tcp6Table->table[i].dwRemotePort != 0)
+                && (tcp6Table->table[i].dwState != MIB_TCP_STATE_LISTEN))
+            {
+                struct in6_addr addr;
+
+                memcpy(&addr, tcp6Table->table[i].ucRemoteAddr, 16);
+                RtlIpv6AddressToStringA(&addr, addressBufferRemote);
+                py_addr_tuple_remote = Py_BuildValue(
+                    "(si)",
+                    addressBufferRemote,
+                    BYTESWAP_USHORT(tcp6Table->table[i].dwRemotePort)
+                );
+            }
+            else {
+                py_addr_tuple_remote = PyTuple_New(0);
+            }
+
+            if (py_addr_tuple_remote == NULL)
+                goto error;
+
+            ok = pylist_append_fmt(
+                py_retlist,
+                "(iiiNNiI)",
+                -1,
+                AF_INET6,
+                SOCK_STREAM,
+                py_addr_tuple_local,
+                py_addr_tuple_remote,
+                tcp6Table->table[i].dwState,
+                tcp6Table->table[i].dwOwningPid
+            );
+            // "N" consumes the references, whether it succeeds or not.
+            py_addr_tuple_local = NULL;
+            py_addr_tuple_remote = NULL;
+            if (!ok)
+                goto error;
+        }
+
+        free(table);
+        table = NULL;
+    }
+
+    // UDP IPv4
+
+    if (filters.udp && filters.v4) {
+        table = NULL;
+        py_addr_tuple_local = NULL;
+        table = __GetExtendedUdpTable(AF_INET);
+        if (table == NULL)
+            goto error;
+        udp4Table = table;
+        for (i = 0; i < udp4Table->dwNumEntries; i++) {
+            if (pid != -1) {
+                if (udp4Table->table[i].dwOwningPid != pid) {
+                    continue;
+                }
+            }
+
+            if (udp4Table->table[i].dwLocalAddr != 0
+                || udp4Table->table[i].dwLocalPort != 0)
+            {
+                struct in_addr addr;
+
+                addr.S_un.S_addr = udp4Table->table[i].dwLocalAddr;
+                RtlIpv4AddressToStringA(&addr, addressBufferLocal);
+                py_addr_tuple_local = Py_BuildValue(
+                    "(si)",
+                    addressBufferLocal,
+                    BYTESWAP_USHORT(udp4Table->table[i].dwLocalPort)
+                );
+            }
+            else {
+                py_addr_tuple_local = PyTuple_New(0);
+            }
+
+            if (py_addr_tuple_local == NULL)
+                goto error;
+
+            ok = pylist_append_fmt(
+                py_retlist,
+                "(iiiNNiI)",
+                -1,
+                AF_INET,
+                SOCK_DGRAM,
+                py_addr_tuple_local,
+                PyTuple_New(0),
+                PSUTIL_CONN_NONE,
+                udp4Table->table[i].dwOwningPid
+            );
+            // "N" consumes the references, whether it succeeds or not.
+            py_addr_tuple_local = NULL;
+            if (!ok)
+                goto error;
+        }
+
+        free(table);
+        table = NULL;
+    }
+
+    // UDP IPv6
+
+    if (filters.udp && filters.v6) {
+        table = NULL;
+        py_addr_tuple_local = NULL;
+        table = __GetExtendedUdpTable(AF_INET6);
+        if (table == NULL)
+            goto error;
+        udp6Table = table;
+        for (i = 0; i < udp6Table->dwNumEntries; i++) {
+            if (pid != -1) {
+                if (udp6Table->table[i].dwOwningPid != pid) {
+                    continue;
+                }
+            }
+
+            if (memcmp(udp6Table->table[i].ucLocalAddr, null_address, 16) != 0
+                || udp6Table->table[i].dwLocalPort != 0)
+            {
+                struct in6_addr addr;
+
+                memcpy(&addr, udp6Table->table[i].ucLocalAddr, 16);
+                RtlIpv6AddressToStringA(&addr, addressBufferLocal);
+                py_addr_tuple_local = Py_BuildValue(
+                    "(si)",
+                    addressBufferLocal,
+                    BYTESWAP_USHORT(udp6Table->table[i].dwLocalPort)
+                );
+            }
+            else {
+                py_addr_tuple_local = PyTuple_New(0);
+            }
+
+            if (py_addr_tuple_local == NULL)
+                goto error;
+
+            ok = pylist_append_fmt(
+                py_retlist,
+                "(iiiNNiI)",
+                -1,
+                AF_INET6,
+                SOCK_DGRAM,
+                py_addr_tuple_local,
+                PyTuple_New(0),
+                PSUTIL_CONN_NONE,
+                udp6Table->table[i].dwOwningPid
+            );
+            // "N" consumes the references, whether it succeeds or not.
+            py_addr_tuple_local = NULL;
+            if (!ok)
+                goto error;
+        }
+
+        free(table);
+        table = NULL;
+    }
+
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_addr_tuple_local);
+    Py_XDECREF(py_addr_tuple_remote);
+    Py_XDECREF(py_retlist);
+    if (table != NULL)
+        free(table);
+    return NULL;
+}
diff --git a/psutil/arch/windows/sys.c b/psutil/arch/windows/sys.c
new file mode 100644
index 0000000000..79d0951771
--- /dev/null
+++ b/psutil/arch/windows/sys.c
@@ -0,0 +1,222 @@
+/*
+ * Copyright (c) 2009, Jay Loden, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// System related functions. Original code moved in here from
+// psutil/_psutil_windows.c in 2023. For reference, here's the GIT
+// blame history before the move:
+//
+// - boot_time():
+//   https://github.com/giampaolo/psutil/blame/efd7ed3/psutil/_psutil_windows.c#L51-L60
+// - users():
+//   https://github.com/giampaolo/psutil/blame/efd7ed3/psutil/_psutil_windows.c#L1103-L1244
+
+#include <Python.h>
+#include <windows.h>
+
+#include "../../arch/all/init.h"
+
+
+// System boot time expressed in seconds since the UNIX epoch.
+//
+// Read boot time atomically from the kernel via
+// NtQuerySystemInformation(SystemTimeOfDayInformation), so the value
+// is identical across processes and has zero differences between calls
+// (fixes issue #1007 for the second time, which was caused by sampling
+// `time.time()` and `cext.uptime()` as two separate Python calls).
+//
+// This function is subject to system clock updates / NTP (it's by
+// contract and documented). It also takes into account the time spent
+// in suspend / hibernate mode, so that it returns the same result
+// on wakeup.
+PyObject *
+psutil_boot_time(PyObject *self, PyObject *args) {
+    SYSTEM_TIMEOFDAY_INFORMATION info;
+    NTSTATUS status;
+    LARGE_INTEGER boot;
+
+    status = NtQuerySystemInformation(
+        SystemTimeOfDayInformation, &info, sizeof(info), NULL
+    );
+    if (!NT_SUCCESS(status)) {
+        psutil_SetFromNTStatusErr(
+            status, "NtQuerySystemInformation(SystemTimeOfDayInformation)"
+        );
+        return NULL;
+    }
+    // Both BootTime and SleepTimeBias are in 100-ns units.
+    boot.QuadPart = info.BootTime.QuadPart - (LONGLONG)info.SleepTimeBias;
+    return Py_BuildValue("d", psutil_LargeIntegerToUnixTime(boot));
+}
+
+
+PyObject *
+psutil_users(PyObject *self, PyObject *args) {
+    HANDLE hServer = WTS_CURRENT_SERVER_HANDLE;
+    LPWSTR buffer_user = NULL;
+    LPWSTR buffer_addr = NULL;
+    LPWSTR buffer_info = NULL;
+    PWTS_SESSION_INFOW sessions = NULL;
+    BOOL ok;
+    DWORD count;
+    DWORD i;
+    DWORD sessionId;
+    DWORD bytes;
+    PWTS_CLIENT_ADDRESS address;
+    char address_str[50];
+    PWTSINFOW wts_info;
+    PyObject *py_address = NULL;
+    PyObject *py_username = NULL;
+    PyObject *py_retlist = PyList_New(0);
+
+    if (py_retlist == NULL)
+        return NULL;
+
+    if (WTSEnumerateSessionsW == NULL || WTSQuerySessionInformationW == NULL
+        || WTSFreeMemory == NULL)
+    {
+        // If we don't run in an environment that is a Remote Desktop Services
+        // environment the Wtsapi32 proc might not be present.
+        // https://docs.microsoft.com/en-us/windows/win32/termserv/run-time-linking-to-wtsapi32-dll
+        psutil_debug("WTS procs not available; return empty list");
+        return py_retlist;
+    }
+
+    // WTS calls are RPC to the Terminal Services service, they may be
+    // slow.
+    Py_BEGIN_ALLOW_THREADS
+    ok = WTSEnumerateSessionsW(hServer, 0, 1, &sessions, &count);
+    Py_END_ALLOW_THREADS
+    if (ok == 0) {
+        if (ERROR_CALL_NOT_IMPLEMENTED == GetLastError()) {
+            // On Windows Nano server, the Wtsapi32 API can be present, but
+            // return WinError 120.
+            psutil_debug(
+                "WTSEnumerateSessionsW -> ERROR_CALL_NOT_IMPLEMENTED; "
+                "return empty list"
+            );
+            return py_retlist;
+        }
+        psutil_oserror_wsyscall("WTSEnumerateSessionsW");
+        goto error;
+    }
+
+    for (i = 0; i < count; i++) {
+        py_address = NULL;
+        sessionId = sessions[i].SessionId;
+        if (buffer_user != NULL)
+            WTSFreeMemory(buffer_user);
+        if (buffer_addr != NULL)
+            WTSFreeMemory(buffer_addr);
+        if (buffer_info != NULL)
+            WTSFreeMemory(buffer_info);
+
+        buffer_user = NULL;
+        buffer_addr = NULL;
+        buffer_info = NULL;
+
+        // username
+        bytes = 0;
+        Py_BEGIN_ALLOW_THREADS
+        ok = WTSQuerySessionInformationW(
+            hServer, sessionId, WTSUserName, &buffer_user, &bytes
+        );
+        Py_END_ALLOW_THREADS
+        if (ok == 0) {
+            psutil_oserror_wsyscall("WTSQuerySessionInformationW");
+            goto error;
+        }
+        if (bytes <= 2)
+            continue;
+
+        // address
+        bytes = 0;
+        Py_BEGIN_ALLOW_THREADS
+        ok = WTSQuerySessionInformationW(
+            hServer, sessionId, WTSClientAddress, &buffer_addr, &bytes
+        );
+        Py_END_ALLOW_THREADS
+        if (ok == 0) {
+            psutil_oserror_wsyscall("WTSQuerySessionInformationW");
+            goto error;
+        }
+
+        address = (PWTS_CLIENT_ADDRESS)buffer_addr;
+        if (address->AddressFamily == AF_INET) {
+            str_format(
+                address_str,
+                sizeof(address_str),
+                "%u.%u.%u.%u",
+                // The IP address is offset by two bytes from the start of the
+                // Address member of the WTS_CLIENT_ADDRESS structure.
+                address->Address[2],
+                address->Address[3],
+                address->Address[4],
+                address->Address[5]
+            );
+            py_address = PyUnicode_FromString(address_str);
+            if (!py_address)
+                goto error;
+        }
+        else {
+            Py_INCREF(Py_None);
+            py_address = Py_None;
+        }
+
+        // login time
+        bytes = 0;
+        Py_BEGIN_ALLOW_THREADS
+        ok = WTSQuerySessionInformationW(
+            hServer, sessionId, WTSSessionInfo, &buffer_info, &bytes
+        );
+        Py_END_ALLOW_THREADS
+        if (ok == 0) {
+            psutil_oserror_wsyscall("WTSQuerySessionInformationW");
+            goto error;
+        }
+        wts_info = (PWTSINFOW)buffer_info;
+
+        py_username = PyUnicode_FromWideChar(buffer_user, wcslen(buffer_user));
+        if (py_username == NULL)
+            goto error;
+
+        if (!pylist_append_fmt(
+                py_retlist,
+                "OOd",
+                py_username,
+                py_address,
+                psutil_LargeIntegerToUnixTime(wts_info->ConnectTime)
+            ))
+        {
+            goto error;
+        }
+        Py_CLEAR(py_username);
+        Py_CLEAR(py_address);
+    }
+
+    WTSFreeMemory(sessions);
+    if (buffer_user != NULL)
+        WTSFreeMemory(buffer_user);
+    if (buffer_addr != NULL)
+        WTSFreeMemory(buffer_addr);
+    if (buffer_info != NULL)
+        WTSFreeMemory(buffer_info);
+    return py_retlist;
+
+error:
+    Py_XDECREF(py_username);
+    Py_XDECREF(py_address);
+    Py_DECREF(py_retlist);
+
+    if (sessions != NULL)
+        WTSFreeMemory(sessions);
+    if (buffer_user != NULL)
+        WTSFreeMemory(buffer_user);
+    if (buffer_addr != NULL)
+        WTSFreeMemory(buffer_addr);
+    if (buffer_info != NULL)
+        WTSFreeMemory(buffer_info);
+    return NULL;
+}
diff --git a/psutil/arch/windows/wmi.c b/psutil/arch/windows/wmi.c
new file mode 100644
index 0000000000..043a367597
--- /dev/null
+++ b/psutil/arch/windows/wmi.c
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+// Functions related to the Windows Management Instrumentation API.
+
+#include <Python.h>
+#include <windows.h>
+#include <pdh.h>
+
+#include "../../arch/all/init.h"
+
+
+// We use an exponentially weighted moving average, just like Unix systems do
+// https://en.wikipedia.org/wiki/Load_(computing)#Unix-style_load_calculation
+//
+// These constants serve as the damping factor and are calculated with
+// 1 / exp(sampling interval in seconds / window size in seconds)
+//
+// This formula comes from linux's include/linux/sched/loadavg.h
+// https://github.com/torvalds/linux/blob/345671ea0f9258f410eb057b9ced9cefbbe5dc78/include/linux/sched/loadavg.h#L20-L23
+#define LOADAVG_FACTOR_1F 0.9200444146293232478931553241
+#define LOADAVG_FACTOR_5F 0.9834714538216174894737477501
+#define LOADAVG_FACTOR_15F 0.9944598480048967508795473394
+// The time interval in seconds between taking load counts, same as Linux
+#define SAMPLING_INTERVAL 5
+
+double load_avg_1m = 0;
+double load_avg_5m = 0;
+double load_avg_15m = 0;
+
+// clang-format off
+#ifdef Py_GIL_DISABLED
+    static PyMutex mutex;
+    #define MUTEX_LOCK(m) PyMutex_Lock(m)
+    #define MUTEX_UNLOCK(m) PyMutex_Unlock(m)
+#else
+    #define MUTEX_LOCK(m)
+    #define MUTEX_UNLOCK(m)
+#endif
+// clang-format on
+
+
+VOID CALLBACK
+LoadAvgCallback(PVOID hCounter, BOOLEAN timedOut) {
+    PDH_FMT_COUNTERVALUE displayValue;
+    double currentLoad;
+    PDH_STATUS err;
+
+    err = PdhGetFormattedCounterValue(
+        (PDH_HCOUNTER)hCounter, PDH_FMT_DOUBLE, 0, &displayValue
+    );
+    // Skip updating the load if we can't get the value successfully
+    if (err != ERROR_SUCCESS) {
+        return;
+    }
+    currentLoad = displayValue.doubleValue;
+
+    MUTEX_LOCK(&mutex);
+    load_avg_1m = load_avg_1m * LOADAVG_FACTOR_1F
+                  + currentLoad * (1.0 - LOADAVG_FACTOR_1F);
+    load_avg_5m = load_avg_5m * LOADAVG_FACTOR_5F
+                  + currentLoad * (1.0 - LOADAVG_FACTOR_5F);
+    load_avg_15m = load_avg_15m * LOADAVG_FACTOR_15F
+                   + currentLoad * (1.0 - LOADAVG_FACTOR_15F);
+    MUTEX_UNLOCK(&mutex);
+}
+
+
+PyObject *
+psutil_init_loadavg_counter(PyObject *self, PyObject *args) {
+    WCHAR *szCounterPath = L"\\System\\Processor Queue Length";
+    PDH_STATUS s;
+    BOOL ret;
+    HQUERY hQuery;
+    HCOUNTER hCounter;
+    HANDLE event;
+    HANDLE waitHandle;
+
+    if ((PdhOpenQueryW(NULL, 0, &hQuery)) != ERROR_SUCCESS) {
+        psutil_runtime_error("PdhOpenQueryW failed");
+        return NULL;
+    }
+
+    s = PdhAddEnglishCounterW(hQuery, szCounterPath, 0, &hCounter);
+    if (s != ERROR_SUCCESS) {
+        psutil_runtime_error(
+            "PdhAddEnglishCounterW failed. Performance counters may be "
+            "disabled."
+        );
+        return NULL;
+    }
+
+    event = CreateEventW(NULL, FALSE, FALSE, L"LoadUpdateEvent");
+    if (event == NULL) {
+        psutil_oserror_wsyscall("CreateEventW");
+        return NULL;
+    }
+
+    s = PdhCollectQueryDataEx(hQuery, SAMPLING_INTERVAL, event);
+    if (s != ERROR_SUCCESS) {
+        psutil_runtime_error("PdhCollectQueryDataEx failed");
+        return NULL;
+    }
+
+    ret = RegisterWaitForSingleObject(
+        &waitHandle,
+        event,
+        (WAITORTIMERCALLBACK)LoadAvgCallback,
+        (PVOID)hCounter,
+        INFINITE,
+        WT_EXECUTEDEFAULT
+    );
+
+    if (ret == 0) {
+        psutil_oserror_wsyscall("RegisterWaitForSingleObject");
+        return NULL;
+    }
+
+    Py_RETURN_NONE;
+}
+
+
+// Emulated 1, 5, 15 minutes getloadavg() (processor queue length).
+// `init_loadavg_counter()` must be called first to engage the
+// mechanism that records load values.
+PyObject *
+psutil_get_loadavg(PyObject *self, PyObject *args) {
+    MUTEX_LOCK(&mutex);
+    double load_avg_1m_l = load_avg_1m;
+    double load_avg_5m_l = load_avg_5m;
+    double load_avg_15m_l = load_avg_15m;
+    MUTEX_UNLOCK(&mutex);
+    return Py_BuildValue(
+        "(ddd)", load_avg_1m_l, load_avg_5m_l, load_avg_15m_l
+    );
+}
diff --git a/psutil/tests/README.rst b/psutil/tests/README.rst
deleted file mode 100644
index 2ad91c143d..0000000000
--- a/psutil/tests/README.rst
+++ /dev/null
@@ -1,19 +0,0 @@
-Instructions for running tests
-==============================
-
-- The recommended way to run tests (also on Windows) is to cd into psutil root
-  directory and run ``make test``.
-
-- Depending on the Python version, dependencies for running tests include
-  ``ipaddress``, ``mock`` and ``unittest2`` modules.
-  On Windows also ``pywin32`` and ``wmi`` modules are recommended
-  (although optional).
-  Run ``make setup-dev-env`` to install all deps (also on Windows).
-
-- To run tests on all supported Python versions install tox
-  (``pip install tox``) then run ``tox`` from psutil root directory.
-
-- Every time a commit is pushed tests are automatically run on Travis
-  (Linux, OSX) and appveyor (Windows):
-  - https://travis-ci.org/giampaolo/psutil/
-  - https://ci.appveyor.com/project/giampaolo/psutil
diff --git a/psutil/tests/__init__.py b/psutil/tests/__init__.py
deleted file mode 100644
index da71826c6e..0000000000
--- a/psutil/tests/__init__.py
+++ /dev/null
@@ -1,686 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""
-Test utilities.
-"""
-
-import atexit
-import contextlib
-import errno
-import functools
-import os
-import re
-import shutil
-import socket
-import stat
-import subprocess
-import sys
-import tempfile
-import textwrap
-import threading
-import time
-import warnings
-from socket import AF_INET
-from socket import SOCK_DGRAM
-from socket import SOCK_STREAM
-try:
-    import ipaddress  # python >= 3.3
-except ImportError:
-    ipaddress = None
-try:
-    from unittest import mock  # py3
-except ImportError:
-    import mock  # NOQA - requires "pip install mock"
-
-import psutil
-from psutil import LINUX
-from psutil import OSX
-from psutil import POSIX
-from psutil import WINDOWS
-from psutil._compat import PY3
-from psutil._compat import unicode
-from psutil._compat import which
-
-if sys.version_info < (2, 7):
-    import unittest2 as unittest  # requires "pip install unittest2"
-else:
-    import unittest
-if sys.version_info >= (3, 4):
-    import enum
-else:
-    enum = None
-
-if PY3:
-    import importlib
-    # python <=3.3
-    if not hasattr(importlib, 'reload'):
-        import imp as importlib
-else:
-    import imp as importlib
-
-__all__ = [
-    # constants
-    'APPVEYOR', 'DEVNULL', 'GLOBAL_TIMEOUT', 'MEMORY_TOLERANCE', 'NO_RETRIES',
-    'PYPY', 'PYTHON', 'RLIMIT_SUPPORT', 'ROOT_DIR', 'SCRIPTS_DIR',
-    'TESTFILE_PREFIX', 'TESTFN', 'TESTFN_UNICODE', 'TOX', 'TRAVIS',
-    'VALID_PROC_STATUSES', 'VERBOSITY',
-    # classes
-    'ThreadTask'
-    # test utils
-    'check_connection_ntuple', 'check_net_address', 'unittest', 'cleanup',
-    'skip_on_access_denied', 'skip_on_not_implemented', 'retry_before_failing',
-    'run_test_module_by_name',
-    # fs utils
-    'chdir', 'safe_remove', 'safe_rmdir', 'create_temp_executable_file',
-    # subprocesses
-    'pyrun', 'reap_children', 'get_test_subprocess',
-    # os
-    'get_winver', 'get_kernel_version',
-    # sync primitives
-    'call_until', 'wait_for_pid', 'wait_for_file',
-    # others
-    'warn', 'decode_path', 'encode_path',
-]
-
-
-# ===================================================================
-# --- constants
-# ===================================================================
-
-
-# conf for retry_before_failing() decorator
-NO_RETRIES = 10
-# bytes tolerance for OS memory related tests
-MEMORY_TOLERANCE = 500 * 1024  # 500KB
-# the timeout used in functions which have to wait
-GLOBAL_TIMEOUT = 3
-
-AF_INET6 = getattr(socket, "AF_INET6")
-AF_UNIX = getattr(socket, "AF_UNIX", None)
-PYTHON = os.path.realpath(sys.executable)
-DEVNULL = open(os.devnull, 'r+')
-TESTFN = os.path.join(os.getcwd(), "$testfile")
-TESTFN_UNICODE = TESTFN + "Æ’Å‘Å‘"
-TESTFILE_PREFIX = 'psutil-test-suite-'
-TOX = os.getenv('TOX') or '' in ('1', 'true')
-PYPY = '__pypy__' in sys.builtin_module_names
-if not PY3:
-    try:
-        TESTFN_UNICODE = unicode(TESTFN_UNICODE, sys.getfilesystemencoding())
-    except UnicodeDecodeError:
-        TESTFN_UNICODE = TESTFN + "???"
-
-ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__),
-                                        '..', '..'))
-SCRIPTS_DIR = os.path.join(ROOT_DIR, 'scripts')
-
-WIN_VISTA = (6, 0, 0) if WINDOWS else None
-VALID_PROC_STATUSES = [getattr(psutil, x) for x in dir(psutil)
-                       if x.startswith('STATUS_')]
-# whether we're running this test suite on Travis (https://travis-ci.org/)
-TRAVIS = bool(os.environ.get('TRAVIS'))
-# whether we're running this test suite on Appveyor for Windows
-# (http://www.appveyor.com/)
-APPVEYOR = bool(os.environ.get('APPVEYOR'))
-
-if TRAVIS or 'tox' in sys.argv[0]:
-    import ipaddress
-if TRAVIS or APPVEYOR:
-    GLOBAL_TIMEOUT = GLOBAL_TIMEOUT * 4
-VERBOSITY = 1 if os.getenv('SILENT') or TOX else 2
-
-# assertRaisesRegexp renamed to assertRaisesRegex in 3.3; add support
-# for the new name
-if not hasattr(unittest.TestCase, 'assertRaisesRegex'):
-    unittest.TestCase.assertRaisesRegex = unittest.TestCase.assertRaisesRegexp
-
-
-# ===================================================================
-# --- classes
-# ===================================================================
-
-
-class ThreadTask(threading.Thread):
-    """A thread object used for running process thread tests."""
-
-    def __init__(self):
-        threading.Thread.__init__(self)
-        self._running = False
-        self._interval = None
-        self._flag = threading.Event()
-
-    def __repr__(self):
-        name = self.__class__.__name__
-        return '<%s running=%s at %#x>' % (name, self._running, id(self))
-
-    def start(self, interval=0.001):
-        """Start thread and keep it running until an explicit
-        stop() request. Polls for shutdown every 'timeout' seconds.
-        """
-        if self._running:
-            raise ValueError("already started")
-        self._interval = interval
-        threading.Thread.start(self)
-        self._flag.wait()
-
-    def run(self):
-        self._running = True
-        self._flag.set()
-        while self._running:
-            time.sleep(self._interval)
-
-    def stop(self):
-        """Stop thread execution and and waits until it is stopped."""
-        if not self._running:
-            raise ValueError("already stopped")
-        self._running = False
-        self.join()
-
-
-# ===================================================================
-# --- subprocesses
-# ===================================================================
-
-
-_subprocesses_started = set()
-
-
-def get_test_subprocess(cmd=None, wait=False, **kwds):
-    """Return a subprocess.Popen object to use in tests.
-    By default stdout and stderr are redirected to /dev/null and the
-    python interpreter is used as test process.
-    If 'wait' is True attemps to make sure the process is in a
-    reasonably initialized state.
-    """
-    if cmd is None:
-        pyline = ""
-        if wait:
-            pyline += "open(r'%s', 'w'); " % TESTFN
-        # A process living for 30 secs. We sleep N times (as opposed to
-        # once) in order to be nicer towards Windows which doesn't handle
-        # interrupt signals properly.
-        pyline += "import time; [time.sleep(0.01) for x in range(3000)];"
-        cmd_ = [PYTHON, "-c", pyline]
-    else:
-        cmd_ = cmd
-    kwds.setdefault("stdin", DEVNULL)
-    kwds.setdefault("stdout", DEVNULL)
-    kwds.setdefault("stderr", DEVNULL)
-    sproc = subprocess.Popen(cmd_, **kwds)
-    if wait:
-        if cmd is None:
-            stop_at = time.time() + 3
-            while stop_at > time.time():
-                if os.path.exists(TESTFN):
-                    break
-                time.sleep(0.001)
-            else:
-                warn("couldn't make sure test file was actually created")
-        else:
-            wait_for_pid(sproc.pid)
-    _subprocesses_started.add(sproc)
-    return sproc
-
-
-_testfiles = []
-
-
-def pyrun(src):
-    """Run python code 'src' in a separate interpreter.
-    Return interpreter subprocess.
-    """
-    if PY3:
-        src = bytes(src, 'ascii')
-    with tempfile.NamedTemporaryFile(
-            prefix=TESTFILE_PREFIX, delete=False) as f:
-        _testfiles.append(f.name)
-        f.write(src)
-        f.flush()
-        subp = get_test_subprocess([PYTHON, f.name], stdout=None,
-                                   stderr=None)
-        wait_for_pid(subp.pid)
-        return subp
-
-
-def sh(cmdline, stdout=subprocess.PIPE, stderr=subprocess.PIPE):
-    """run cmd in a subprocess and return its output.
-    raises RuntimeError on error.
-    """
-    p = subprocess.Popen(cmdline, shell=True, stdout=stdout, stderr=stderr)
-    stdout, stderr = p.communicate()
-    if p.returncode != 0:
-        raise RuntimeError(stderr)
-    if stderr:
-        if PY3:
-            stderr = str(stderr, sys.stderr.encoding or
-                         sys.getfilesystemencoding())
-        warn(stderr)
-    if PY3:
-        stdout = str(stdout, sys.stdout.encoding or
-                     sys.getfilesystemencoding())
-    return stdout.strip()
-
-
-def reap_children(recursive=False):
-    """Kill any subprocess started by this test suite and ensure that
-    no zombies stick around to hog resources and create problems when
-    looking for refleaks.
-    """
-    # Get the children here, before terminating the sub processes
-    # as we don't want to lose the intermediate reference in case
-    # of grand children.
-    if recursive:
-        children = psutil.Process().children(recursive=True)
-    else:
-        children = []
-
-    subprocs = _subprocesses_started.copy()
-    _subprocesses_started.clear()
-    for subp in subprocs:
-        try:
-            subp.terminate()
-        except OSError as err:
-            if err.errno != errno.ESRCH:
-                raise
-        try:
-            subp.wait()
-        except OSError as err:
-            if err.errno != errno.ECHILD:
-                raise
-
-    if children:
-        for p in children:
-            try:
-                p.terminate()
-            except psutil.NoSuchProcess:
-                pass
-        gone, alive = psutil.wait_procs(children, timeout=GLOBAL_TIMEOUT)
-        for p in alive:
-            warn("couldn't terminate process %s" % p)
-            try:
-                p.kill()
-            except psutil.NoSuchProcess:
-                pass
-            _, alive = psutil.wait_procs(alive, timeout=GLOBAL_TIMEOUT)
-            if alive:
-                warn("couldn't not kill processes %s" % str(alive))
-
-
-# ===================================================================
-# --- OS
-# ===================================================================
-
-
-if not POSIX:
-    def get_kernel_version():
-        return ()
-else:
-    def get_kernel_version():
-        """Return a tuple such as (2, 6, 36)."""
-        s = ""
-        uname = os.uname()[2]
-        for c in uname:
-            if c.isdigit() or c == '.':
-                s += c
-            else:
-                break
-        if not s:
-            raise ValueError("can't parse %r" % uname)
-        minor = 0
-        micro = 0
-        nums = s.split('.')
-        major = int(nums[0])
-        if len(nums) >= 2:
-            minor = int(nums[1])
-        if len(nums) >= 3:
-            micro = int(nums[2])
-        return (major, minor, micro)
-
-
-if LINUX:
-    RLIMIT_SUPPORT = get_kernel_version() >= (2, 6, 36)
-else:
-    RLIMIT_SUPPORT = False
-
-
-if not WINDOWS:
-    def get_winver():
-        raise NotImplementedError("not a Windows OS")
-else:
-    def get_winver():
-        wv = sys.getwindowsversion()
-        if hasattr(wv, 'service_pack_major'):  # python >= 2.7
-            sp = wv.service_pack_major or 0
-        else:
-            r = re.search("\s\d$", wv[4])
-            if r:
-                sp = int(r.group(0))
-            else:
-                sp = 0
-        return (wv[0], wv[1], sp)
-
-
-# ===================================================================
-# --- sync primitives
-# ===================================================================
-
-
-def wait_for_pid(pid, timeout=GLOBAL_TIMEOUT):
-    """Wait for pid to show up in the process list then return.
-    Used in the test suite to give time the sub process to initialize.
-    """
-    raise_at = time.time() + timeout
-    while True:
-        if pid in psutil.pids():
-            # give it one more iteration to allow full initialization
-            time.sleep(0.01)
-            return
-        time.sleep(0.0001)
-        if time.time() >= raise_at:
-            raise RuntimeError("Timed out")
-
-
-def wait_for_file(fname, timeout=GLOBAL_TIMEOUT, delete_file=True):
-    """Wait for a file to be written on disk."""
-    stop_at = time.time() + timeout
-    while time.time() < stop_at:
-        try:
-            with open(fname, "r") as f:
-                data = f.read()
-            if not data:
-                continue
-            if delete_file:
-                os.remove(fname)
-            return data
-        except IOError:
-            time.sleep(0.001)
-    raise RuntimeError(
-        "timed out after %s secs (couldn't read file)" % timeout)
-
-
-def call_until(fun, expr, timeout=GLOBAL_TIMEOUT):
-    """Keep calling function for timeout secs and exit if eval()
-    expression is True.
-    """
-    stop_at = time.time() + timeout
-    while time.time() < stop_at:
-        ret = fun()
-        if eval(expr):
-            return ret
-        time.sleep(0.001)
-    raise RuntimeError('timed out after %s secs (ret=%r)' % (timeout, ret))
-
-
-# ===================================================================
-# --- fs
-# ===================================================================
-
-
-def safe_remove(file):
-    "Convenience function for removing temporary test files"
-    try:
-        os.remove(file)
-    except OSError as err:
-        if err.errno != errno.ENOENT:
-            # # file is being used by another process
-            # if WINDOWS and isinstance(err, WindowsError) and err.errno == 13:
-            #     return
-            raise
-
-
-def safe_rmdir(dir):
-    "Convenience function for removing temporary test directories"
-    try:
-        os.rmdir(dir)
-    except OSError as err:
-        if err.errno != errno.ENOENT:
-            raise
-
-
-@contextlib.contextmanager
-def chdir(dirname):
-    """Context manager which temporarily changes the current directory."""
-    curdir = os.getcwd()
-    try:
-        os.chdir(dirname)
-        yield
-    finally:
-        os.chdir(curdir)
-
-
-# ===================================================================
-# --- testing
-# ===================================================================
-
-
-def retry_before_failing(ntimes=None):
-    """Decorator which runs a test function and retries N times before
-    actually failing.
-    """
-    def decorator(fun):
-        @functools.wraps(fun)
-        def wrapper(*args, **kwargs):
-            times = ntimes or NO_RETRIES
-            assert times, times
-            for x in range(times):
-                try:
-                    return fun(*args, **kwargs)
-                except AssertionError as _:
-                    err = _
-            raise err
-        return wrapper
-    return decorator
-
-
-def run_test_module_by_name(name):
-    # testmodules = [os.path.splitext(x)[0] for x in os.listdir(HERE)
-    #                if x.endswith('.py') and x.startswith('test_')]
-    name = os.path.splitext(os.path.basename(name))[0]
-    suite = unittest.TestSuite()
-    suite.addTest(unittest.defaultTestLoader.loadTestsFromName(name))
-    result = unittest.TextTestRunner(verbosity=VERBOSITY).run(suite)
-    success = result.wasSuccessful()
-    sys.exit(0 if success else 1)
-
-
-def skip_on_access_denied(only_if=None):
-    """Decorator to Ignore AccessDenied exceptions."""
-    def decorator(fun):
-        @functools.wraps(fun)
-        def wrapper(*args, **kwargs):
-            try:
-                return fun(*args, **kwargs)
-            except psutil.AccessDenied:
-                if only_if is not None:
-                    if not only_if:
-                        raise
-                msg = "%r was skipped because it raised AccessDenied" \
-                      % fun.__name__
-                raise unittest.SkipTest(msg)
-        return wrapper
-    return decorator
-
-
-def skip_on_not_implemented(only_if=None):
-    """Decorator to Ignore NotImplementedError exceptions."""
-    def decorator(fun):
-        @functools.wraps(fun)
-        def wrapper(*args, **kwargs):
-            try:
-                return fun(*args, **kwargs)
-            except NotImplementedError:
-                if only_if is not None:
-                    if not only_if:
-                        raise
-                msg = "%r was skipped because it raised NotImplementedError" \
-                      % fun.__name__
-                raise unittest.SkipTest(msg)
-        return wrapper
-    return decorator
-
-
-def check_net_address(addr, family):
-    """Check a net address validity. Supported families are IPv4,
-    IPv6 and MAC addresses.
-    """
-    if enum and PY3:
-        assert isinstance(family, enum.IntEnum), family
-    if family == AF_INET:
-        octs = [int(x) for x in addr.split('.')]
-        assert len(octs) == 4, addr
-        for num in octs:
-            assert 0 <= num <= 255, addr
-        if ipaddress:
-            if not PY3:
-                addr = unicode(addr)
-            ipaddress.IPv4Address(addr)
-    elif family == AF_INET6:
-        assert isinstance(addr, str), addr
-        if ipaddress:
-            if not PY3:
-                addr = unicode(addr)
-            ipaddress.IPv6Address(addr)
-    elif family == psutil.AF_LINK:
-        assert re.match('([a-fA-F0-9]{2}[:|\-]?){6}', addr) is not None, addr
-    else:
-        raise ValueError("unknown family %r", family)
-
-
-def check_connection_ntuple(conn):
-    """Check validity of a connection namedtuple."""
-    valid_conn_states = [getattr(psutil, x) for x in dir(psutil) if
-                         x.startswith('CONN_')]
-    assert conn[0] == conn.fd
-    assert conn[1] == conn.family
-    assert conn[2] == conn.type
-    assert conn[3] == conn.laddr
-    assert conn[4] == conn.raddr
-    assert conn[5] == conn.status
-    assert conn.type in (SOCK_STREAM, SOCK_DGRAM), repr(conn.type)
-    assert conn.family in (AF_INET, AF_INET6, AF_UNIX), repr(conn.family)
-    assert conn.status in valid_conn_states, conn.status
-
-    # check IP address and port sanity
-    for addr in (conn.laddr, conn.raddr):
-        if not addr:
-            continue
-        if conn.family in (AF_INET, AF_INET6):
-            assert isinstance(addr, tuple), addr
-            ip, port = addr
-            assert isinstance(port, int), port
-            assert 0 <= port <= 65535, port
-            check_net_address(ip, conn.family)
-        elif conn.family == AF_UNIX:
-            assert isinstance(addr, (str, None)), addr
-        else:
-            raise ValueError("unknown family %r", conn.family)
-
-    if conn.family in (AF_INET, AF_INET6):
-        # actually try to bind the local socket; ignore IPv6
-        # sockets as their address might be represented as
-        # an IPv4-mapped-address (e.g. "::127.0.0.1")
-        # and that's rejected by bind()
-        if conn.family == AF_INET:
-            s = socket.socket(conn.family, conn.type)
-            with contextlib.closing(s):
-                try:
-                    s.bind((conn.laddr[0], 0))
-                except socket.error as err:
-                    if err.errno != errno.EADDRNOTAVAIL:
-                        raise
-    elif conn.family == AF_UNIX:
-        assert not conn.raddr, repr(conn.raddr)
-        assert conn.status == psutil.CONN_NONE, conn.status
-
-    if getattr(conn, 'fd', -1) != -1:
-        assert conn.fd > 0, conn
-        if hasattr(socket, 'fromfd') and not WINDOWS:
-            try:
-                dupsock = socket.fromfd(conn.fd, conn.family, conn.type)
-            except (socket.error, OSError) as err:
-                if err.args[0] != errno.EBADF:
-                    raise
-            else:
-                with contextlib.closing(dupsock):
-                    assert dupsock.family == conn.family
-                    assert dupsock.type == conn.type
-
-
-def create_temp_executable_file(suffix, c_code=None):
-    tmpdir = None
-    if TRAVIS and OSX:
-        tmpdir = "/private/tmp"
-    fd, path = tempfile.mkstemp(
-        prefix='psu', suffix=suffix, dir=tmpdir)
-    os.close(fd)
-
-    if which("gcc"):
-        if c_code is None:
-            c_code = textwrap.dedent(
-                """
-                #include <unistd.h>
-                void main() {
-                    pause();
-                }
-                """)
-        fd, c_file = tempfile.mkstemp(
-            prefix='psu', suffix='.c', dir=tmpdir)
-        os.close(fd)
-        with open(c_file, "w") as f:
-            f.write(c_code)
-        subprocess.check_call(["gcc", c_file, "-o", path])
-        safe_remove(c_file)
-    else:
-        # fallback - use python's executable
-        shutil.copyfile(sys.executable, path)
-        if POSIX:
-            st = os.stat(path)
-            os.chmod(path, st.st_mode | stat.S_IEXEC)
-    return path
-
-
-def cleanup():
-    reap_children(recursive=True)
-    safe_remove(TESTFN)
-    try:
-        safe_rmdir(TESTFN_UNICODE)
-    except UnicodeEncodeError:
-        pass
-    for path in _testfiles:
-        safe_remove(path)
-
-atexit.register(cleanup)
-atexit.register(lambda: DEVNULL.close())
-
-
-# ===================================================================
-# --- others
-# ===================================================================
-
-
-def warn(msg):
-    """Raise a warning msg."""
-    warnings.warn(msg, UserWarning)
-
-
-# In Python 3 paths are unicode objects by default.  Surrogate escapes
-# are used to handle non-character data.
-def encode_path(path):
-    if PY3:
-        return path.encode(sys.getfilesystemencoding(),
-                           errors="surrogateescape")
-    else:
-        return path
-
-
-def decode_path(path):
-    if PY3:
-        return path.decode(sys.getfilesystemencoding(),
-                           errors="surrogateescape")
-    else:
-        return path
diff --git a/psutil/tests/runner.py b/psutil/tests/runner.py
deleted file mode 100644
index c4dd88b3a1..0000000000
--- a/psutil/tests/runner.py
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (C) 2007-2016 Giampaolo Rodola' <g.rodola@gmail.com>.
-# Use of this source code is governed by MIT license that can be
-# found in the LICENSE file.
-
-"""Script for running all test files (except memory leaks tests)."""
-
-import os
-import sys
-
-from psutil.tests import unittest
-from psutil.tests import VERBOSITY
-
-
-HERE = os.path.abspath(os.path.dirname(__file__))
-testmodules = [os.path.splitext(x)[0] for x in os.listdir(HERE)
-               if x.endswith('.py') and x.startswith('test_') and not
-               x.startswith('test_memory_leaks')]
-suite = unittest.TestSuite()
-for tm in testmodules:
-    suite.addTest(unittest.defaultTestLoader.loadTestsFromName(tm))
-result = unittest.TextTestRunner(verbosity=VERBOSITY).run(suite)
-success = result.wasSuccessful()
-sys.exit(0 if success else 1)
diff --git a/psutil/tests/test_bsd.py b/psutil/tests/test_bsd.py
deleted file mode 100644
index 53f830d3d9..0000000000
--- a/psutil/tests/test_bsd.py
+++ /dev/null
@@ -1,383 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-# TODO: (FreeBSD) add test for comparing connections with 'sockstat' cmd.
-
-
-"""Tests specific to all BSD platforms."""
-
-
-import datetime
-import os
-import subprocess
-import sys
-import time
-
-import psutil
-from psutil import BSD
-from psutil import FREEBSD
-from psutil import NETBSD
-from psutil import OPENBSD
-from psutil._compat import PY3
-from psutil.tests import get_test_subprocess
-from psutil.tests import MEMORY_TOLERANCE
-from psutil.tests import reap_children
-from psutil.tests import retry_before_failing
-from psutil.tests import run_test_module_by_name
-from psutil.tests import sh
-from psutil.tests import unittest
-from psutil.tests import which
-
-
-if BSD:
-    PAGESIZE = os.sysconf("SC_PAGE_SIZE")
-    if os.getuid() == 0:  # muse requires root privileges
-        MUSE_AVAILABLE = which('muse')
-    else:
-        MUSE_AVAILABLE = False
-else:
-    MUSE_AVAILABLE = False
-
-
-def sysctl(cmdline):
-    """Expects a sysctl command with an argument and parse the result
-    returning only the value of interest.
-    """
-    result = sh("sysctl " + cmdline)
-    if FREEBSD:
-        result = result[result.find(": ") + 2:]
-    elif OPENBSD or NETBSD:
-        result = result[result.find("=") + 1:]
-    try:
-        return int(result)
-    except ValueError:
-        return result
-
-
-def muse(field):
-    """Thin wrapper around 'muse' cmdline utility."""
-    out = sh('muse')
-    for line in out.split('\n'):
-        if line.startswith(field):
-            break
-    else:
-        raise ValueError("line not found")
-    return int(line.split()[1])
-
-
-# =====================================================================
-# --- All BSD*
-# =====================================================================
-
-
-@unittest.skipUnless(BSD, "not a BSD system")
-class BSDSpecificTestCase(unittest.TestCase):
-    """Generic tests common to all BSD variants."""
-
-    @classmethod
-    def setUpClass(cls):
-        cls.pid = get_test_subprocess().pid
-
-    @classmethod
-    def tearDownClass(cls):
-        reap_children()
-
-    def test_process_create_time(self):
-        cmdline = "ps -o lstart -p %s" % self.pid
-        p = subprocess.Popen(cmdline, shell=1, stdout=subprocess.PIPE)
-        output = p.communicate()[0]
-        if PY3:
-            output = str(output, sys.stdout.encoding)
-        start_ps = output.replace('STARTED', '').strip()
-        start_psutil = psutil.Process(self.pid).create_time()
-        start_psutil = time.strftime("%a %b %e %H:%M:%S %Y",
-                                     time.localtime(start_psutil))
-        self.assertEqual(start_ps, start_psutil)
-
-    def test_disks(self):
-        # test psutil.disk_usage() and psutil.disk_partitions()
-        # against "df -a"
-        def df(path):
-            out = sh('df -k "%s"' % path).strip()
-            lines = out.split('\n')
-            lines.pop(0)
-            line = lines.pop(0)
-            dev, total, used, free = line.split()[:4]
-            if dev == 'none':
-                dev = ''
-            total = int(total) * 1024
-            used = int(used) * 1024
-            free = int(free) * 1024
-            return dev, total, used, free
-
-        for part in psutil.disk_partitions(all=False):
-            usage = psutil.disk_usage(part.mountpoint)
-            dev, total, used, free = df(part.mountpoint)
-            self.assertEqual(part.device, dev)
-            self.assertEqual(usage.total, total)
-            # 10 MB tollerance
-            if abs(usage.free - free) > 10 * 1024 * 1024:
-                self.fail("psutil=%s, df=%s" % (usage.free, free))
-            if abs(usage.used - used) > 10 * 1024 * 1024:
-                self.fail("psutil=%s, df=%s" % (usage.used, used))
-
-    def test_cpu_count_logical(self):
-        syst = sysctl("hw.ncpu")
-        self.assertEqual(psutil.cpu_count(logical=True), syst)
-
-    def test_virtual_memory_total(self):
-        num = sysctl('hw.physmem')
-        self.assertEqual(num, psutil.virtual_memory().total)
-
-
-# =====================================================================
-# --- FreeBSD
-# =====================================================================
-
-
-@unittest.skipUnless(FREEBSD, "not a FreeBSD system")
-class FreeBSDSpecificTestCase(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        cls.pid = get_test_subprocess().pid
-
-    @classmethod
-    def tearDownClass(cls):
-        reap_children()
-
-    def test_boot_time(self):
-        s = sysctl('sysctl kern.boottime')
-        s = s[s.find(" sec = ") + 7:]
-        s = s[:s.find(',')]
-        btime = int(s)
-        self.assertEqual(btime, psutil.boot_time())
-
-    @retry_before_failing()
-    def test_memory_maps(self):
-        out = sh('procstat -v %s' % self.pid)
-        maps = psutil.Process(self.pid).memory_maps(grouped=False)
-        lines = out.split('\n')[1:]
-        while lines:
-            line = lines.pop()
-            fields = line.split()
-            _, start, stop, perms, res = fields[:5]
-            map = maps.pop()
-            self.assertEqual("%s-%s" % (start, stop), map.addr)
-            self.assertEqual(int(res), map.rss)
-            if not map.path.startswith('['):
-                self.assertEqual(fields[10], map.path)
-
-    def test_exe(self):
-        out = sh('procstat -b %s' % self.pid)
-        self.assertEqual(psutil.Process(self.pid).exe(),
-                         out.split('\n')[1].split()[-1])
-
-    def test_cmdline(self):
-        out = sh('procstat -c %s' % self.pid)
-        self.assertEqual(' '.join(psutil.Process(self.pid).cmdline()),
-                         ' '.join(out.split('\n')[1].split()[2:]))
-
-    def test_uids_gids(self):
-        out = sh('procstat -s %s' % self.pid)
-        euid, ruid, suid, egid, rgid, sgid = out.split('\n')[1].split()[2:8]
-        p = psutil.Process(self.pid)
-        uids = p.uids()
-        gids = p.gids()
-        self.assertEqual(uids.real, int(ruid))
-        self.assertEqual(uids.effective, int(euid))
-        self.assertEqual(uids.saved, int(suid))
-        self.assertEqual(gids.real, int(rgid))
-        self.assertEqual(gids.effective, int(egid))
-        self.assertEqual(gids.saved, int(sgid))
-
-    # --- virtual_memory(); tests against sysctl
-
-    @retry_before_failing()
-    def test_vmem_active(self):
-        syst = sysctl("vm.stats.vm.v_active_count") * PAGESIZE
-        self.assertAlmostEqual(psutil.virtual_memory().active, syst,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_vmem_inactive(self):
-        syst = sysctl("vm.stats.vm.v_inactive_count") * PAGESIZE
-        self.assertAlmostEqual(psutil.virtual_memory().inactive, syst,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_vmem_wired(self):
-        syst = sysctl("vm.stats.vm.v_wire_count") * PAGESIZE
-        self.assertAlmostEqual(psutil.virtual_memory().wired, syst,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_vmem_cached(self):
-        syst = sysctl("vm.stats.vm.v_cache_count") * PAGESIZE
-        self.assertAlmostEqual(psutil.virtual_memory().cached, syst,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_vmem_free(self):
-        syst = sysctl("vm.stats.vm.v_free_count") * PAGESIZE
-        self.assertAlmostEqual(psutil.virtual_memory().free, syst,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_vmem_buffers(self):
-        syst = sysctl("vfs.bufspace")
-        self.assertAlmostEqual(psutil.virtual_memory().buffers, syst,
-                               delta=MEMORY_TOLERANCE)
-
-    # --- virtual_memory(); tests against muse
-
-    @unittest.skipUnless(MUSE_AVAILABLE, "muse cmdline tool is not available")
-    def test_muse_vmem_total(self):
-        num = muse('Total')
-        self.assertEqual(psutil.virtual_memory().total, num)
-
-    @unittest.skipUnless(MUSE_AVAILABLE, "muse cmdline tool is not available")
-    @retry_before_failing()
-    def test_muse_vmem_active(self):
-        num = muse('Active')
-        self.assertAlmostEqual(psutil.virtual_memory().active, num,
-                               delta=MEMORY_TOLERANCE)
-
-    @unittest.skipUnless(MUSE_AVAILABLE, "muse cmdline tool is not available")
-    @retry_before_failing()
-    def test_muse_vmem_inactive(self):
-        num = muse('Inactive')
-        self.assertAlmostEqual(psutil.virtual_memory().inactive, num,
-                               delta=MEMORY_TOLERANCE)
-
-    @unittest.skipUnless(MUSE_AVAILABLE, "muse cmdline tool is not available")
-    @retry_before_failing()
-    def test_muse_vmem_wired(self):
-        num = muse('Wired')
-        self.assertAlmostEqual(psutil.virtual_memory().wired, num,
-                               delta=MEMORY_TOLERANCE)
-
-    @unittest.skipUnless(MUSE_AVAILABLE, "muse cmdline tool is not available")
-    @retry_before_failing()
-    def test_muse_vmem_cached(self):
-        num = muse('Cache')
-        self.assertAlmostEqual(psutil.virtual_memory().cached, num,
-                               delta=MEMORY_TOLERANCE)
-
-    @unittest.skipUnless(MUSE_AVAILABLE, "muse cmdline tool is not available")
-    @retry_before_failing()
-    def test_muse_vmem_free(self):
-        num = muse('Free')
-        self.assertAlmostEqual(psutil.virtual_memory().free, num,
-                               delta=MEMORY_TOLERANCE)
-
-    @unittest.skipUnless(MUSE_AVAILABLE, "muse cmdline tool is not available")
-    @retry_before_failing()
-    def test_muse_vmem_buffers(self):
-        num = muse('Buffer')
-        self.assertAlmostEqual(psutil.virtual_memory().buffers, num,
-                               delta=MEMORY_TOLERANCE)
-
-    def test_cpu_stats_ctx_switches(self):
-        self.assertAlmostEqual(psutil.cpu_stats().ctx_switches,
-                               sysctl('vm.stats.sys.v_swtch'), delta=1000)
-
-    def test_cpu_stats_interrupts(self):
-        self.assertAlmostEqual(psutil.cpu_stats().interrupts,
-                               sysctl('vm.stats.sys.v_intr'), delta=1000)
-
-    def test_cpu_stats_soft_interrupts(self):
-        self.assertAlmostEqual(psutil.cpu_stats().soft_interrupts,
-                               sysctl('vm.stats.sys.v_soft'), delta=1000)
-
-    def test_cpu_stats_syscalls(self):
-        self.assertAlmostEqual(psutil.cpu_stats().syscalls,
-                               sysctl('vm.stats.sys.v_syscall'), delta=1000)
-
-    # def test_cpu_stats_traps(self):
-    #    self.assertAlmostEqual(psutil.cpu_stats().traps,
-    #                           sysctl('vm.stats.sys.v_trap'), delta=1000)
-
-
-# =====================================================================
-# --- OpenBSD
-# =====================================================================
-
-@unittest.skipUnless(OPENBSD, "not an OpenBSD system")
-class OpenBSDSpecificTestCase(unittest.TestCase):
-
-    def test_boot_time(self):
-        s = sysctl('kern.boottime')
-        sys_bt = datetime.datetime.strptime(s, "%a %b %d %H:%M:%S %Y")
-        psutil_bt = datetime.datetime.fromtimestamp(psutil.boot_time())
-        self.assertEqual(sys_bt, psutil_bt)
-
-
-# =====================================================================
-# --- NetBSD
-# =====================================================================
-
-@unittest.skipUnless(NETBSD, "not a NetBSD system")
-class NetBSDSpecificTestCase(unittest.TestCase):
-
-    def parse_meminfo(self, look_for):
-        with open('/proc/meminfo', 'rb') as f:
-            for line in f:
-                if line.startswith(look_for):
-                    return int(line.split()[1]) * 1024
-        raise ValueError("can't find %s" % look_for)
-
-    # XXX - failing tests
-
-    # def test_vmem_total(self):
-    #     self.assertEqual(
-    #         psutil.virtual_memory().total, self.parse_meminfo("MemTotal:"))
-
-    # def test_vmem_free(self):
-    #     self.assertEqual(
-    #         psutil.virtual_memory().buffers, self.parse_meminfo("MemFree:"))
-
-    def test_vmem_buffers(self):
-        self.assertEqual(
-            psutil.virtual_memory().buffers, self.parse_meminfo("Buffers:"))
-
-    def test_vmem_shared(self):
-        self.assertEqual(
-            psutil.virtual_memory().shared, self.parse_meminfo("MemShared:"))
-
-    def test_swapmem_total(self):
-        self.assertEqual(
-            psutil.swap_memory().total, self.parse_meminfo("SwapTotal:"))
-
-    def test_swapmem_free(self):
-        self.assertEqual(
-            psutil.swap_memory().free, self.parse_meminfo("SwapFree:"))
-
-    def test_cpu_stats_interrupts(self):
-        with open('/proc/stat', 'rb') as f:
-            for line in f:
-                if line.startswith(b'intr'):
-                    interrupts = int(line.split()[1])
-                    break
-            else:
-                raise ValueError("couldn't find line")
-        self.assertAlmostEqual(
-            psutil.cpu_stats().interrupts, interrupts, delta=1000)
-
-    def test_cpu_stats_ctx_switches(self):
-        with open('/proc/stat', 'rb') as f:
-            for line in f:
-                if line.startswith(b'ctxt'):
-                    ctx_switches = int(line.split()[1])
-                    break
-            else:
-                raise ValueError("couldn't find line")
-        self.assertAlmostEqual(
-            psutil.cpu_stats().ctx_switches, ctx_switches, delta=1000)
-
-
-if __name__ == '__main__':
-    run_test_module_by_name(__file__)
diff --git a/psutil/tests/test_linux.py b/psutil/tests/test_linux.py
deleted file mode 100644
index f6c263655c..0000000000
--- a/psutil/tests/test_linux.py
+++ /dev/null
@@ -1,1024 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Linux specific tests."""
-
-import contextlib
-import errno
-import io
-import os
-import pprint
-import re
-import shutil
-import socket
-import struct
-import tempfile
-import textwrap
-import time
-import warnings
-
-import psutil
-from psutil import LINUX
-from psutil._compat import PY3
-from psutil._compat import u
-from psutil.tests import call_until
-from psutil.tests import get_kernel_version
-from psutil.tests import importlib
-from psutil.tests import MEMORY_TOLERANCE
-from psutil.tests import mock
-from psutil.tests import PYPY
-from psutil.tests import pyrun
-from psutil.tests import reap_children
-from psutil.tests import retry_before_failing
-from psutil.tests import run_test_module_by_name
-from psutil.tests import safe_remove
-from psutil.tests import sh
-from psutil.tests import skip_on_not_implemented
-from psutil.tests import TESTFN
-from psutil.tests import TRAVIS
-from psutil.tests import unittest
-from psutil.tests import which
-
-
-HERE = os.path.abspath(os.path.dirname(__file__))
-SIOCGIFADDR = 0x8915
-SIOCGIFCONF = 0x8912
-SIOCGIFHWADDR = 0x8927
-if LINUX:
-    SECTOR_SIZE = psutil._psplatform.SECTOR_SIZE
-
-
-# =====================================================================
-# utils
-# =====================================================================
-
-def get_ipv4_address(ifname):
-    import fcntl
-    ifname = ifname[:15]
-    if PY3:
-        ifname = bytes(ifname, 'ascii')
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    with contextlib.closing(s):
-        return socket.inet_ntoa(
-            fcntl.ioctl(s.fileno(),
-                        SIOCGIFADDR,
-                        struct.pack('256s', ifname))[20:24])
-
-
-def get_mac_address(ifname):
-    import fcntl
-    ifname = ifname[:15]
-    if PY3:
-        ifname = bytes(ifname, 'ascii')
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    with contextlib.closing(s):
-        info = fcntl.ioctl(
-            s.fileno(), SIOCGIFHWADDR, struct.pack('256s', ifname))
-        if PY3:
-            def ord(x):
-                return x
-        else:
-            import __builtin__
-            ord = __builtin__.ord
-        return ''.join(['%02x:' % ord(char) for char in info[18:24]])[:-1]
-
-
-def free_swap():
-    """Parse 'free' cmd and return swap memory's s total, used and free
-    values.
-    """
-    lines = sh('free').split('\n')
-    for line in lines:
-        if line.startswith('Swap'):
-            _, total, used, free = line.split()
-            return (int(total) * 1024, int(used) * 1024, int(free) * 1024)
-    raise ValueError(
-        "can't find 'Swap' in 'free' output:\n%s" % '\n'.join(lines))
-
-
-def free_physmem():
-    """Parse 'free' cmd and return physical memory's total, used
-    and free values.
-    """
-    # Note: free can have 2 different formats, invalidating 'shared'
-    # and 'cached' memory which may have different positions so we
-    # do not return them.
-    # https://github.com/giampaolo/psutil/issues/538#issuecomment-57059946
-    lines = sh('free').split('\n')
-    for line in lines:
-        if line.startswith('Mem'):
-            total, used, free, shared = \
-                [int(x) * 1024 for x in line.split()[1:5]]
-            return (total, used, free, shared)
-    raise ValueError(
-        "can't find 'Mem' in 'free' output:\n%s" % '\n'.join(lines))
-
-
-# =====================================================================
-# system virtual memory
-# =====================================================================
-
-@unittest.skipUnless(LINUX, "not a Linux system")
-class TestSystemVirtualMemory(unittest.TestCase):
-
-    def test_total(self):
-        total, used, free, shared = free_physmem()
-        self.assertEqual(total, psutil.virtual_memory().total)
-
-    @retry_before_failing()
-    def test_used(self):
-        total, used, free, shared = free_physmem()
-        self.assertAlmostEqual(used, psutil.virtual_memory().used,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_free(self):
-        total, used, free, shared = free_physmem()
-        self.assertAlmostEqual(free, psutil.virtual_memory().free,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_buffers(self):
-        buffers = int(sh('vmstat').split('\n')[2].split()[4]) * 1024
-        self.assertAlmostEqual(buffers, psutil.virtual_memory().buffers,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_cached(self):
-        cached = int(sh('vmstat').split('\n')[2].split()[5]) * 1024
-        self.assertAlmostEqual(cached, psutil.virtual_memory().cached,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    @unittest.skipIf(TRAVIS, "fails on travis")
-    def test_shared(self):
-        total, used, free, shared = free_physmem()
-        self.assertAlmostEqual(shared, psutil.virtual_memory().shared,
-                               delta=MEMORY_TOLERANCE)
-
-    # --- mocked tests
-
-    def test_warnings_mocked(self):
-        with mock.patch('psutil._pslinux.open', create=True) as m:
-            with warnings.catch_warnings(record=True) as ws:
-                warnings.simplefilter("always")
-                ret = psutil._pslinux.virtual_memory()
-                assert m.called
-                self.assertEqual(len(ws), 1)
-                w = ws[0]
-                self.assertTrue(w.filename.endswith('psutil/_pslinux.py'))
-                self.assertIn(
-                    "memory stats couldn't be determined", str(w.message))
-                self.assertEqual(ret.cached, 0)
-                self.assertEqual(ret.active, 0)
-                self.assertEqual(ret.inactive, 0)
-
-
-# =====================================================================
-# system swap memory
-# =====================================================================
-
-@unittest.skipUnless(LINUX, "not a Linux system")
-class TestSystemSwapMemory(unittest.TestCase):
-
-    def test_total(self):
-        total, used, free = free_swap()
-        return self.assertAlmostEqual(total, psutil.swap_memory().total,
-                                      delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_used(self):
-        total, used, free = free_swap()
-        return self.assertAlmostEqual(used, psutil.swap_memory().used,
-                                      delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_free(self):
-        total, used, free = free_swap()
-        return self.assertAlmostEqual(free, psutil.swap_memory().free,
-                                      delta=MEMORY_TOLERANCE)
-
-    def test_warnings_mocked(self):
-        with mock.patch('psutil._pslinux.open', create=True) as m:
-            with warnings.catch_warnings(record=True) as ws:
-                warnings.simplefilter("always")
-                ret = psutil._pslinux.swap_memory()
-                assert m.called
-                self.assertEqual(len(ws), 1)
-                w = ws[0]
-                self.assertTrue(w.filename.endswith('psutil/_pslinux.py'))
-                self.assertIn(
-                    "'sin' and 'sout' swap memory stats couldn't "
-                    "be determined", str(w.message))
-                self.assertEqual(ret.sin, 0)
-                self.assertEqual(ret.sout, 0)
-
-    def test_no_vmstat_mocked(self):
-        # see https://github.com/giampaolo/psutil/issues/722
-        with mock.patch('psutil._pslinux.open', create=True,
-                        side_effect=IOError) as m:
-            with warnings.catch_warnings(record=True) as ws:
-                warnings.simplefilter("always")
-                ret = psutil.swap_memory()
-                assert m.called
-                self.assertEqual(len(ws), 1)
-                w = ws[0]
-                self.assertTrue(w.filename.endswith('psutil/_pslinux.py'))
-                self.assertIn(
-                    "'sin' and 'sout' swap memory stats couldn't "
-                    "be determined and were set to 0",
-                    str(w.message))
-                self.assertEqual(ret.sin, 0)
-                self.assertEqual(ret.sout, 0)
-
-
-# =====================================================================
-# system CPU
-# =====================================================================
-
-@unittest.skipUnless(LINUX, "not a Linux system")
-class TestSystemCPU(unittest.TestCase):
-
-    @unittest.skipIf(TRAVIS, "unknown failure on travis")
-    def test_cpu_times(self):
-        fields = psutil.cpu_times()._fields
-        kernel_ver = re.findall('\d+\.\d+\.\d+', os.uname()[2])[0]
-        kernel_ver_info = tuple(map(int, kernel_ver.split('.')))
-        if kernel_ver_info >= (2, 6, 11):
-            self.assertIn('steal', fields)
-        else:
-            self.assertNotIn('steal', fields)
-        if kernel_ver_info >= (2, 6, 24):
-            self.assertIn('guest', fields)
-        else:
-            self.assertNotIn('guest', fields)
-        if kernel_ver_info >= (3, 2, 0):
-            self.assertIn('guest_nice', fields)
-        else:
-            self.assertNotIn('guest_nice', fields)
-
-    @unittest.skipUnless(which("nproc"), "nproc utility not available")
-    def test_cpu_count_logical_w_nproc(self):
-        num = int(sh("nproc --all"))
-        self.assertEqual(psutil.cpu_count(logical=True), num)
-
-    @unittest.skipUnless(which("lscpu"), "lscpu utility not available")
-    def test_cpu_count_logical_w_lscpu(self):
-        out = sh("lscpu -p")
-        num = len([x for x in out.split('\n') if not x.startswith('#')])
-        self.assertEqual(psutil.cpu_count(logical=True), num)
-
-    def test_cpu_count_logical_mocked(self):
-        import psutil._pslinux
-        original = psutil._pslinux.cpu_count_logical()
-        # Here we want to mock os.sysconf("SC_NPROCESSORS_ONLN") in
-        # order to cause the parsing of /proc/cpuinfo and /proc/stat.
-        with mock.patch(
-                'psutil._pslinux.os.sysconf', side_effect=ValueError) as m:
-            self.assertEqual(psutil._pslinux.cpu_count_logical(), original)
-            assert m.called
-
-            # Let's have open() return emtpy data and make sure None is
-            # returned ('cause we mimick os.cpu_count()).
-            with mock.patch('psutil._pslinux.open', create=True) as m:
-                self.assertIsNone(psutil._pslinux.cpu_count_logical())
-                self.assertEqual(m.call_count, 2)
-                # /proc/stat should be the last one
-                self.assertEqual(m.call_args[0][0], '/proc/stat')
-
-            # Let's push this a bit further and make sure /proc/cpuinfo
-            # parsing works as expected.
-            with open('/proc/cpuinfo', 'rb') as f:
-                cpuinfo_data = f.read()
-            fake_file = io.BytesIO(cpuinfo_data)
-            with mock.patch('psutil._pslinux.open',
-                            return_value=fake_file, create=True) as m:
-                self.assertEqual(psutil._pslinux.cpu_count_logical(), original)
-
-            # Finally, let's make /proc/cpuinfo return meaningless data;
-            # this way we'll fall back on relying on /proc/stat
-            def open_mock(name, *args, **kwargs):
-                if name.startswith('/proc/cpuinfo'):
-                    return io.BytesIO(b"")
-                else:
-                    return orig_open(name, *args, **kwargs)
-
-            orig_open = open
-            patch_point = 'builtins.open' if PY3 else '__builtin__.open'
-            with mock.patch(patch_point, side_effect=open_mock, create=True):
-                self.assertEqual(psutil._pslinux.cpu_count_logical(), original)
-
-    def test_cpu_count_physical_mocked(self):
-        # Have open() return emtpy data and make sure None is returned
-        # ('cause we want to mimick os.cpu_count())
-        with mock.patch('psutil._pslinux.open', create=True) as m:
-            self.assertIsNone(psutil._pslinux.cpu_count_physical())
-            assert m.called
-
-
-# =====================================================================
-# system network
-# =====================================================================
-
-@unittest.skipUnless(LINUX, "not a Linux system")
-class TestSystemNetwork(unittest.TestCase):
-
-    def test_net_if_addrs_ips(self):
-        for name, addrs in psutil.net_if_addrs().items():
-            for addr in addrs:
-                if addr.family == psutil.AF_LINK:
-                    self.assertEqual(addr.address, get_mac_address(name))
-                elif addr.family == socket.AF_INET:
-                    self.assertEqual(addr.address, get_ipv4_address(name))
-                # TODO: test for AF_INET6 family
-
-    def test_net_if_stats(self):
-        for name, stats in psutil.net_if_stats().items():
-            try:
-                out = sh("ifconfig %s" % name)
-            except RuntimeError:
-                pass
-            else:
-                self.assertEqual(stats.isup, 'RUNNING' in out)
-                self.assertEqual(stats.mtu,
-                                 int(re.findall('MTU:(\d+)', out)[0]))
-
-    def test_net_io_counters(self):
-        def ifconfig(nic):
-            ret = {}
-            out = sh("ifconfig %s" % name)
-            ret['packets_recv'] = int(re.findall('RX packets:(\d+)', out)[0])
-            ret['packets_sent'] = int(re.findall('TX packets:(\d+)', out)[0])
-            ret['errin'] = int(re.findall('errors:(\d+)', out)[0])
-            ret['errout'] = int(re.findall('errors:(\d+)', out)[1])
-            ret['dropin'] = int(re.findall('dropped:(\d+)', out)[0])
-            ret['dropout'] = int(re.findall('dropped:(\d+)', out)[1])
-            ret['bytes_recv'] = int(re.findall('RX bytes:(\d+)', out)[0])
-            ret['bytes_sent'] = int(re.findall('TX bytes:(\d+)', out)[0])
-            return ret
-
-        for name, stats in psutil.net_io_counters(pernic=True).items():
-            try:
-                ifconfig_ret = ifconfig(name)
-            except RuntimeError:
-                continue
-            self.assertAlmostEqual(
-                stats.bytes_recv, ifconfig_ret['bytes_recv'], delta=1024)
-            self.assertAlmostEqual(
-                stats.bytes_sent, ifconfig_ret['bytes_sent'], delta=1024)
-            self.assertAlmostEqual(
-                stats.packets_recv, ifconfig_ret['packets_recv'], delta=512)
-            self.assertAlmostEqual(
-                stats.packets_sent, ifconfig_ret['packets_sent'], delta=512)
-            self.assertAlmostEqual(
-                stats.errin, ifconfig_ret['errin'], delta=10)
-            self.assertAlmostEqual(
-                stats.errout, ifconfig_ret['errout'], delta=10)
-            self.assertAlmostEqual(
-                stats.dropin, ifconfig_ret['dropin'], delta=10)
-            self.assertAlmostEqual(
-                stats.dropout, ifconfig_ret['dropout'], delta=10)
-
-    @unittest.skipUnless(which('ip'), "'ip' utility not available")
-    @unittest.skipIf(TRAVIS, "skipped on Travis")
-    def test_net_if_names(self):
-        out = sh("ip addr").strip()
-        nics = [x for x in psutil.net_if_addrs().keys() if ':' not in x]
-        found = 0
-        for line in out.split('\n'):
-            line = line.strip()
-            if re.search("^\d+:", line):
-                found += 1
-                name = line.split(':')[1].strip()
-                self.assertIn(name, nics)
-        self.assertEqual(len(nics), found, msg="%s\n---\n%s" % (
-            pprint.pformat(nics), out))
-
-    @mock.patch('psutil._pslinux.socket.inet_ntop', side_effect=ValueError)
-    @mock.patch('psutil._pslinux.supports_ipv6', return_value=False)
-    def test_net_connections_ipv6_unsupported(self, supports_ipv6, inet_ntop):
-        # see: https://github.com/giampaolo/psutil/issues/623
-        try:
-            s = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
-            self.addCleanup(s.close)
-            s.bind(("::1", 0))
-        except socket.error:
-            pass
-        psutil.net_connections(kind='inet6')
-
-    def test_net_connections_mocked(self):
-        def open_mock(name, *args, **kwargs):
-            if name == '/proc/net/unix':
-                return io.StringIO(textwrap.dedent(u"""\
-                    0: 00000003 000 000 0001 03 462170 @/tmp/dbus-Qw2hMPIU3n
-                    0: 00000003 000 000 0001 03 35010 @/tmp/dbus-tB2X8h69BQ
-                    0: 00000003 000 000 0001 03 34424 @/tmp/dbus-cHy80Y8O
-                    000000000000000000000000000000000000000000000000000000
-                    """))
-            else:
-                return orig_open(name, *args, **kwargs)
-            return orig_open(name, *args)
-
-        orig_open = open
-        patch_point = 'builtins.open' if PY3 else '__builtin__.open'
-        with mock.patch(patch_point, side_effect=open_mock) as m:
-            psutil.net_connections(kind='unix')
-            assert m.called
-
-
-# =====================================================================
-# system disk
-# =====================================================================
-
-@unittest.skipUnless(LINUX, "not a Linux system")
-class TestSystemDisks(unittest.TestCase):
-
-    @unittest.skipUnless(
-        hasattr(os, 'statvfs'), "os.statvfs() function not available")
-    @skip_on_not_implemented()
-    def test_disk_partitions_and_usage(self):
-        # test psutil.disk_usage() and psutil.disk_partitions()
-        # against "df -a"
-        def df(path):
-            out = sh('df -P -B 1 "%s"' % path).strip()
-            lines = out.split('\n')
-            lines.pop(0)
-            line = lines.pop(0)
-            dev, total, used, free = line.split()[:4]
-            if dev == 'none':
-                dev = ''
-            total, used, free = int(total), int(used), int(free)
-            return dev, total, used, free
-
-        for part in psutil.disk_partitions(all=False):
-            usage = psutil.disk_usage(part.mountpoint)
-            dev, total, used, free = df(part.mountpoint)
-            self.assertEqual(usage.total, total)
-            # 10 MB tollerance
-            if abs(usage.free - free) > 10 * 1024 * 1024:
-                self.fail("psutil=%s, df=%s" % (usage.free, free))
-            if abs(usage.used - used) > 10 * 1024 * 1024:
-                self.fail("psutil=%s, df=%s" % (usage.used, used))
-
-    def test_disk_partitions_mocked(self):
-        # Test that ZFS partitions are returned.
-        with open("/proc/filesystems", "r") as f:
-            data = f.read()
-        if 'zfs' in data:
-            for part in psutil.disk_partitions():
-                if part.fstype == 'zfs':
-                    break
-            else:
-                self.fail("couldn't find any ZFS partition")
-        else:
-            # No ZFS partitions on this system. Let's fake one.
-            fake_file = io.StringIO(u("nodev\tzfs\n"))
-            with mock.patch('psutil._pslinux.open',
-                            return_value=fake_file, create=True) as m1:
-                with mock.patch(
-                        'psutil._pslinux.cext.disk_partitions',
-                        return_value=[('/dev/sdb3', '/', 'zfs', 'rw')]) as m2:
-                    ret = psutil.disk_partitions()
-                    assert m1.called
-                    assert m2.called
-                    assert ret
-                    self.assertEqual(ret[0].fstype, 'zfs')
-
-    def test_disk_io_counters_kernel_2_4_mocked(self):
-        # Tests /proc/diskstats parsing format for 2.4 kernels, see:
-        # https://github.com/giampaolo/psutil/issues/767
-        def open_mock(name, *args, **kwargs):
-            if name == '/proc/partitions':
-                return io.StringIO(textwrap.dedent(u"""\
-                    major minor  #blocks  name
-
-                       8        0  488386584 hda
-                    """))
-            elif name == '/proc/diskstats':
-                return io.StringIO(
-                    u("   3     0   1 hda 2 3 4 5 6 7 8 9 10 11 12"))
-            else:
-                return orig_open(name, *args, **kwargs)
-            return orig_open(name, *args)
-
-        orig_open = open
-        patch_point = 'builtins.open' if PY3 else '__builtin__.open'
-        with mock.patch(patch_point, side_effect=open_mock) as m:
-            ret = psutil.disk_io_counters()
-            assert m.called
-            self.assertEqual(ret.read_count, 1)
-            self.assertEqual(ret.read_merged_count, 2)
-            self.assertEqual(ret.read_bytes, 3 * SECTOR_SIZE)
-            self.assertEqual(ret.read_time, 4)
-            self.assertEqual(ret.write_count, 5)
-            self.assertEqual(ret.write_merged_count, 6)
-            self.assertEqual(ret.write_bytes, 7 * SECTOR_SIZE)
-            self.assertEqual(ret.write_time, 8)
-            self.assertEqual(ret.busy_time, 10)
-
-    def test_disk_io_counters_kernel_2_6_full_mocked(self):
-        # Tests /proc/diskstats parsing format for 2.6 kernels,
-        # lines reporting all metrics:
-        # https://github.com/giampaolo/psutil/issues/767
-        def open_mock(name, *args, **kwargs):
-            if name == '/proc/partitions':
-                return io.StringIO(textwrap.dedent(u"""\
-                    major minor  #blocks  name
-
-                       8        0  488386584 hda
-                    """))
-            elif name == '/proc/diskstats':
-                return io.StringIO(
-                    u("   3    0   hda 1 2 3 4 5 6 7 8 9 10 11"))
-            else:
-                return orig_open(name, *args, **kwargs)
-            return orig_open(name, *args)
-
-        orig_open = open
-        patch_point = 'builtins.open' if PY3 else '__builtin__.open'
-        with mock.patch(patch_point, side_effect=open_mock) as m:
-            ret = psutil.disk_io_counters()
-            assert m.called
-            self.assertEqual(ret.read_count, 1)
-            self.assertEqual(ret.read_merged_count, 2)
-            self.assertEqual(ret.read_bytes, 3 * SECTOR_SIZE)
-            self.assertEqual(ret.read_time, 4)
-            self.assertEqual(ret.write_count, 5)
-            self.assertEqual(ret.write_merged_count, 6)
-            self.assertEqual(ret.write_bytes, 7 * SECTOR_SIZE)
-            self.assertEqual(ret.write_time, 8)
-            self.assertEqual(ret.busy_time, 10)
-
-    def test_disk_io_counters_kernel_2_6_limited_mocked(self):
-        # Tests /proc/diskstats parsing format for 2.6 kernels,
-        # where one line of /proc/partitions return a limited
-        # amount of metrics when it bumps into a partition
-        # (instead of a disk). See:
-        # https://github.com/giampaolo/psutil/issues/767
-        def open_mock(name, *args, **kwargs):
-            if name == '/proc/partitions':
-                return io.StringIO(textwrap.dedent(u"""\
-                    major minor  #blocks  name
-
-                       8        0  488386584 hda
-                    """))
-            elif name == '/proc/diskstats':
-                return io.StringIO(
-                    u("   3    1   hda 1 2 3 4"))
-            else:
-                return orig_open(name, *args, **kwargs)
-            return orig_open(name, *args)
-
-        orig_open = open
-        patch_point = 'builtins.open' if PY3 else '__builtin__.open'
-        with mock.patch(patch_point, side_effect=open_mock) as m:
-            ret = psutil.disk_io_counters()
-            assert m.called
-            self.assertEqual(ret.read_count, 1)
-            self.assertEqual(ret.read_bytes, 2 * SECTOR_SIZE)
-            self.assertEqual(ret.write_count, 3)
-            self.assertEqual(ret.write_bytes, 4 * SECTOR_SIZE)
-
-            self.assertEqual(ret.read_merged_count, 0)
-            self.assertEqual(ret.read_time, 0)
-            self.assertEqual(ret.write_merged_count, 0)
-            self.assertEqual(ret.write_time, 0)
-            self.assertEqual(ret.busy_time, 0)
-
-
-# =====================================================================
-# misc
-# =====================================================================
-
-@unittest.skipUnless(LINUX, "not a Linux system")
-class TestMisc(unittest.TestCase):
-
-    @mock.patch('psutil.traceback.print_exc')
-    def test_no_procfs_on_import(self, tb):
-        my_procfs = tempfile.mkdtemp()
-
-        with open(os.path.join(my_procfs, 'stat'), 'w') as f:
-            f.write('cpu   0 0 0 0 0 0 0 0 0 0\n')
-            f.write('cpu0  0 0 0 0 0 0 0 0 0 0\n')
-            f.write('cpu1  0 0 0 0 0 0 0 0 0 0\n')
-
-        try:
-            orig_open = open
-
-            def open_mock(name, *args, **kwargs):
-                if name.startswith('/proc'):
-                    raise IOError(errno.ENOENT, 'rejecting access for test')
-                return orig_open(name, *args, **kwargs)
-
-            patch_point = 'builtins.open' if PY3 else '__builtin__.open'
-            with mock.patch(patch_point, side_effect=open_mock):
-                importlib.reload(psutil)
-                assert tb.called
-
-                self.assertRaises(IOError, psutil.cpu_times)
-                self.assertRaises(IOError, psutil.cpu_times, percpu=True)
-                self.assertRaises(IOError, psutil.cpu_percent)
-                self.assertRaises(IOError, psutil.cpu_percent, percpu=True)
-                self.assertRaises(IOError, psutil.cpu_times_percent)
-                self.assertRaises(
-                    IOError, psutil.cpu_times_percent, percpu=True)
-
-                psutil.PROCFS_PATH = my_procfs
-
-                self.assertEqual(psutil.cpu_percent(), 0)
-                self.assertEqual(sum(psutil.cpu_times_percent()), 0)
-
-                # since we don't know the number of CPUs at import time,
-                # we awkwardly say there are none until the second call
-                per_cpu_percent = psutil.cpu_percent(percpu=True)
-                self.assertEqual(sum(per_cpu_percent), 0)
-
-                # ditto awkward length
-                per_cpu_times_percent = psutil.cpu_times_percent(percpu=True)
-                self.assertEqual(sum(map(sum, per_cpu_times_percent)), 0)
-
-                # much user, very busy
-                with open(os.path.join(my_procfs, 'stat'), 'w') as f:
-                    f.write('cpu   1 0 0 0 0 0 0 0 0 0\n')
-                    f.write('cpu0  1 0 0 0 0 0 0 0 0 0\n')
-                    f.write('cpu1  1 0 0 0 0 0 0 0 0 0\n')
-
-                self.assertNotEqual(psutil.cpu_percent(), 0)
-                self.assertNotEqual(
-                    sum(psutil.cpu_percent(percpu=True)), 0)
-                self.assertNotEqual(sum(psutil.cpu_times_percent()), 0)
-                self.assertNotEqual(
-                    sum(map(sum, psutil.cpu_times_percent(percpu=True))), 0)
-        finally:
-            shutil.rmtree(my_procfs)
-            importlib.reload(psutil)
-
-        self.assertEqual(psutil.PROCFS_PATH, '/proc')
-
-    @unittest.skipUnless(
-        get_kernel_version() >= (2, 6, 36),
-        "prlimit() not available on this Linux kernel version")
-    def test_prlimit_availability(self):
-        # prlimit() should be available starting from kernel 2.6.36
-        p = psutil.Process(os.getpid())
-        p.rlimit(psutil.RLIMIT_NOFILE)
-        # if prlimit() is supported *at least* these constants should
-        # be available
-        self.assertTrue(hasattr(psutil, "RLIM_INFINITY"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_AS"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_CORE"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_CPU"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_DATA"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_FSIZE"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_LOCKS"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_MEMLOCK"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_NOFILE"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_NPROC"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_RSS"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_STACK"))
-
-    @unittest.skipUnless(
-        get_kernel_version() >= (3, 0),
-        "prlimit constants not available on this Linux kernel version")
-    def test_resource_consts_kernel_v(self):
-        # more recent constants
-        self.assertTrue(hasattr(psutil, "RLIMIT_MSGQUEUE"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_NICE"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_RTPRIO"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_RTTIME"))
-        self.assertTrue(hasattr(psutil, "RLIMIT_SIGPENDING"))
-
-    def test_boot_time_mocked(self):
-        with mock.patch('psutil._pslinux.open', create=True) as m:
-            self.assertRaises(
-                RuntimeError,
-                psutil._pslinux.boot_time)
-            assert m.called
-
-    def test_users_mocked(self):
-        # Make sure ':0' and ':0.0' (returned by C ext) are converted
-        # to 'localhost'.
-        with mock.patch('psutil._pslinux.cext.users',
-                        return_value=[('giampaolo', 'pts/2', ':0',
-                                       1436573184.0, True)]) as m:
-            self.assertEqual(psutil.users()[0].host, 'localhost')
-            assert m.called
-        with mock.patch('psutil._pslinux.cext.users',
-                        return_value=[('giampaolo', 'pts/2', ':0.0',
-                                       1436573184.0, True)]) as m:
-            self.assertEqual(psutil.users()[0].host, 'localhost')
-            assert m.called
-        # ...otherwise it should be returned as-is
-        with mock.patch('psutil._pslinux.cext.users',
-                        return_value=[('giampaolo', 'pts/2', 'foo',
-                                       1436573184.0, True)]) as m:
-            self.assertEqual(psutil.users()[0].host, 'foo')
-            assert m.called
-
-    def test_procfs_path(self):
-        tdir = tempfile.mkdtemp()
-        try:
-            psutil.PROCFS_PATH = tdir
-            self.assertRaises(IOError, psutil.virtual_memory)
-            self.assertRaises(IOError, psutil.cpu_times)
-            self.assertRaises(IOError, psutil.cpu_times, percpu=True)
-            self.assertRaises(IOError, psutil.boot_time)
-            # self.assertRaises(IOError, psutil.pids)
-            self.assertRaises(IOError, psutil.net_connections)
-            self.assertRaises(IOError, psutil.net_io_counters)
-            self.assertRaises(IOError, psutil.net_if_stats)
-            self.assertRaises(IOError, psutil.disk_io_counters)
-            self.assertRaises(IOError, psutil.disk_partitions)
-            self.assertRaises(psutil.NoSuchProcess, psutil.Process)
-        finally:
-            psutil.PROCFS_PATH = "/proc"
-            os.rmdir(tdir)
-
-    def test_sector_size_mock(self):
-        # Test SECTOR_SIZE fallback in case 'hw_sector_size' file
-        # does not exist.
-        def open_mock(name, *args, **kwargs):
-            if PY3 and isinstance(name, bytes):
-                name = name.decode()
-            if name.startswith("/sys/block/sda/queue/hw_sector_size"):
-                flag.append(None)
-                raise IOError(errno.ENOENT, '')
-            else:
-                return orig_open(name, *args, **kwargs)
-
-        flag = []
-        orig_open = open
-        patch_point = 'builtins.open' if PY3 else '__builtin__.open'
-        try:
-            with mock.patch(patch_point, side_effect=open_mock):
-                importlib.reload(psutil._pslinux)
-                importlib.reload(psutil)
-                self.assertEqual(flag, [None])
-                self.assertEqual(psutil._pslinux.SECTOR_SIZE, 512)
-        finally:
-            importlib.reload(psutil._pslinux)
-            importlib.reload(psutil)
-
-
-# =====================================================================
-# test process
-# =====================================================================
-
-@unittest.skipUnless(LINUX, "not a Linux system")
-class TestProcess(unittest.TestCase):
-
-    def setUp(self):
-        safe_remove(TESTFN)
-
-    tearDown = setUp
-
-    def test_compare_stat_and_status_files(self):
-        # /proc/pid/stat and /proc/pid/status have many values in common.
-        # Whenever possible, psutil uses /proc/pid/stat (it's faster).
-        # For all those cases we check that the value found in
-        # /proc/pid/stat (by psutil) matches the one found in
-        # /proc/pid/status.
-        for p in psutil.process_iter():
-            try:
-                f = psutil._psplatform.open_text('/proc/%s/status' % p.pid)
-            except IOError:
-                pass
-            else:
-                with f:
-                    for line in f:
-                        line = line.strip()
-                        if line.startswith('Name:'):
-                            name = line.split()[1]
-                            # Name is truncated to 15 chars
-                            self.assertEqual(p.name()[:15], name[:15])
-                        elif line.startswith('State:'):
-                            status = line[line.find('(') + 1:line.rfind(')')]
-                            status = status.replace(' ', '-')
-                            self.assertEqual(p.status(), status)
-                        elif line.startswith('PPid:'):
-                            ppid = int(line.split()[1])
-                            self.assertEqual(p.ppid(), ppid)
-                        # The ones below internally are determined by reading
-                        # 'status' file but we use a re to extract the info
-                        # so it makes sense to check them.
-                        elif line.startswith('Threads:'):
-                            num_threads = int(line.split()[1])
-                            self.assertEqual(p.num_threads(), num_threads)
-                        elif line.startswith('Uid:'):
-                            uids = tuple(map(int, line.split()[1:4]))
-                            self.assertEqual(tuple(p.uids()), uids)
-                        elif line.startswith('Gid:'):
-                            gids = tuple(map(int, line.split()[1:4]))
-                            self.assertEqual(tuple(p.gids()), gids)
-                        elif line.startswith('voluntary_ctxt_switches:'):
-                            vol = int(line.split()[1])
-                            self.assertAlmostEqual(
-                                p.num_ctx_switches().voluntary, vol, delta=2)
-                        elif line.startswith('nonvoluntary_ctxt_switches:'):
-                            invol = int(line.split()[1])
-                            self.assertAlmostEqual(
-                                p.num_ctx_switches().involuntary, invol,
-                                delta=2)
-
-    def test_memory_maps(self):
-        src = textwrap.dedent("""
-            import time
-            with open("%s", "w") as f:
-                time.sleep(10)
-            """ % TESTFN)
-        sproc = pyrun(src)
-        self.addCleanup(reap_children)
-        call_until(lambda: os.listdir('.'), "'%s' not in ret" % TESTFN)
-        p = psutil.Process(sproc.pid)
-        time.sleep(.1)
-        maps = p.memory_maps(grouped=False)
-        pmap = sh('pmap -x %s' % p.pid).split('\n')
-        # get rid of header
-        del pmap[0]
-        del pmap[0]
-        while maps and pmap:
-            this = maps.pop(0)
-            other = pmap.pop(0)
-            addr, _, rss, dirty, mode, path = other.split(None, 5)
-            if not path.startswith('[') and not path.endswith(']'):
-                self.assertEqual(path, os.path.basename(this.path))
-            self.assertEqual(int(rss) * 1024, this.rss)
-            # test only rwx chars, ignore 's' and 'p'
-            self.assertEqual(mode[:3], this.perms[:3])
-
-    def test_memory_full_info(self):
-        src = textwrap.dedent("""
-            import time
-            with open("%s", "w") as f:
-                time.sleep(10)
-            """ % TESTFN)
-        sproc = pyrun(src)
-        self.addCleanup(reap_children)
-        call_until(lambda: os.listdir('.'), "'%s' not in ret" % TESTFN)
-        p = psutil.Process(sproc.pid)
-        time.sleep(.1)
-        mem = p.memory_full_info()
-        maps = p.memory_maps(grouped=False)
-        self.assertAlmostEqual(
-            mem.uss, sum([x.private_dirty + x.private_clean for x in maps]),
-            delta=4096)
-        self.assertAlmostEqual(
-            mem.pss, sum([x.pss for x in maps]), delta=4096)
-        self.assertAlmostEqual(
-            mem.swap, sum([x.swap for x in maps]), delta=4096)
-
-    # On PYPY file descriptors are not closed fast enough.
-    @unittest.skipIf(PYPY, "skipped on PYPY")
-    def test_open_files_mode(self):
-        def get_test_file():
-            p = psutil.Process()
-            giveup_at = time.time() + 2
-            while True:
-                for file in p.open_files():
-                    if file.path == os.path.abspath(TESTFN):
-                        return file
-                    elif time.time() > giveup_at:
-                        break
-            raise RuntimeError("timeout looking for test file")
-
-        #
-        with open(TESTFN, "w"):
-            self.assertEqual(get_test_file().mode, "w")
-        with open(TESTFN, "r"):
-            self.assertEqual(get_test_file().mode, "r")
-        with open(TESTFN, "a"):
-            self.assertEqual(get_test_file().mode, "a")
-        #
-        with open(TESTFN, "r+"):
-            self.assertEqual(get_test_file().mode, "r+")
-        with open(TESTFN, "w+"):
-            self.assertEqual(get_test_file().mode, "r+")
-        with open(TESTFN, "a+"):
-            self.assertEqual(get_test_file().mode, "a+")
-        # note: "x" bit is not supported
-        if PY3:
-            safe_remove(TESTFN)
-            with open(TESTFN, "x"):
-                self.assertEqual(get_test_file().mode, "w")
-            safe_remove(TESTFN)
-            with open(TESTFN, "x+"):
-                self.assertEqual(get_test_file().mode, "r+")
-
-    def test_open_files_file_gone(self):
-        # simulates a file which gets deleted during open_files()
-        # execution
-        p = psutil.Process()
-        files = p.open_files()
-        with tempfile.NamedTemporaryFile():
-            # give the kernel some time to see the new file
-            call_until(p.open_files, "len(ret) != %i" % len(files))
-            with mock.patch('psutil._pslinux.os.readlink',
-                            side_effect=OSError(errno.ENOENT, "")) as m:
-                files = p.open_files()
-                assert not files
-                assert m.called
-            # also simulate the case where os.readlink() returns EINVAL
-            # in which case psutil is supposed to 'continue'
-            with mock.patch('psutil._pslinux.os.readlink',
-                            side_effect=OSError(errno.EINVAL, "")) as m:
-                self.assertEqual(p.open_files(), [])
-                assert m.called
-
-    # --- mocked tests
-
-    def test_terminal_mocked(self):
-        with mock.patch('psutil._pslinux._psposix.get_terminal_map',
-                        return_value={}) as m:
-            self.assertIsNone(psutil._pslinux.Process(os.getpid()).terminal())
-            assert m.called
-
-    # TODO: re-enable this test.
-    # def test_num_ctx_switches_mocked(self):
-    #     with mock.patch('psutil._pslinux.open', create=True) as m:
-    #         self.assertRaises(
-    #             NotImplementedError,
-    #             psutil._pslinux.Process(os.getpid()).num_ctx_switches)
-    #         assert m.called
-
-    def test_cmdline_mocked(self):
-        # see: https://github.com/giampaolo/psutil/issues/639
-        p = psutil.Process()
-        fake_file = io.StringIO(u('foo\x00bar\x00'))
-        with mock.patch('psutil._pslinux.open',
-                        return_value=fake_file, create=True) as m:
-            p.cmdline() == ['foo', 'bar']
-            assert m.called
-        fake_file = io.StringIO(u('foo\x00bar\x00\x00'))
-        with mock.patch('psutil._pslinux.open',
-                        return_value=fake_file, create=True) as m:
-            p.cmdline() == ['foo', 'bar', '']
-            assert m.called
-
-    def test_io_counters_mocked(self):
-        with mock.patch('psutil._pslinux.open', create=True) as m:
-            self.assertRaises(
-                NotImplementedError,
-                psutil._pslinux.Process(os.getpid()).io_counters)
-            assert m.called
-
-    def test_readlink_path_deleted_mocked(self):
-        with mock.patch('psutil._pslinux.os.readlink',
-                        return_value='/home/foo (deleted)'):
-            self.assertEqual(psutil.Process().exe(), "/home/foo")
-            self.assertEqual(psutil.Process().cwd(), "/home/foo")
-
-    def test_threads_mocked(self):
-        # Test the case where os.listdir() returns a file (thread)
-        # which no longer exists by the time we open() it (race
-        # condition). threads() is supposed to ignore that instead
-        # of raising NSP.
-        def open_mock(name, *args, **kwargs):
-            if name.startswith('/proc/%s/task' % os.getpid()):
-                raise IOError(errno.ENOENT, "")
-            else:
-                return orig_open(name, *args, **kwargs)
-
-        orig_open = open
-        patch_point = 'builtins.open' if PY3 else '__builtin__.open'
-        with mock.patch(patch_point, side_effect=open_mock) as m:
-            ret = psutil.Process().threads()
-            assert m.called
-            self.assertEqual(ret, [])
-
-        # ...but if it bumps into something != ENOENT we want an
-        # exception.
-        def open_mock(name, *args, **kwargs):
-            if name.startswith('/proc/%s/task' % os.getpid()):
-                raise IOError(errno.EPERM, "")
-            else:
-                return orig_open(name, *args, **kwargs)
-
-        with mock.patch(patch_point, side_effect=open_mock):
-            self.assertRaises(psutil.AccessDenied, psutil.Process().threads)
-
-    # not sure why (doesn't fail locally)
-    # https://travis-ci.org/giampaolo/psutil/jobs/108629915
-    @unittest.skipIf(TRAVIS, "fails on travis")
-    def test_exe_mocked(self):
-        with mock.patch('psutil._pslinux.os.readlink',
-                        side_effect=OSError(errno.ENOENT, "")) as m:
-            # No such file error; might be raised also if /proc/pid/exe
-            # path actually exists for system processes with low pids
-            # (about 0-20). In this case psutil is supposed to return
-            # an empty string.
-            ret = psutil.Process().exe()
-            assert m.called
-            self.assertEqual(ret, "")
-
-            # ...but if /proc/pid no longer exist we're supposed to treat
-            # it as an alias for zombie process
-            with mock.patch('psutil._pslinux.os.path.lexists',
-                            return_value=False):
-                self.assertRaises(psutil.ZombieProcess, psutil.Process().exe)
-
-
-if __name__ == '__main__':
-    run_test_module_by_name(__file__)
diff --git a/psutil/tests/test_memory_leaks.py b/psutil/tests/test_memory_leaks.py
deleted file mode 100644
index b7eabffb29..0000000000
--- a/psutil/tests/test_memory_leaks.py
+++ /dev/null
@@ -1,471 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""
-A test script which attempts to detect memory leaks by calling C
-functions many times and compare process memory usage before and
-after the calls.  It might produce false positives.
-"""
-
-import functools
-import gc
-import os
-import socket
-import threading
-import time
-
-import psutil
-import psutil._common
-from psutil import FREEBSD
-from psutil import LINUX
-from psutil import OPENBSD
-from psutil import OSX
-from psutil import POSIX
-from psutil import SUNOS
-from psutil import WINDOWS
-from psutil._common import supports_ipv6
-from psutil._compat import callable
-from psutil._compat import xrange
-from psutil.tests import get_test_subprocess
-from psutil.tests import reap_children
-from psutil.tests import RLIMIT_SUPPORT
-from psutil.tests import run_test_module_by_name
-from psutil.tests import safe_remove
-from psutil.tests import TESTFN
-from psutil.tests import TRAVIS
-from psutil.tests import unittest
-
-
-LOOPS = 1000
-MEMORY_TOLERANCE = 4096
-SKIP_PYTHON_IMPL = True
-
-
-def skip_if_linux():
-    return unittest.skipIf(LINUX and SKIP_PYTHON_IMPL,
-                           "not worth being tested on LINUX (pure python)")
-
-
-class Base(unittest.TestCase):
-    proc = psutil.Process()
-
-    def execute(self, function, *args, **kwargs):
-        def call_many_times():
-            for x in xrange(LOOPS - 1):
-                self.call(function, *args, **kwargs)
-            del x
-            gc.collect()
-            return self.get_mem()
-
-        self.call(function, *args, **kwargs)
-        self.assertEqual(gc.garbage, [])
-        self.assertEqual(threading.active_count(), 1)
-
-        # RSS comparison
-        # step 1
-        rss1 = call_many_times()
-        # step 2
-        rss2 = call_many_times()
-
-        difference = rss2 - rss1
-        if difference > MEMORY_TOLERANCE:
-            # This doesn't necessarily mean we have a leak yet.
-            # At this point we assume that after having called the
-            # function so many times the memory usage is stabilized
-            # and if there are no leaks it should not increase any
-            # more.
-            # Let's keep calling fun for 3 more seconds and fail if
-            # we notice any difference.
-            stop_at = time.time() + 3
-            while True:
-                self.call(function, *args, **kwargs)
-                if time.time() >= stop_at:
-                    break
-            del stop_at
-            gc.collect()
-            rss3 = self.get_mem()
-            difference = rss3 - rss2
-            if rss3 > rss2:
-                self.fail("rss2=%s, rss3=%s, difference=%s"
-                          % (rss2, rss3, difference))
-
-    def execute_w_exc(self, exc, function, *args, **kwargs):
-        kwargs['_exc'] = exc
-        self.execute(function, *args, **kwargs)
-
-    def get_mem(self):
-        return psutil.Process().memory_info()[0]
-
-    def call(self, function, *args, **kwargs):
-        raise NotImplementedError("must be implemented in subclass")
-
-
-class TestProcessObjectLeaks(Base):
-    """Test leaks of Process class methods and properties"""
-
-    def setUp(self):
-        gc.collect()
-
-    def tearDown(self):
-        reap_children()
-
-    def call(self, function, *args, **kwargs):
-        if callable(function):
-            if '_exc' in kwargs:
-                exc = kwargs.pop('_exc')
-                self.assertRaises(exc, function, *args, **kwargs)
-            else:
-                try:
-                    function(*args, **kwargs)
-                except psutil.Error:
-                    pass
-        else:
-            meth = getattr(self.proc, function)
-            if '_exc' in kwargs:
-                exc = kwargs.pop('_exc')
-                self.assertRaises(exc, meth, *args, **kwargs)
-            else:
-                try:
-                    meth(*args, **kwargs)
-                except psutil.Error:
-                    pass
-
-    @skip_if_linux()
-    def test_name(self):
-        self.execute('name')
-
-    @skip_if_linux()
-    def test_cmdline(self):
-        self.execute('cmdline')
-
-    @skip_if_linux()
-    def test_exe(self):
-        self.execute('exe')
-
-    @skip_if_linux()
-    def test_ppid(self):
-        self.execute('ppid')
-
-    @unittest.skipUnless(POSIX, "POSIX only")
-    @skip_if_linux()
-    def test_uids(self):
-        self.execute('uids')
-
-    @unittest.skipUnless(POSIX, "POSIX only")
-    @skip_if_linux()
-    def test_gids(self):
-        self.execute('gids')
-
-    @skip_if_linux()
-    def test_status(self):
-        self.execute('status')
-
-    def test_nice_get(self):
-        self.execute('nice')
-
-    def test_nice_set(self):
-        niceness = psutil.Process().nice()
-        self.execute('nice', niceness)
-
-    @unittest.skipUnless(hasattr(psutil.Process, 'ionice'),
-                         "Linux and Windows Vista only")
-    def test_ionice_get(self):
-        self.execute('ionice')
-
-    @unittest.skipUnless(hasattr(psutil.Process, 'ionice'),
-                         "Linux and Windows Vista only")
-    def test_ionice_set(self):
-        if WINDOWS:
-            value = psutil.Process().ionice()
-            self.execute('ionice', value)
-        else:
-            from psutil._pslinux import cext
-            self.execute('ionice', psutil.IOPRIO_CLASS_NONE)
-            fun = functools.partial(cext.proc_ioprio_set, os.getpid(), -1, 0)
-            self.execute_w_exc(OSError, fun)
-
-    @unittest.skipIf(OSX or SUNOS, "feature not supported on this platform")
-    @skip_if_linux()
-    def test_io_counters(self):
-        self.execute('io_counters')
-
-    @unittest.skipUnless(WINDOWS, "not worth being tested on posix")
-    def test_username(self):
-        self.execute('username')
-
-    @skip_if_linux()
-    def test_create_time(self):
-        self.execute('create_time')
-
-    @skip_if_linux()
-    def test_num_threads(self):
-        self.execute('num_threads')
-
-    @unittest.skipUnless(WINDOWS, "Windows only")
-    def test_num_handles(self):
-        self.execute('num_handles')
-
-    @unittest.skipUnless(POSIX, "POSIX only")
-    @skip_if_linux()
-    def test_num_fds(self):
-        self.execute('num_fds')
-
-    @skip_if_linux()
-    def test_threads(self):
-        self.execute('threads')
-
-    @skip_if_linux()
-    def test_cpu_times(self):
-        self.execute('cpu_times')
-
-    @skip_if_linux()
-    def test_memory_info(self):
-        self.execute('memory_info')
-
-    # also available on Linux but it's pure python
-    @unittest.skipUnless(OSX or WINDOWS,
-                         "not available on this platform")
-    def test_memory_full_info(self):
-        self.execute('memory_full_info')
-
-    @unittest.skipUnless(POSIX, "POSIX only")
-    @skip_if_linux()
-    def test_terminal(self):
-        self.execute('terminal')
-
-    @unittest.skipIf(POSIX and SKIP_PYTHON_IMPL,
-                     "not worth being tested on POSIX (pure python)")
-    def test_resume(self):
-        self.execute('resume')
-
-    @skip_if_linux()
-    def test_cwd(self):
-        self.execute('cwd')
-
-    @unittest.skipUnless(WINDOWS or LINUX or FREEBSD,
-                         "Windows or Linux or BSD only")
-    def test_cpu_affinity_get(self):
-        self.execute('cpu_affinity')
-
-    @unittest.skipUnless(WINDOWS or LINUX or FREEBSD,
-                         "Windows or Linux or BSD only")
-    def test_cpu_affinity_set(self):
-        affinity = psutil.Process().cpu_affinity()
-        self.execute('cpu_affinity', affinity)
-        if not TRAVIS:
-            self.execute_w_exc(ValueError, 'cpu_affinity', [-1])
-
-    @skip_if_linux()
-    def test_open_files(self):
-        safe_remove(TESTFN)  # needed after UNIX socket test has run
-        with open(TESTFN, 'w'):
-            self.execute('open_files')
-
-    # OSX implementation is unbelievably slow
-    @unittest.skipIf(OSX, "OSX implementation is too slow")
-    @unittest.skipIf(OPENBSD, "not implemented on OpenBSD")
-    @skip_if_linux()
-    def test_memory_maps(self):
-        self.execute('memory_maps')
-
-    @unittest.skipUnless(LINUX, "Linux only")
-    @unittest.skipUnless(LINUX and RLIMIT_SUPPORT,
-                         "only available on Linux >= 2.6.36")
-    def test_rlimit_get(self):
-        self.execute('rlimit', psutil.RLIMIT_NOFILE)
-
-    @unittest.skipUnless(LINUX, "Linux only")
-    @unittest.skipUnless(LINUX and RLIMIT_SUPPORT,
-                         "only available on Linux >= 2.6.36")
-    def test_rlimit_set(self):
-        limit = psutil.Process().rlimit(psutil.RLIMIT_NOFILE)
-        self.execute('rlimit', psutil.RLIMIT_NOFILE, limit)
-        self.execute_w_exc(OSError, 'rlimit', -1)
-
-    @skip_if_linux()
-    # Windows implementation is based on a single system-wide function
-    @unittest.skipIf(WINDOWS, "tested later")
-    def test_connections(self):
-        def create_socket(family, type):
-            sock = socket.socket(family, type)
-            sock.bind(('', 0))
-            if type == socket.SOCK_STREAM:
-                sock.listen(1)
-            return sock
-
-        socks = []
-        socks.append(create_socket(socket.AF_INET, socket.SOCK_STREAM))
-        socks.append(create_socket(socket.AF_INET, socket.SOCK_DGRAM))
-        if supports_ipv6():
-            socks.append(create_socket(socket.AF_INET6, socket.SOCK_STREAM))
-            socks.append(create_socket(socket.AF_INET6, socket.SOCK_DGRAM))
-        if hasattr(socket, 'AF_UNIX'):
-            safe_remove(TESTFN)
-            s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-            s.bind(TESTFN)
-            s.listen(1)
-            socks.append(s)
-        kind = 'all'
-        # TODO: UNIX sockets are temporarily implemented by parsing
-        # 'pfiles' cmd  output; we don't want that part of the code to
-        # be executed.
-        if SUNOS:
-            kind = 'inet'
-        try:
-            self.execute('connections', kind=kind)
-        finally:
-            for s in socks:
-                s.close()
-
-    @unittest.skipUnless(hasattr(psutil.Process, 'environ'),
-                         "Linux, OSX and Windows")
-    def test_environ(self):
-        self.execute("environ")
-
-
-p = get_test_subprocess()
-DEAD_PROC = psutil.Process(p.pid)
-DEAD_PROC.kill()
-DEAD_PROC.wait()
-del p
-
-
-class TestProcessObjectLeaksZombie(TestProcessObjectLeaks):
-    """Same as above but looks for leaks occurring when dealing with
-    zombie processes raising NoSuchProcess exception.
-    """
-    proc = DEAD_PROC
-
-    def call(self, *args, **kwargs):
-        try:
-            TestProcessObjectLeaks.call(self, *args, **kwargs)
-        except psutil.NoSuchProcess:
-            pass
-
-    if not POSIX:
-        def test_kill(self):
-            self.execute('kill')
-
-        def test_terminate(self):
-            self.execute('terminate')
-
-        def test_suspend(self):
-            self.execute('suspend')
-
-        def test_resume(self):
-            self.execute('resume')
-
-        def test_wait(self):
-            self.execute('wait')
-
-
-class TestModuleFunctionsLeaks(Base):
-    """Test leaks of psutil module functions."""
-
-    def setUp(self):
-        gc.collect()
-
-    def call(self, function, *args, **kwargs):
-        fun = function if callable(function) else getattr(psutil, function)
-        fun(*args, **kwargs)
-
-    @skip_if_linux()
-    def test_cpu_count_logical(self):
-        self.execute('cpu_count', logical=True)
-
-    @skip_if_linux()
-    def test_cpu_count_physical(self):
-        self.execute('cpu_count', logical=False)
-
-    @skip_if_linux()
-    def test_boot_time(self):
-        self.execute('boot_time')
-
-    @unittest.skipIf(POSIX and SKIP_PYTHON_IMPL,
-                     "not worth being tested on POSIX (pure python)")
-    def test_pid_exists(self):
-        self.execute('pid_exists', os.getpid())
-
-    def test_virtual_memory(self):
-        self.execute('virtual_memory')
-
-    # TODO: remove this skip when this gets fixed
-    @unittest.skipIf(SUNOS,
-                     "not worth being tested on SUNOS (uses a subprocess)")
-    def test_swap_memory(self):
-        self.execute('swap_memory')
-
-    @skip_if_linux()
-    def test_cpu_times(self):
-        self.execute('cpu_times')
-
-    @skip_if_linux()
-    def test_per_cpu_times(self):
-        self.execute('cpu_times', percpu=True)
-
-    @unittest.skipIf(POSIX and SKIP_PYTHON_IMPL,
-                     "not worth being tested on POSIX (pure python)")
-    def test_disk_usage(self):
-        self.execute('disk_usage', '.')
-
-    def test_disk_partitions(self):
-        self.execute('disk_partitions')
-
-    @skip_if_linux()
-    def test_net_io_counters(self):
-        self.execute('net_io_counters')
-
-    @unittest.skipIf(LINUX and not os.path.exists('/proc/diskstats'),
-                     '/proc/diskstats not available on this Linux version')
-    @skip_if_linux()
-    def test_disk_io_counters(self):
-        self.execute('disk_io_counters')
-
-    # XXX - on Windows this produces a false positive
-    @unittest.skipIf(WINDOWS, "XXX produces a false positive on Windows")
-    def test_users(self):
-        self.execute('users')
-
-    @unittest.skipIf(LINUX,
-                     "not worth being tested on Linux (pure python)")
-    @unittest.skipIf(OSX and os.getuid() != 0, "need root access")
-    def test_net_connections(self):
-        self.execute('net_connections')
-
-    def test_net_if_addrs(self):
-        self.execute('net_if_addrs')
-
-    @unittest.skipIf(TRAVIS, "EPERM on travis")
-    def test_net_if_stats(self):
-        self.execute('net_if_stats')
-
-    def test_cpu_stats(self):
-        self.execute('cpu_stats')
-
-    if WINDOWS:
-
-        def test_win_service_iter(self):
-            fun = psutil._psplatform.cext.winservice_enumerate
-            self.execute(fun)
-
-        def test_win_service_get_config(self):
-            name = next(psutil.win_service_iter()).name()
-            fun = psutil._psplatform.cext.winservice_query_config
-            self.execute(fun, name)
-
-        def test_win_service_get_status(self):
-            name = next(psutil.win_service_iter()).name()
-            fun = psutil._psplatform.cext.winservice_query_status
-            self.execute(fun, name)
-
-        def test_win_service_get_description(self):
-            name = next(psutil.win_service_iter()).name()
-            fun = psutil._psplatform.cext.winservice_query_descr
-            self.execute(fun, name)
-
-
-if __name__ == '__main__':
-    run_test_module_by_name(__file__)
diff --git a/psutil/tests/test_misc.py b/psutil/tests/test_misc.py
deleted file mode 100644
index 64908a773c..0000000000
--- a/psutil/tests/test_misc.py
+++ /dev/null
@@ -1,447 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-import ast
-import errno
-import imp
-import json
-import os
-import pickle
-import psutil
-import socket
-import stat
-import sys
-
-from psutil import LINUX
-from psutil import NETBSD
-from psutil import OPENBSD
-from psutil import OSX
-from psutil import POSIX
-from psutil import WINDOWS
-from psutil._common import supports_ipv6
-from psutil.tests import APPVEYOR
-from psutil.tests import SCRIPTS_DIR
-from psutil.tests import importlib
-from psutil.tests import mock
-from psutil.tests import ROOT_DIR
-from psutil.tests import run_test_module_by_name
-from psutil.tests import sh
-from psutil.tests import TOX
-from psutil.tests import TRAVIS
-from psutil.tests import unittest
-
-
-# ===================================================================
-# --- Misc tests
-# ===================================================================
-
-class TestMisc(unittest.TestCase):
-    """Misc / generic tests."""
-
-    def test_process__repr__(self, func=repr):
-        p = psutil.Process()
-        r = func(p)
-        self.assertIn("psutil.Process", r)
-        self.assertIn("pid=%s" % p.pid, r)
-        self.assertIn("name=", r)
-        self.assertIn(p.name(), r)
-        with mock.patch.object(psutil.Process, "name",
-                               side_effect=psutil.ZombieProcess(os.getpid())):
-            p = psutil.Process()
-            r = func(p)
-            self.assertIn("pid=%s" % p.pid, r)
-            self.assertIn("zombie", r)
-            self.assertNotIn("name=", r)
-        with mock.patch.object(psutil.Process, "name",
-                               side_effect=psutil.NoSuchProcess(os.getpid())):
-            p = psutil.Process()
-            r = func(p)
-            self.assertIn("pid=%s" % p.pid, r)
-            self.assertIn("terminated", r)
-            self.assertNotIn("name=", r)
-        with mock.patch.object(psutil.Process, "name",
-                               side_effect=psutil.AccessDenied(os.getpid())):
-            p = psutil.Process()
-            r = func(p)
-            self.assertIn("pid=%s" % p.pid, r)
-            self.assertNotIn("name=", r)
-
-    def test_process__str__(self):
-        self.test_process__repr__(func=str)
-
-    def test_no_such_process__repr__(self, func=repr):
-        self.assertEqual(
-            repr(psutil.NoSuchProcess(321)),
-            "psutil.NoSuchProcess process no longer exists (pid=321)")
-        self.assertEqual(
-            repr(psutil.NoSuchProcess(321, name='foo')),
-            "psutil.NoSuchProcess process no longer exists (pid=321, "
-            "name='foo')")
-        self.assertEqual(
-            repr(psutil.NoSuchProcess(321, msg='foo')),
-            "psutil.NoSuchProcess foo")
-
-    def test_zombie_process__repr__(self, func=repr):
-        self.assertEqual(
-            repr(psutil.ZombieProcess(321)),
-            "psutil.ZombieProcess process still exists but it's a zombie "
-            "(pid=321)")
-        self.assertEqual(
-            repr(psutil.ZombieProcess(321, name='foo')),
-            "psutil.ZombieProcess process still exists but it's a zombie "
-            "(pid=321, name='foo')")
-        self.assertEqual(
-            repr(psutil.ZombieProcess(321, name='foo', ppid=1)),
-            "psutil.ZombieProcess process still exists but it's a zombie "
-            "(pid=321, name='foo', ppid=1)")
-        self.assertEqual(
-            repr(psutil.ZombieProcess(321, msg='foo')),
-            "psutil.ZombieProcess foo")
-
-    def test_access_denied__repr__(self, func=repr):
-        self.assertEqual(
-            repr(psutil.AccessDenied(321)),
-            "psutil.AccessDenied (pid=321)")
-        self.assertEqual(
-            repr(psutil.AccessDenied(321, name='foo')),
-            "psutil.AccessDenied (pid=321, name='foo')")
-        self.assertEqual(
-            repr(psutil.AccessDenied(321, msg='foo')),
-            "psutil.AccessDenied foo")
-
-    def test_timeout_expired__repr__(self, func=repr):
-        self.assertEqual(
-            repr(psutil.TimeoutExpired(321)),
-            "psutil.TimeoutExpired timeout after 321 seconds")
-        self.assertEqual(
-            repr(psutil.TimeoutExpired(321, pid=111)),
-            "psutil.TimeoutExpired timeout after 321 seconds (pid=111)")
-        self.assertEqual(
-            repr(psutil.TimeoutExpired(321, pid=111, name='foo')),
-            "psutil.TimeoutExpired timeout after 321 seconds "
-            "(pid=111, name='foo')")
-
-    def test_process__eq__(self):
-        p1 = psutil.Process()
-        p2 = psutil.Process()
-        self.assertEqual(p1, p2)
-        p2._ident = (0, 0)
-        self.assertNotEqual(p1, p2)
-        self.assertNotEqual(p1, 'foo')
-
-    def test_process__hash__(self):
-        s = set([psutil.Process(), psutil.Process()])
-        self.assertEqual(len(s), 1)
-
-    def test__all__(self):
-        dir_psutil = dir(psutil)
-        for name in dir_psutil:
-            if name in ('callable', 'error', 'namedtuple', 'tests',
-                        'long', 'test', 'NUM_CPUS', 'BOOT_TIME',
-                        'TOTAL_PHYMEM'):
-                continue
-            if not name.startswith('_'):
-                try:
-                    __import__(name)
-                except ImportError:
-                    if name not in psutil.__all__:
-                        fun = getattr(psutil, name)
-                        if fun is None:
-                            continue
-                        if (fun.__doc__ is not None and
-                                'deprecated' not in fun.__doc__.lower()):
-                            self.fail('%r not in psutil.__all__' % name)
-
-        # Import 'star' will break if __all__ is inconsistent, see:
-        # https://github.com/giampaolo/psutil/issues/656
-        # Can't do `from psutil import *` as it won't work on python 3
-        # so we simply iterate over __all__.
-        for name in psutil.__all__:
-            self.assertIn(name, dir_psutil)
-
-    def test_version(self):
-        self.assertEqual('.'.join([str(x) for x in psutil.version_info]),
-                         psutil.__version__)
-
-    def test_process_as_dict_no_new_names(self):
-        # See https://github.com/giampaolo/psutil/issues/813
-        p = psutil.Process()
-        p.foo = '1'
-        self.assertNotIn('foo', p.as_dict())
-
-    def test_memoize(self):
-        from psutil._common import memoize
-
-        @memoize
-        def foo(*args, **kwargs):
-            "foo docstring"
-            calls.append(None)
-            return (args, kwargs)
-
-        calls = []
-        # no args
-        for x in range(2):
-            ret = foo()
-            expected = ((), {})
-            self.assertEqual(ret, expected)
-            self.assertEqual(len(calls), 1)
-        # with args
-        for x in range(2):
-            ret = foo(1)
-            expected = ((1, ), {})
-            self.assertEqual(ret, expected)
-            self.assertEqual(len(calls), 2)
-        # with args + kwargs
-        for x in range(2):
-            ret = foo(1, bar=2)
-            expected = ((1, ), {'bar': 2})
-            self.assertEqual(ret, expected)
-            self.assertEqual(len(calls), 3)
-        # clear cache
-        foo.cache_clear()
-        ret = foo()
-        expected = ((), {})
-        self.assertEqual(ret, expected)
-        self.assertEqual(len(calls), 4)
-        # docstring
-        self.assertEqual(foo.__doc__, "foo docstring")
-
-    def test_parse_environ_block(self):
-        from psutil._common import parse_environ_block
-
-        def k(s):
-            return s.upper() if WINDOWS else s
-
-        self.assertEqual(parse_environ_block("a=1\0"),
-                         {k("a"): "1"})
-        self.assertEqual(parse_environ_block("a=1\0b=2\0\0"),
-                         {k("a"): "1", k("b"): "2"})
-        self.assertEqual(parse_environ_block("a=1\0b=\0\0"),
-                         {k("a"): "1", k("b"): ""})
-        # ignore everything after \0\0
-        self.assertEqual(parse_environ_block("a=1\0b=2\0\0c=3\0"),
-                         {k("a"): "1", k("b"): "2"})
-        # ignore everything that is not an assignment
-        self.assertEqual(parse_environ_block("xxx\0a=1\0"), {k("a"): "1"})
-        self.assertEqual(parse_environ_block("a=1\0=b=2\0"), {k("a"): "1"})
-        # do not fail if the block is incomplete
-        self.assertEqual(parse_environ_block("a=1\0b=2"), {k("a"): "1"})
-
-    def test_supports_ipv6(self):
-        if supports_ipv6():
-            with mock.patch('psutil._common.socket') as s:
-                s.has_ipv6 = False
-                assert not supports_ipv6()
-            with mock.patch('psutil._common.socket.socket',
-                            side_effect=socket.error) as s:
-                assert not supports_ipv6()
-                assert s.called
-            with mock.patch('psutil._common.socket.socket',
-                            side_effect=socket.gaierror) as s:
-                assert not supports_ipv6()
-                assert s.called
-            with mock.patch('psutil._common.socket.socket.bind',
-                            side_effect=socket.gaierror) as s:
-                assert not supports_ipv6()
-                assert s.called
-        else:
-            if hasattr(socket, 'AF_INET6'):
-                with self.assertRaises(Exception):
-                    sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
-                    sock.bind(("::1", 0))
-
-    def test_isfile_strict(self):
-        from psutil._common import isfile_strict
-        this_file = os.path.abspath(__file__)
-        assert isfile_strict(this_file)
-        assert not isfile_strict(os.path.dirname(this_file))
-        with mock.patch('psutil._common.os.stat',
-                        side_effect=OSError(errno.EPERM, "foo")):
-            self.assertRaises(OSError, isfile_strict, this_file)
-        with mock.patch('psutil._common.os.stat',
-                        side_effect=OSError(errno.EACCES, "foo")):
-            self.assertRaises(OSError, isfile_strict, this_file)
-        with mock.patch('psutil._common.os.stat',
-                        side_effect=OSError(errno.EINVAL, "foo")):
-            assert not isfile_strict(this_file)
-        with mock.patch('psutil._common.stat.S_ISREG', return_value=False):
-            assert not isfile_strict(this_file)
-
-    def test_serialization(self):
-        def check(ret):
-            if json is not None:
-                json.loads(json.dumps(ret))
-            a = pickle.dumps(ret)
-            b = pickle.loads(a)
-            self.assertEqual(ret, b)
-
-        check(psutil.Process().as_dict())
-        check(psutil.virtual_memory())
-        check(psutil.swap_memory())
-        check(psutil.cpu_times())
-        check(psutil.cpu_times_percent(interval=0))
-        check(psutil.net_io_counters())
-        if LINUX and not os.path.exists('/proc/diskstats'):
-            pass
-        else:
-            if not APPVEYOR:
-                check(psutil.disk_io_counters())
-        check(psutil.disk_partitions())
-        check(psutil.disk_usage(os.getcwd()))
-        check(psutil.users())
-
-    def test_setup_script(self):
-        setup_py = os.path.join(ROOT_DIR, 'setup.py')
-        module = imp.load_source('setup', setup_py)
-        self.assertRaises(SystemExit, module.setup)
-        self.assertEqual(module.get_version(), psutil.__version__)
-
-    def test_ad_on_process_creation(self):
-        # We are supposed to be able to instantiate Process also in case
-        # of zombie processes or access denied.
-        with mock.patch.object(psutil.Process, 'create_time',
-                               side_effect=psutil.AccessDenied) as meth:
-            psutil.Process()
-            assert meth.called
-        with mock.patch.object(psutil.Process, 'create_time',
-                               side_effect=psutil.ZombieProcess(1)) as meth:
-            psutil.Process()
-            assert meth.called
-        with mock.patch.object(psutil.Process, 'create_time',
-                               side_effect=ValueError) as meth:
-            with self.assertRaises(ValueError):
-                psutil.Process()
-            assert meth.called
-
-    def test_psutil_is_reloadable(self):
-        importlib.reload(psutil)
-
-    def test_sanity_version_check(self):
-        # see: https://github.com/giampaolo/psutil/issues/564
-        try:
-            with mock.patch(
-                    "psutil._psplatform.cext.version", return_value="0.0.0"):
-                with self.assertRaises(ImportError) as cm:
-                    importlib.reload(psutil)
-                self.assertIn("version conflict", str(cm.exception).lower())
-        finally:
-            importlib.reload(psutil)
-
-
-# ===================================================================
-# --- Example script tests
-# ===================================================================
-
-@unittest.skipIf(TOX, "can't test on tox")
-class TestScripts(unittest.TestCase):
-    """Tests for scripts in the "scripts" directory."""
-
-    def assert_stdout(self, exe, args=None):
-        exe = os.path.join(SCRIPTS_DIR, exe)
-        if args:
-            exe = exe + ' ' + args
-        try:
-            out = sh(sys.executable + ' ' + exe).strip()
-        except RuntimeError as err:
-            if 'AccessDenied' in str(err):
-                return str(err)
-            else:
-                raise
-        assert out, out
-        return out
-
-    def assert_syntax(self, exe, args=None):
-        exe = os.path.join(SCRIPTS_DIR, exe)
-        with open(exe, 'r') as f:
-            src = f.read()
-        ast.parse(src)
-
-    def test_check_presence(self):
-        # make sure all example scripts have a test method defined
-        meths = dir(self)
-        for name in os.listdir(SCRIPTS_DIR):
-            if name.endswith('.py'):
-                if 'test_' + os.path.splitext(name)[0] not in meths:
-                    # self.assert_stdout(name)
-                    self.fail('no test defined for %r script'
-                              % os.path.join(SCRIPTS_DIR, name))
-
-    @unittest.skipUnless(POSIX, "UNIX only")
-    def test_executable(self):
-        for name in os.listdir(SCRIPTS_DIR):
-            if name.endswith('.py'):
-                path = os.path.join(SCRIPTS_DIR, name)
-                if not stat.S_IXUSR & os.stat(path)[stat.ST_MODE]:
-                    self.fail('%r is not executable' % path)
-
-    def test_disk_usage(self):
-        self.assert_stdout('disk_usage.py')
-
-    def test_free(self):
-        self.assert_stdout('free.py')
-
-    def test_meminfo(self):
-        self.assert_stdout('meminfo.py')
-
-    def test_procinfo(self):
-        self.assert_stdout('procinfo.py')
-
-    @unittest.skipIf(APPVEYOR, "can't find users on Appveyor")
-    def test_who(self):
-        self.assert_stdout('who.py')
-
-    def test_ps(self):
-        self.assert_stdout('ps.py')
-
-    def test_pstree(self):
-        self.assert_stdout('pstree.py')
-
-    def test_netstat(self):
-        self.assert_stdout('netstat.py')
-
-    @unittest.skipIf(TRAVIS, "permission denied on travis")
-    def test_ifconfig(self):
-        self.assert_stdout('ifconfig.py')
-
-    @unittest.skipIf(OPENBSD or NETBSD, "memory maps not supported")
-    def test_pmap(self):
-        self.assert_stdout('pmap.py', args=str(os.getpid()))
-
-    @unittest.skipUnless(OSX or WINDOWS or LINUX, "uss not available")
-    def test_procsmem(self):
-        self.assert_stdout('procsmem.py')
-
-    @unittest.skipIf(ast is None,
-                     'ast module not available on this python version')
-    def test_killall(self):
-        self.assert_syntax('killall.py')
-
-    @unittest.skipIf(ast is None,
-                     'ast module not available on this python version')
-    def test_nettop(self):
-        self.assert_syntax('nettop.py')
-
-    @unittest.skipIf(ast is None,
-                     'ast module not available on this python version')
-    def test_top(self):
-        self.assert_syntax('top.py')
-
-    @unittest.skipIf(ast is None,
-                     'ast module not available on this python version')
-    def test_iotop(self):
-        self.assert_syntax('iotop.py')
-
-    def test_pidof(self):
-        output = self.assert_stdout('pidof.py %s' % psutil.Process().name())
-        self.assertIn(str(os.getpid()), output)
-
-    @unittest.skipUnless(WINDOWS, "Windows only")
-    def test_winservices(self):
-        self.assert_stdout('winservices.py')
-
-
-if __name__ == '__main__':
-    run_test_module_by_name(__file__)
diff --git a/psutil/tests/test_osx.py b/psutil/tests/test_osx.py
deleted file mode 100644
index 3f3082979b..0000000000
--- a/psutil/tests/test_osx.py
+++ /dev/null
@@ -1,199 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""OSX specific tests."""
-
-import os
-import re
-import subprocess
-import sys
-import time
-
-import psutil
-from psutil import OSX
-from psutil._compat import PY3
-from psutil.tests import get_test_subprocess
-from psutil.tests import MEMORY_TOLERANCE
-from psutil.tests import reap_children
-from psutil.tests import retry_before_failing
-from psutil.tests import run_test_module_by_name
-from psutil.tests import sh
-from psutil.tests import TRAVIS
-from psutil.tests import unittest
-
-
-PAGESIZE = os.sysconf("SC_PAGE_SIZE") if OSX else None
-
-
-def sysctl(cmdline):
-    """Expects a sysctl command with an argument and parse the result
-    returning only the value of interest.
-    """
-    p = subprocess.Popen(cmdline, shell=1, stdout=subprocess.PIPE)
-    result = p.communicate()[0].strip().split()[1]
-    if PY3:
-        result = str(result, sys.stdout.encoding)
-    try:
-        return int(result)
-    except ValueError:
-        return result
-
-
-def vm_stat(field):
-    """Wrapper around 'vm_stat' cmdline utility."""
-    out = sh('vm_stat')
-    for line in out.split('\n'):
-        if field in line:
-            break
-    else:
-        raise ValueError("line not found")
-    return int(re.search('\d+', line).group(0)) * PAGESIZE
-
-
-# http://code.activestate.com/recipes/578019/
-def human2bytes(s):
-    SYMBOLS = {
-        'customary': ('B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'),
-    }
-    init = s
-    num = ""
-    while s and s[0:1].isdigit() or s[0:1] == '.':
-        num += s[0]
-        s = s[1:]
-    num = float(num)
-    letter = s.strip()
-    for name, sset in SYMBOLS.items():
-        if letter in sset:
-            break
-    else:
-        if letter == 'k':
-            sset = SYMBOLS['customary']
-            letter = letter.upper()
-        else:
-            raise ValueError("can't interpret %r" % init)
-    prefix = {sset[0]: 1}
-    for i, s in enumerate(sset[1:]):
-        prefix[s] = 1 << (i + 1) * 10
-    return int(num * prefix[letter])
-
-
-@unittest.skipUnless(OSX, "not an OSX system")
-class TestProcess(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        cls.pid = get_test_subprocess().pid
-
-    @classmethod
-    def tearDownClass(cls):
-        reap_children()
-
-    def test_process_create_time(self):
-        cmdline = "ps -o lstart -p %s" % self.pid
-        p = subprocess.Popen(cmdline, shell=1, stdout=subprocess.PIPE)
-        output = p.communicate()[0]
-        if PY3:
-            output = str(output, sys.stdout.encoding)
-        start_ps = output.replace('STARTED', '').strip()
-        start_psutil = psutil.Process(self.pid).create_time()
-        start_psutil = time.strftime("%a %b %e %H:%M:%S %Y",
-                                     time.localtime(start_psutil))
-        self.assertEqual(start_ps, start_psutil)
-
-
-@unittest.skipUnless(OSX, "not an OSX system")
-class TestSystemAPIs(unittest.TestCase):
-
-    def test_disks(self):
-        # test psutil.disk_usage() and psutil.disk_partitions()
-        # against "df -a"
-        def df(path):
-            out = sh('df -k "%s"' % path).strip()
-            lines = out.split('\n')
-            lines.pop(0)
-            line = lines.pop(0)
-            dev, total, used, free = line.split()[:4]
-            if dev == 'none':
-                dev = ''
-            total = int(total) * 1024
-            used = int(used) * 1024
-            free = int(free) * 1024
-            return dev, total, used, free
-
-        for part in psutil.disk_partitions(all=False):
-            usage = psutil.disk_usage(part.mountpoint)
-            dev, total, used, free = df(part.mountpoint)
-            self.assertEqual(part.device, dev)
-            self.assertEqual(usage.total, total)
-            # 10 MB tollerance
-            if abs(usage.free - free) > 10 * 1024 * 1024:
-                self.fail("psutil=%s, df=%s" % usage.free, free)
-            if abs(usage.used - used) > 10 * 1024 * 1024:
-                self.fail("psutil=%s, df=%s" % usage.used, used)
-
-    def test_cpu_count_logical(self):
-        num = sysctl("sysctl hw.logicalcpu")
-        self.assertEqual(num, psutil.cpu_count(logical=True))
-
-    def test_cpu_count_physical(self):
-        num = sysctl("sysctl hw.physicalcpu")
-        self.assertEqual(num, psutil.cpu_count(logical=False))
-
-    # --- virtual mem
-
-    def test_vmem_total(self):
-        sysctl_hwphymem = sysctl('sysctl hw.memsize')
-        self.assertEqual(sysctl_hwphymem, psutil.virtual_memory().total)
-
-    @unittest.skipIf(TRAVIS, "")
-    @retry_before_failing()
-    def test_vmem_free(self):
-        num = vm_stat("free")
-        self.assertAlmostEqual(psutil.virtual_memory().free, num,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_vmem_active(self):
-        num = vm_stat("active")
-        self.assertAlmostEqual(psutil.virtual_memory().active, num,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_vmem_inactive(self):
-        num = vm_stat("inactive")
-        self.assertAlmostEqual(psutil.virtual_memory().inactive, num,
-                               delta=MEMORY_TOLERANCE)
-
-    @retry_before_failing()
-    def test_vmem_wired(self):
-        num = vm_stat("wired")
-        self.assertAlmostEqual(psutil.virtual_memory().wired, num,
-                               delta=MEMORY_TOLERANCE)
-
-    # --- swap mem
-
-    @retry_before_failing()
-    def test_swapmem_sin(self):
-        num = vm_stat("Pageins")
-        self.assertEqual(psutil.swap_memory().sin, num)
-
-    @retry_before_failing()
-    def test_swapmem_sout(self):
-        num = vm_stat("Pageouts")
-        self.assertEqual(psutil.swap_memory().sout, num)
-
-    def test_swapmem_total(self):
-        out = sh('sysctl vm.swapusage')
-        out = out.replace('vm.swapusage: ', '')
-        total, used, free = re.findall('\d+.\d+\w', out)
-        psutil_smem = psutil.swap_memory()
-        self.assertEqual(psutil_smem.total, human2bytes(total))
-        self.assertEqual(psutil_smem.used, human2bytes(used))
-        self.assertEqual(psutil_smem.free, human2bytes(free))
-
-
-if __name__ == '__main__':
-    run_test_module_by_name(__file__)
diff --git a/psutil/tests/test_posix.py b/psutil/tests/test_posix.py
deleted file mode 100644
index 2645f70a8d..0000000000
--- a/psutil/tests/test_posix.py
+++ /dev/null
@@ -1,348 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""POSIX specific tests."""
-
-import datetime
-import errno
-import os
-import subprocess
-import sys
-import time
-
-import psutil
-from psutil import BSD
-from psutil import LINUX
-from psutil import OSX
-from psutil import POSIX
-from psutil import SUNOS
-from psutil._compat import callable
-from psutil._compat import PY3
-from psutil.tests import get_kernel_version
-from psutil.tests import get_test_subprocess
-from psutil.tests import mock
-from psutil.tests import PYTHON
-from psutil.tests import reap_children
-from psutil.tests import retry_before_failing
-from psutil.tests import run_test_module_by_name
-from psutil.tests import sh
-from psutil.tests import skip_on_access_denied
-from psutil.tests import TRAVIS
-from psutil.tests import unittest
-from psutil.tests import wait_for_pid
-
-
-def ps(cmd):
-    """Expects a ps command with a -o argument and parse the result
-    returning only the value of interest.
-    """
-    if not LINUX:
-        cmd = cmd.replace(" --no-headers ", " ")
-    if SUNOS:
-        cmd = cmd.replace("-o command", "-o comm")
-        cmd = cmd.replace("-o start", "-o stime")
-    p = subprocess.Popen(cmd, shell=1, stdout=subprocess.PIPE)
-    output = p.communicate()[0].strip()
-    if PY3:
-        output = str(output, sys.stdout.encoding)
-    if not LINUX:
-        output = output.split('\n')[1].strip()
-    try:
-        return int(output)
-    except ValueError:
-        return output
-
-
-@unittest.skipUnless(POSIX, "not a POSIX system")
-class TestProcess(unittest.TestCase):
-    """Compare psutil results against 'ps' command line utility (mainly)."""
-
-    @classmethod
-    def setUpClass(cls):
-        cls.pid = get_test_subprocess([PYTHON, "-E", "-O"],
-                                      stdin=subprocess.PIPE).pid
-        wait_for_pid(cls.pid)
-
-    @classmethod
-    def tearDownClass(cls):
-        reap_children()
-
-    # for ps -o arguments see: http://unixhelp.ed.ac.uk/CGI/man-cgi?ps
-
-    def test_ppid(self):
-        ppid_ps = ps("ps --no-headers -o ppid -p %s" % self.pid)
-        ppid_psutil = psutil.Process(self.pid).ppid()
-        self.assertEqual(ppid_ps, ppid_psutil)
-
-    def test_uid(self):
-        uid_ps = ps("ps --no-headers -o uid -p %s" % self.pid)
-        uid_psutil = psutil.Process(self.pid).uids().real
-        self.assertEqual(uid_ps, uid_psutil)
-
-    def test_gid(self):
-        gid_ps = ps("ps --no-headers -o rgid -p %s" % self.pid)
-        gid_psutil = psutil.Process(self.pid).gids().real
-        self.assertEqual(gid_ps, gid_psutil)
-
-    def test_username(self):
-        username_ps = ps("ps --no-headers -o user -p %s" % self.pid)
-        username_psutil = psutil.Process(self.pid).username()
-        self.assertEqual(username_ps, username_psutil)
-
-    @skip_on_access_denied()
-    @retry_before_failing()
-    def test_rss_memory(self):
-        # give python interpreter some time to properly initialize
-        # so that the results are the same
-        time.sleep(0.1)
-        rss_ps = ps("ps --no-headers -o rss -p %s" % self.pid)
-        rss_psutil = psutil.Process(self.pid).memory_info()[0] / 1024
-        self.assertEqual(rss_ps, rss_psutil)
-
-    @skip_on_access_denied()
-    @retry_before_failing()
-    def test_vsz_memory(self):
-        # give python interpreter some time to properly initialize
-        # so that the results are the same
-        time.sleep(0.1)
-        vsz_ps = ps("ps --no-headers -o vsz -p %s" % self.pid)
-        vsz_psutil = psutil.Process(self.pid).memory_info()[1] / 1024
-        self.assertEqual(vsz_ps, vsz_psutil)
-
-    def test_name(self):
-        # use command + arg since "comm" keyword not supported on all platforms
-        name_ps = ps("ps --no-headers -o command -p %s" % (
-            self.pid)).split(' ')[0]
-        # remove path if there is any, from the command
-        name_ps = os.path.basename(name_ps).lower()
-        name_psutil = psutil.Process(self.pid).name().lower()
-        self.assertEqual(name_ps, name_psutil)
-
-    @unittest.skipIf(OSX or BSD,
-                     'ps -o start not available')
-    def test_create_time(self):
-        time_ps = ps("ps --no-headers -o start -p %s" % self.pid).split(' ')[0]
-        time_psutil = psutil.Process(self.pid).create_time()
-        time_psutil_tstamp = datetime.datetime.fromtimestamp(
-            time_psutil).strftime("%H:%M:%S")
-        # sometimes ps shows the time rounded up instead of down, so we check
-        # for both possible values
-        round_time_psutil = round(time_psutil)
-        round_time_psutil_tstamp = datetime.datetime.fromtimestamp(
-            round_time_psutil).strftime("%H:%M:%S")
-        self.assertIn(time_ps, [time_psutil_tstamp, round_time_psutil_tstamp])
-
-    def test_exe(self):
-        ps_pathname = ps("ps --no-headers -o command -p %s" %
-                         self.pid).split(' ')[0]
-        psutil_pathname = psutil.Process(self.pid).exe()
-        try:
-            self.assertEqual(ps_pathname, psutil_pathname)
-        except AssertionError:
-            # certain platforms such as BSD are more accurate returning:
-            # "/usr/local/bin/python2.7"
-            # ...instead of:
-            # "/usr/local/bin/python"
-            # We do not want to consider this difference in accuracy
-            # an error.
-            adjusted_ps_pathname = ps_pathname[:len(ps_pathname)]
-            self.assertEqual(ps_pathname, adjusted_ps_pathname)
-
-    def test_cmdline(self):
-        ps_cmdline = ps("ps --no-headers -o command -p %s" % self.pid)
-        psutil_cmdline = " ".join(psutil.Process(self.pid).cmdline())
-        if SUNOS:
-            # ps on Solaris only shows the first part of the cmdline
-            psutil_cmdline = psutil_cmdline.split(" ")[0]
-        self.assertEqual(ps_cmdline, psutil_cmdline)
-
-    def test_nice(self):
-        ps_nice = ps("ps --no-headers -o nice -p %s" % self.pid)
-        psutil_nice = psutil.Process().nice()
-        self.assertEqual(ps_nice, psutil_nice)
-
-    def test_num_fds(self):
-        # Note: this fails from time to time; I'm keen on thinking
-        # it doesn't mean something is broken
-        def call(p, attr):
-            args = ()
-            attr = getattr(p, name, None)
-            if attr is not None and callable(attr):
-                if name == 'rlimit':
-                    args = (psutil.RLIMIT_NOFILE,)
-                attr(*args)
-            else:
-                attr
-
-        p = psutil.Process(os.getpid())
-        failures = []
-        ignored_names = ['terminate', 'kill', 'suspend', 'resume', 'nice',
-                         'send_signal', 'wait', 'children', 'as_dict']
-        if LINUX and get_kernel_version() < (2, 6, 36):
-            ignored_names.append('rlimit')
-        if LINUX and get_kernel_version() < (2, 6, 23):
-            ignored_names.append('num_ctx_switches')
-        for name in dir(psutil.Process):
-            if (name.startswith('_') or name in ignored_names):
-                continue
-            else:
-                try:
-                    num1 = p.num_fds()
-                    for x in range(2):
-                        call(p, name)
-                    num2 = p.num_fds()
-                except psutil.AccessDenied:
-                    pass
-                else:
-                    if abs(num2 - num1) > 1:
-                        fail = "failure while processing Process.%s method " \
-                               "(before=%s, after=%s)" % (name, num1, num2)
-                        failures.append(fail)
-        if failures:
-            self.fail('\n' + '\n'.join(failures))
-
-    @unittest.skipUnless(os.path.islink("/proc/%s/cwd" % os.getpid()),
-                         "/proc fs not available")
-    def test_cwd(self):
-        self.assertEqual(os.readlink("/proc/%s/cwd" % os.getpid()),
-                         psutil.Process().cwd())
-
-
-@unittest.skipUnless(POSIX, "not a POSIX system")
-class TestSystemAPIs(unittest.TestCase):
-    """Test some system APIs."""
-
-    @retry_before_failing()
-    def test_pids(self):
-        # Note: this test might fail if the OS is starting/killing
-        # other processes in the meantime
-        if SUNOS:
-            cmd = ["ps", "-A", "-o", "pid"]
-        else:
-            cmd = ["ps", "ax", "-o", "pid"]
-        p = get_test_subprocess(cmd, stdout=subprocess.PIPE)
-        output = p.communicate()[0].strip()
-        assert p.poll() == 0
-        if PY3:
-            output = str(output, sys.stdout.encoding)
-        pids_ps = []
-        for line in output.split('\n')[1:]:
-            if line:
-                pid = int(line.split()[0].strip())
-                pids_ps.append(pid)
-        # remove ps subprocess pid which is supposed to be dead in meantime
-        pids_ps.remove(p.pid)
-        pids_psutil = psutil.pids()
-        pids_ps.sort()
-        pids_psutil.sort()
-
-        # on OSX ps doesn't show pid 0
-        if OSX and 0 not in pids_ps:
-            pids_ps.insert(0, 0)
-
-        if pids_ps != pids_psutil:
-            difference = [x for x in pids_psutil if x not in pids_ps] + \
-                         [x for x in pids_ps if x not in pids_psutil]
-            self.fail("difference: " + str(difference))
-
-    # for some reason ifconfig -a does not report all interfaces
-    # returned by psutil
-    @unittest.skipIf(SUNOS, "test not reliable on SUNOS")
-    @unittest.skipIf(TRAVIS, "test not reliable on Travis")
-    def test_nic_names(self):
-        p = subprocess.Popen("ifconfig -a", shell=1, stdout=subprocess.PIPE)
-        output = p.communicate()[0].strip()
-        if PY3:
-            output = str(output, sys.stdout.encoding)
-        for nic in psutil.net_io_counters(pernic=True).keys():
-            for line in output.split():
-                if line.startswith(nic):
-                    break
-            else:
-                self.fail(
-                    "couldn't find %s nic in 'ifconfig -a' output\n%s" % (
-                        nic, output))
-
-    @retry_before_failing()
-    def test_users(self):
-        out = sh("who")
-        lines = out.split('\n')
-        users = [x.split()[0] for x in lines]
-        self.assertEqual(len(users), len(psutil.users()))
-        terminals = [x.split()[1] for x in lines]
-        for u in psutil.users():
-            self.assertTrue(u.name in users, u.name)
-            self.assertTrue(u.terminal in terminals, u.terminal)
-
-    def test_pid_exists_let_raise(self):
-        # According to "man 2 kill" possible error values for kill
-        # are (EINVAL, EPERM, ESRCH). Test that any other errno
-        # results in an exception.
-        with mock.patch("psutil._psposix.os.kill",
-                        side_effect=OSError(errno.EBADF, "")) as m:
-            self.assertRaises(OSError, psutil._psposix.pid_exists, os.getpid())
-            assert m.called
-
-    def test_os_waitpid_let_raise(self):
-        # os.waitpid() is supposed to catch EINTR and ECHILD only.
-        # Test that any other errno results in an exception.
-        with mock.patch("psutil._psposix.os.waitpid",
-                        side_effect=OSError(errno.EBADF, "")) as m:
-            self.assertRaises(OSError, psutil._psposix.wait_pid, os.getpid())
-            assert m.called
-
-    def test_os_waitpid_eintr(self):
-        # os.waitpid() is supposed to "retry" on EINTR.
-        with mock.patch("psutil._psposix.os.waitpid",
-                        side_effect=OSError(errno.EINTR, "")) as m:
-            self.assertRaises(
-                psutil._psposix.TimeoutExpired,
-                psutil._psposix.wait_pid, os.getpid(), timeout=0.01)
-            assert m.called
-
-    def test_os_waitpid_bad_ret_status(self):
-        # Simulate os.waitpid() returning a bad status.
-        with mock.patch("psutil._psposix.os.waitpid",
-                        return_value=(1, -1)) as m:
-            self.assertRaises(ValueError,
-                              psutil._psposix.wait_pid, os.getpid())
-            assert m.called
-
-    def test_disk_usage(self):
-        def df(device):
-            out = sh("df -k %s" % device).strip()
-            line = out.split('\n')[1]
-            fields = line.split()
-            total = int(fields[1]) * 1024
-            used = int(fields[2]) * 1024
-            free = int(fields[3]) * 1024
-            percent = float(fields[4].replace('%', ''))
-            return (total, used, free, percent)
-
-        tolerance = 4 * 1024 * 1024  # 4MB
-        for part in psutil.disk_partitions(all=False):
-            usage = psutil.disk_usage(part.mountpoint)
-            try:
-                total, used, free, percent = df(part.device)
-            except RuntimeError as err:
-                # see:
-                # https://travis-ci.org/giampaolo/psutil/jobs/138338464
-                # https://travis-ci.org/giampaolo/psutil/jobs/138343361
-                if "no such file or directory" in str(err).lower() or \
-                        "raw devices not supported" in str(err).lower():
-                    continue
-                else:
-                    raise
-            else:
-                self.assertAlmostEqual(usage.total, total, delta=tolerance)
-                self.assertAlmostEqual(usage.used, used, delta=tolerance)
-                self.assertAlmostEqual(usage.free, free, delta=tolerance)
-                self.assertAlmostEqual(usage.percent, percent, delta=1)
-
-
-if __name__ == '__main__':
-    run_test_module_by_name(__file__)
diff --git a/psutil/tests/test_process.py b/psutil/tests/test_process.py
deleted file mode 100644
index f2d58cee4f..0000000000
--- a/psutil/tests/test_process.py
+++ /dev/null
@@ -1,2070 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Tests for psutil.Process class."""
-
-import collections
-import contextlib
-import errno
-import os
-import select
-import shutil
-import signal
-import socket
-import stat
-import subprocess
-import sys
-import tempfile
-import textwrap
-import time
-import traceback
-import types
-from socket import AF_INET
-from socket import SOCK_DGRAM
-from socket import SOCK_STREAM
-try:
-    import ipaddress  # python >= 3.3
-except ImportError:
-    ipaddress = None
-
-import psutil
-
-from psutil import BSD
-from psutil import FREEBSD
-from psutil import LINUX
-from psutil import NETBSD
-from psutil import OPENBSD
-from psutil import OSX
-from psutil import POSIX
-from psutil import SUNOS
-from psutil import WINDOWS
-from psutil._common import supports_ipv6
-from psutil._compat import callable
-from psutil._compat import long
-from psutil._compat import PY3
-from psutil._compat import unicode
-from psutil.tests import AF_INET6
-from psutil.tests import AF_UNIX
-from psutil.tests import APPVEYOR
-from psutil.tests import call_until
-from psutil.tests import chdir
-from psutil.tests import check_connection_ntuple
-from psutil.tests import create_temp_executable_file
-from psutil.tests import decode_path
-from psutil.tests import encode_path
-from psutil.tests import enum
-from psutil.tests import get_test_subprocess
-from psutil.tests import get_winver
-from psutil.tests import GLOBAL_TIMEOUT
-from psutil.tests import mock
-from psutil.tests import PYPY
-from psutil.tests import pyrun
-from psutil.tests import PYTHON
-from psutil.tests import reap_children
-from psutil.tests import retry_before_failing
-from psutil.tests import RLIMIT_SUPPORT
-from psutil.tests import run_test_module_by_name
-from psutil.tests import safe_remove
-from psutil.tests import safe_rmdir
-from psutil.tests import sh
-from psutil.tests import skip_on_access_denied
-from psutil.tests import skip_on_not_implemented
-from psutil.tests import TESTFILE_PREFIX
-from psutil.tests import TESTFN
-from psutil.tests import ThreadTask
-from psutil.tests import TOX
-from psutil.tests import TRAVIS
-from psutil.tests import unittest
-from psutil.tests import VALID_PROC_STATUSES
-from psutil.tests import wait_for_file
-from psutil.tests import wait_for_pid
-from psutil.tests import warn
-from psutil.tests import which
-from psutil.tests import WIN_VISTA
-
-
-# ===================================================================
-# --- psutil.Process class tests
-# ===================================================================
-
-class TestProcess(unittest.TestCase):
-    """Tests for psutil.Process class."""
-
-    def setUp(self):
-        safe_remove(TESTFN)
-
-    def tearDown(self):
-        reap_children()
-
-    def test_pid(self):
-        self.assertEqual(psutil.Process().pid, os.getpid())
-        sproc = get_test_subprocess()
-        self.assertEqual(psutil.Process(sproc.pid).pid, sproc.pid)
-
-    def test_kill(self):
-        sproc = get_test_subprocess(wait=True)
-        test_pid = sproc.pid
-        p = psutil.Process(test_pid)
-        p.kill()
-        sig = p.wait()
-        self.assertFalse(psutil.pid_exists(test_pid))
-        if POSIX:
-            self.assertEqual(sig, signal.SIGKILL)
-
-    def test_terminate(self):
-        sproc = get_test_subprocess(wait=True)
-        test_pid = sproc.pid
-        p = psutil.Process(test_pid)
-        p.terminate()
-        sig = p.wait()
-        self.assertFalse(psutil.pid_exists(test_pid))
-        if POSIX:
-            self.assertEqual(sig, signal.SIGTERM)
-
-    def test_send_signal(self):
-        sig = signal.SIGKILL if POSIX else signal.SIGTERM
-        sproc = get_test_subprocess()
-        p = psutil.Process(sproc.pid)
-        p.send_signal(sig)
-        exit_sig = p.wait()
-        self.assertFalse(psutil.pid_exists(p.pid))
-        if POSIX:
-            self.assertEqual(exit_sig, sig)
-            #
-            sproc = get_test_subprocess()
-            p = psutil.Process(sproc.pid)
-            p.send_signal(sig)
-            with mock.patch('psutil.os.kill',
-                            side_effect=OSError(errno.ESRCH, "")) as fun:
-                with self.assertRaises(psutil.NoSuchProcess):
-                    p.send_signal(sig)
-                assert fun.called
-            #
-            sproc = get_test_subprocess()
-            p = psutil.Process(sproc.pid)
-            p.send_signal(sig)
-            with mock.patch('psutil.os.kill',
-                            side_effect=OSError(errno.EPERM, "")) as fun:
-                with self.assertRaises(psutil.AccessDenied):
-                    psutil.Process().send_signal(sig)
-                assert fun.called
-            # Sending a signal to process with PID 0 is not allowed as
-            # it would affect every process in the process group of
-            # the calling process (os.getpid()) instead of PID 0").
-            if 0 in psutil.pids():
-                p = psutil.Process(0)
-                self.assertRaises(ValueError, p.send_signal, signal.SIGTERM)
-
-    def test_wait(self):
-        # check exit code signal
-        sproc = get_test_subprocess()
-        p = psutil.Process(sproc.pid)
-        p.kill()
-        code = p.wait()
-        if POSIX:
-            self.assertEqual(code, signal.SIGKILL)
-        else:
-            self.assertEqual(code, 0)
-        self.assertFalse(p.is_running())
-
-        sproc = get_test_subprocess()
-        p = psutil.Process(sproc.pid)
-        p.terminate()
-        code = p.wait()
-        if POSIX:
-            self.assertEqual(code, signal.SIGTERM)
-        else:
-            self.assertEqual(code, 0)
-        self.assertFalse(p.is_running())
-
-        # check sys.exit() code
-        code = "import time, sys; time.sleep(0.01); sys.exit(5);"
-        sproc = get_test_subprocess([PYTHON, "-c", code])
-        p = psutil.Process(sproc.pid)
-        self.assertEqual(p.wait(), 5)
-        self.assertFalse(p.is_running())
-
-        # Test wait() issued twice.
-        # It is not supposed to raise NSP when the process is gone.
-        # On UNIX this should return None, on Windows it should keep
-        # returning the exit code.
-        sproc = get_test_subprocess([PYTHON, "-c", code])
-        p = psutil.Process(sproc.pid)
-        self.assertEqual(p.wait(), 5)
-        self.assertIn(p.wait(), (5, None))
-
-        # test timeout
-        sproc = get_test_subprocess()
-        p = psutil.Process(sproc.pid)
-        p.name()
-        self.assertRaises(psutil.TimeoutExpired, p.wait, 0.01)
-
-        # timeout < 0 not allowed
-        self.assertRaises(ValueError, p.wait, -1)
-
-    # XXX why is this skipped on Windows?
-    @unittest.skipUnless(POSIX, 'skipped on Windows')
-    def test_wait_non_children(self):
-        # test wait() against processes which are not our children
-        code = "import sys;"
-        code += "from subprocess import Popen, PIPE;"
-        code += "cmd = ['%s', '-c', 'import time; time.sleep(60)'];" % PYTHON
-        code += "sp = Popen(cmd, stdout=PIPE);"
-        code += "sys.stdout.write(str(sp.pid));"
-        sproc = get_test_subprocess([PYTHON, "-c", code],
-                                    stdout=subprocess.PIPE)
-        grandson_pid = int(sproc.stdout.read())
-        grandson_proc = psutil.Process(grandson_pid)
-        try:
-            self.assertRaises(psutil.TimeoutExpired, grandson_proc.wait, 0.01)
-            grandson_proc.kill()
-            ret = grandson_proc.wait()
-            self.assertEqual(ret, None)
-        finally:
-            reap_children(recursive=True)
-
-    def test_wait_timeout_0(self):
-        sproc = get_test_subprocess()
-        p = psutil.Process(sproc.pid)
-        self.assertRaises(psutil.TimeoutExpired, p.wait, 0)
-        p.kill()
-        stop_at = time.time() + 2
-        while True:
-            try:
-                code = p.wait(0)
-            except psutil.TimeoutExpired:
-                if time.time() >= stop_at:
-                    raise
-            else:
-                break
-        if POSIX:
-            self.assertEqual(code, signal.SIGKILL)
-        else:
-            self.assertEqual(code, 0)
-        self.assertFalse(p.is_running())
-
-    def test_cpu_percent(self):
-        p = psutil.Process()
-        p.cpu_percent(interval=0.001)
-        p.cpu_percent(interval=0.001)
-        for x in range(100):
-            percent = p.cpu_percent(interval=None)
-            self.assertIsInstance(percent, float)
-            self.assertGreaterEqual(percent, 0.0)
-            if not POSIX:
-                self.assertLessEqual(percent, 100.0)
-            else:
-                self.assertGreaterEqual(percent, 0.0)
-
-    def test_cpu_times(self):
-        times = psutil.Process().cpu_times()
-        assert (times.user > 0.0) or (times.system > 0.0), times
-        assert (times.children_user >= 0.0), times
-        assert (times.children_system >= 0.0), times
-        # make sure returned values can be pretty printed with strftime
-        for name in times._fields:
-            time.strftime("%H:%M:%S", time.localtime(getattr(times, name)))
-
-    # Test Process.cpu_times() against os.times()
-    # os.times() is broken on Python 2.6
-    # http://bugs.python.org/issue1040026
-    # XXX fails on OSX: not sure if it's for os.times(). We should
-    # try this with Python 2.7 and re-enable the test.
-
-    @unittest.skipUnless(sys.version_info > (2, 6, 1) and not OSX,
-                         'os.times() is not reliable on this Python version')
-    def test_cpu_times_2(self):
-        user_time, kernel_time = psutil.Process().cpu_times()[:2]
-        utime, ktime = os.times()[:2]
-
-        # Use os.times()[:2] as base values to compare our results
-        # using a tolerance  of +/- 0.1 seconds.
-        # It will fail if the difference between the values is > 0.1s.
-        if (max([user_time, utime]) - min([user_time, utime])) > 0.1:
-            self.fail("expected: %s, found: %s" % (utime, user_time))
-
-        if (max([kernel_time, ktime]) - min([kernel_time, ktime])) > 0.1:
-            self.fail("expected: %s, found: %s" % (ktime, kernel_time))
-
-    def test_create_time(self):
-        sproc = get_test_subprocess(wait=True)
-        now = time.time()
-        p = psutil.Process(sproc.pid)
-        create_time = p.create_time()
-
-        # Use time.time() as base value to compare our result using a
-        # tolerance of +/- 1 second.
-        # It will fail if the difference between the values is > 2s.
-        difference = abs(create_time - now)
-        if difference > 2:
-            self.fail("expected: %s, found: %s, difference: %s"
-                      % (now, create_time, difference))
-
-        # make sure returned value can be pretty printed with strftime
-        time.strftime("%Y %m %d %H:%M:%S", time.localtime(p.create_time()))
-
-    @unittest.skipIf(WINDOWS, 'Windows only')
-    def test_terminal(self):
-        terminal = psutil.Process().terminal()
-        if sys.stdin.isatty():
-            tty = os.path.realpath(sh('tty'))
-            self.assertEqual(terminal, tty)
-        else:
-            assert terminal, repr(terminal)
-
-    @unittest.skipUnless(LINUX or BSD or WINDOWS,
-                         'not available on this platform')
-    @skip_on_not_implemented(only_if=LINUX)
-    def test_io_counters(self):
-        p = psutil.Process()
-        # test reads
-        io1 = p.io_counters()
-        with open(PYTHON, 'rb') as f:
-            f.read()
-        io2 = p.io_counters()
-        if not BSD:
-            assert io2.read_count > io1.read_count, (io1, io2)
-            self.assertEqual(io2.write_count, io1.write_count)
-        assert io2.read_bytes >= io1.read_bytes, (io1, io2)
-        assert io2.write_bytes >= io1.write_bytes, (io1, io2)
-        # test writes
-        io1 = p.io_counters()
-        with tempfile.TemporaryFile(prefix=TESTFILE_PREFIX) as f:
-            if PY3:
-                f.write(bytes("x" * 1000000, 'ascii'))
-            else:
-                f.write("x" * 1000000)
-        io2 = p.io_counters()
-        assert io2.write_count >= io1.write_count, (io1, io2)
-        assert io2.write_bytes >= io1.write_bytes, (io1, io2)
-        assert io2.read_count >= io1.read_count, (io1, io2)
-        assert io2.read_bytes >= io1.read_bytes, (io1, io2)
-
-    @unittest.skipUnless(LINUX or (WINDOWS and get_winver() >= WIN_VISTA),
-                         'Linux and Windows Vista only')
-    @unittest.skipIf(LINUX and TRAVIS, "unknown failure on travis")
-    def test_ionice(self):
-        if LINUX:
-            from psutil import (IOPRIO_CLASS_NONE, IOPRIO_CLASS_RT,
-                                IOPRIO_CLASS_BE, IOPRIO_CLASS_IDLE)
-            self.assertEqual(IOPRIO_CLASS_NONE, 0)
-            self.assertEqual(IOPRIO_CLASS_RT, 1)
-            self.assertEqual(IOPRIO_CLASS_BE, 2)
-            self.assertEqual(IOPRIO_CLASS_IDLE, 3)
-            p = psutil.Process()
-            try:
-                p.ionice(2)
-                ioclass, value = p.ionice()
-                if enum is not None:
-                    self.assertIsInstance(ioclass, enum.IntEnum)
-                self.assertEqual(ioclass, 2)
-                self.assertEqual(value, 4)
-                #
-                p.ionice(3)
-                ioclass, value = p.ionice()
-                self.assertEqual(ioclass, 3)
-                self.assertEqual(value, 0)
-                #
-                p.ionice(2, 0)
-                ioclass, value = p.ionice()
-                self.assertEqual(ioclass, 2)
-                self.assertEqual(value, 0)
-                p.ionice(2, 7)
-                ioclass, value = p.ionice()
-                self.assertEqual(ioclass, 2)
-                self.assertEqual(value, 7)
-                #
-                self.assertRaises(ValueError, p.ionice, 2, 10)
-                self.assertRaises(ValueError, p.ionice, 2, -1)
-                self.assertRaises(ValueError, p.ionice, 4)
-                self.assertRaises(TypeError, p.ionice, 2, "foo")
-                self.assertRaisesRegex(
-                    ValueError, "can't specify value with IOPRIO_CLASS_NONE",
-                    p.ionice, psutil.IOPRIO_CLASS_NONE, 1)
-                self.assertRaisesRegex(
-                    ValueError, "can't specify value with IOPRIO_CLASS_IDLE",
-                    p.ionice, psutil.IOPRIO_CLASS_IDLE, 1)
-                self.assertRaisesRegex(
-                    ValueError, "'ioclass' argument must be specified",
-                    p.ionice, value=1)
-            finally:
-                p.ionice(IOPRIO_CLASS_NONE)
-        else:
-            p = psutil.Process()
-            original = p.ionice()
-            self.assertIsInstance(original, int)
-            try:
-                value = 0  # very low
-                if original == value:
-                    value = 1  # low
-                p.ionice(value)
-                self.assertEqual(p.ionice(), value)
-            finally:
-                p.ionice(original)
-            #
-            self.assertRaises(ValueError, p.ionice, 3)
-            self.assertRaises(TypeError, p.ionice, 2, 1)
-
-    @unittest.skipUnless(LINUX and RLIMIT_SUPPORT,
-                         "only available on Linux >= 2.6.36")
-    def test_rlimit_get(self):
-        import resource
-        p = psutil.Process(os.getpid())
-        names = [x for x in dir(psutil) if x.startswith('RLIMIT')]
-        assert names, names
-        for name in names:
-            value = getattr(psutil, name)
-            self.assertGreaterEqual(value, 0)
-            if name in dir(resource):
-                self.assertEqual(value, getattr(resource, name))
-                # XXX - On PyPy RLIMIT_INFINITY returned by
-                # resource.getrlimit() is reported as a very big long
-                # number instead of -1. It looks like a bug with PyPy.
-                if PYPY:
-                    continue
-                self.assertEqual(p.rlimit(value), resource.getrlimit(value))
-            else:
-                ret = p.rlimit(value)
-                self.assertEqual(len(ret), 2)
-                self.assertGreaterEqual(ret[0], -1)
-                self.assertGreaterEqual(ret[1], -1)
-
-    @unittest.skipUnless(LINUX and RLIMIT_SUPPORT,
-                         "only available on Linux >= 2.6.36")
-    def test_rlimit_set(self):
-        sproc = get_test_subprocess()
-        p = psutil.Process(sproc.pid)
-        p.rlimit(psutil.RLIMIT_NOFILE, (5, 5))
-        self.assertEqual(p.rlimit(psutil.RLIMIT_NOFILE), (5, 5))
-        # If pid is 0 prlimit() applies to the calling process and
-        # we don't want that.
-        with self.assertRaises(ValueError):
-            psutil._psplatform.Process(0).rlimit(0)
-        with self.assertRaises(ValueError):
-            p.rlimit(psutil.RLIMIT_NOFILE, (5, 5, 5))
-
-    @unittest.skipUnless(LINUX and RLIMIT_SUPPORT,
-                         "only available on Linux >= 2.6.36")
-    def test_rlimit(self):
-        p = psutil.Process()
-        soft, hard = p.rlimit(psutil.RLIMIT_FSIZE)
-        try:
-            p.rlimit(psutil.RLIMIT_FSIZE, (1024, hard))
-            with open(TESTFN, "wb") as f:
-                f.write(b"X" * 1024)
-            # write() or flush() doesn't always cause the exception
-            # but close() will.
-            with self.assertRaises(IOError) as exc:
-                with open(TESTFN, "wb") as f:
-                    f.write(b"X" * 1025)
-            self.assertEqual(exc.exception.errno if PY3 else exc.exception[0],
-                             errno.EFBIG)
-        finally:
-            p.rlimit(psutil.RLIMIT_FSIZE, (soft, hard))
-            self.assertEqual(p.rlimit(psutil.RLIMIT_FSIZE), (soft, hard))
-
-    @unittest.skipUnless(LINUX and RLIMIT_SUPPORT,
-                         "only available on Linux >= 2.6.36")
-    def test_rlimit_infinity(self):
-        # First set a limit, then re-set it by specifying INFINITY
-        # and assume we overridden the previous limit.
-        p = psutil.Process()
-        soft, hard = p.rlimit(psutil.RLIMIT_FSIZE)
-        try:
-            p.rlimit(psutil.RLIMIT_FSIZE, (1024, hard))
-            p.rlimit(psutil.RLIMIT_FSIZE, (psutil.RLIM_INFINITY, hard))
-            with open(TESTFN, "wb") as f:
-                f.write(b"X" * 2048)
-        finally:
-            p.rlimit(psutil.RLIMIT_FSIZE, (soft, hard))
-            self.assertEqual(p.rlimit(psutil.RLIMIT_FSIZE), (soft, hard))
-
-    @unittest.skipUnless(LINUX and RLIMIT_SUPPORT,
-                         "only available on Linux >= 2.6.36")
-    def test_rlimit_infinity_value(self):
-        # RLIMIT_FSIZE should be RLIM_INFINITY, which will be a really
-        # big number on a platform with large file support.  On these
-        # platforms we need to test that the get/setrlimit functions
-        # properly convert the number to a C long long and that the
-        # conversion doesn't raise an error.
-        p = psutil.Process()
-        soft, hard = p.rlimit(psutil.RLIMIT_FSIZE)
-        self.assertEqual(psutil.RLIM_INFINITY, hard)
-        p.rlimit(psutil.RLIMIT_FSIZE, (soft, hard))
-
-    def test_num_threads(self):
-        # on certain platforms such as Linux we might test for exact
-        # thread number, since we always have with 1 thread per process,
-        # but this does not apply across all platforms (OSX, Windows)
-        p = psutil.Process()
-        if OPENBSD:
-            try:
-                step1 = p.num_threads()
-            except psutil.AccessDenied:
-                raise unittest.SkipTest("on OpenBSD this requires root access")
-        else:
-            step1 = p.num_threads()
-
-        thread = ThreadTask()
-        thread.start()
-        try:
-            step2 = p.num_threads()
-            self.assertEqual(step2, step1 + 1)
-            thread.stop()
-        finally:
-            if thread._running:
-                thread.stop()
-
-    @unittest.skipUnless(WINDOWS, 'Windows only')
-    def test_num_handles(self):
-        # a better test is done later into test/_windows.py
-        p = psutil.Process()
-        self.assertGreater(p.num_handles(), 0)
-
-    def test_threads(self):
-        p = psutil.Process()
-        if OPENBSD:
-            try:
-                step1 = p.threads()
-            except psutil.AccessDenied:
-                raise unittest.SkipTest("on OpenBSD this requires root access")
-        else:
-            step1 = p.threads()
-
-        thread = ThreadTask()
-        thread.start()
-
-        try:
-            step2 = p.threads()
-            self.assertEqual(len(step2), len(step1) + 1)
-            # on Linux, first thread id is supposed to be this process
-            if LINUX:
-                self.assertEqual(step2[0].id, os.getpid())
-            athread = step2[0]
-            # test named tuple
-            self.assertEqual(athread.id, athread[0])
-            self.assertEqual(athread.user_time, athread[1])
-            self.assertEqual(athread.system_time, athread[2])
-            # test num threads
-            thread.stop()
-        finally:
-            if thread._running:
-                thread.stop()
-
-    @retry_before_failing()
-    # see: https://travis-ci.org/giampaolo/psutil/jobs/111842553
-    @unittest.skipIf(OSX and TRAVIS, "")
-    def test_threads_2(self):
-        p = psutil.Process()
-        if OPENBSD:
-            try:
-                p.threads()
-            except psutil.AccessDenied:
-                raise unittest.SkipTest(
-                    "on OpenBSD this requires root access")
-        self.assertAlmostEqual(p.cpu_times().user,
-                               p.threads()[0].user_time, delta=0.1)
-        self.assertAlmostEqual(p.cpu_times().system,
-                               p.threads()[0].system_time, delta=0.1)
-
-    def test_memory_info(self):
-        p = psutil.Process()
-
-        # step 1 - get a base value to compare our results
-        rss1, vms1 = p.memory_info()[:2]
-        percent1 = p.memory_percent()
-        self.assertGreater(rss1, 0)
-        self.assertGreater(vms1, 0)
-
-        # step 2 - allocate some memory
-        memarr = [None] * 1500000
-
-        rss2, vms2 = p.memory_info()[:2]
-        percent2 = p.memory_percent()
-
-        # step 3 - make sure that the memory usage bumped up
-        self.assertGreater(rss2, rss1)
-        self.assertGreaterEqual(vms2, vms1)  # vms might be equal
-        self.assertGreater(percent2, percent1)
-        del memarr
-
-        if WINDOWS:
-            mem = p.memory_info()
-            self.assertEqual(mem.rss, mem.wset)
-            self.assertEqual(mem.vms, mem.pagefile)
-
-        mem = p.memory_info()
-        for name in mem._fields:
-            self.assertGreaterEqual(getattr(mem, name), 0)
-
-    def test_memory_full_info(self):
-        mem = psutil.Process().memory_full_info()
-        for name in mem._fields:
-            self.assertGreaterEqual(getattr(mem, name), 0)
-        if LINUX or WINDOWS or OSX:
-            self.assertGreater(mem.uss, 0)
-        if LINUX:
-            self.assertGreater(mem.pss, 0)
-            self.assertGreater(mem.pss, mem.uss)
-
-    @unittest.skipIf(OPENBSD or NETBSD, "not available on this platform")
-    def test_memory_maps(self):
-        p = psutil.Process()
-        maps = p.memory_maps()
-        paths = [x for x in maps]
-        self.assertEqual(len(paths), len(set(paths)))
-        ext_maps = p.memory_maps(grouped=False)
-
-        for nt in maps:
-            if not nt.path.startswith('['):
-                assert os.path.isabs(nt.path), nt.path
-                if POSIX:
-                    try:
-                        assert os.path.exists(nt.path) or \
-                            os.path.islink(nt.path), nt.path
-                    except AssertionError:
-                        if not LINUX:
-                            raise
-                        else:
-                            # https://github.com/giampaolo/psutil/issues/759
-                            with open('/proc/self/smaps') as f:
-                                data = f.read()
-                            if "%s (deleted)" % nt.path not in data:
-                                raise
-                else:
-                    # XXX - On Windows we have this strange behavior with
-                    # 64 bit dlls: they are visible via explorer but cannot
-                    # be accessed via os.stat() (wtf?).
-                    if '64' not in os.path.basename(nt.path):
-                        assert os.path.exists(nt.path), nt.path
-        for nt in ext_maps:
-            for fname in nt._fields:
-                value = getattr(nt, fname)
-                if fname == 'path':
-                    continue
-                elif fname in ('addr', 'perms'):
-                    assert value, value
-                else:
-                    self.assertIsInstance(value, (int, long))
-                    assert value >= 0, value
-
-    def test_memory_percent(self):
-        p = psutil.Process()
-        ret = p.memory_percent()
-        assert 0 <= ret <= 100, ret
-        ret = p.memory_percent(memtype='vms')
-        assert 0 <= ret <= 100, ret
-        assert 0 <= ret <= 100, ret
-        self.assertRaises(ValueError, p.memory_percent, memtype="?!?")
-        if LINUX or OSX or WINDOWS:
-            ret = p.memory_percent(memtype='uss')
-            assert 0 <= ret <= 100, ret
-            assert 0 <= ret <= 100, ret
-
-    def test_is_running(self):
-        sproc = get_test_subprocess(wait=True)
-        p = psutil.Process(sproc.pid)
-        assert p.is_running()
-        assert p.is_running()
-        p.kill()
-        p.wait()
-        assert not p.is_running()
-        assert not p.is_running()
-
-    def test_exe(self):
-        sproc = get_test_subprocess(wait=True)
-        exe = psutil.Process(sproc.pid).exe()
-        try:
-            self.assertEqual(exe, PYTHON)
-        except AssertionError:
-            if WINDOWS and len(exe) == len(PYTHON):
-                # on Windows we don't care about case sensitivity
-                normcase = os.path.normcase
-                self.assertEqual(normcase(exe), normcase(PYTHON))
-            else:
-                # certain platforms such as BSD are more accurate returning:
-                # "/usr/local/bin/python2.7"
-                # ...instead of:
-                # "/usr/local/bin/python"
-                # We do not want to consider this difference in accuracy
-                # an error.
-                ver = "%s.%s" % (sys.version_info[0], sys.version_info[1])
-                self.assertEqual(exe.replace(ver, ''), PYTHON.replace(ver, ''))
-
-    def test_cmdline(self):
-        cmdline = [PYTHON, "-c", "import time; time.sleep(60)"]
-        sproc = get_test_subprocess(cmdline, wait=True)
-        try:
-            self.assertEqual(' '.join(psutil.Process(sproc.pid).cmdline()),
-                             ' '.join(cmdline))
-        except AssertionError:
-            # XXX - most of the times the underlying sysctl() call on Net
-            # and Open BSD returns a truncated string.
-            # Also /proc/pid/cmdline behaves the same so it looks
-            # like this is a kernel bug.
-            if NETBSD or OPENBSD:
-                self.assertEqual(
-                    psutil.Process(sproc.pid).cmdline()[0], PYTHON)
-            else:
-                raise
-
-    def test_name(self):
-        sproc = get_test_subprocess(PYTHON, wait=True)
-        name = psutil.Process(sproc.pid).name().lower()
-        pyexe = os.path.basename(os.path.realpath(sys.executable)).lower()
-        assert pyexe.startswith(name), (pyexe, name)
-
-    @unittest.skipIf(SUNOS, "doesn't work on Solaris")
-    def test_prog_w_funky_name(self):
-        # Test that name(), exe() and cmdline() correctly handle programs
-        # with funky chars such as spaces and ")", see:
-        # https://github.com/giampaolo/psutil/issues/628
-        funky_path = create_temp_executable_file('foo bar )')
-        self.addCleanup(safe_remove, funky_path)
-        cmdline = [funky_path, "-c",
-                   "import time; [time.sleep(0.01) for x in range(3000)];"
-                   "arg1", "arg2", "", "arg3", ""]
-        sproc = get_test_subprocess(cmdline)
-        p = psutil.Process(sproc.pid)
-        # ...in order to try to prevent occasional failures on travis
-        if TRAVIS:
-            wait_for_pid(p.pid)
-        self.assertEqual(p.cmdline(), cmdline)
-        self.assertEqual(p.name(), os.path.basename(funky_path))
-        self.assertEqual(os.path.normcase(p.exe()),
-                         os.path.normcase(funky_path))
-
-    @unittest.skipUnless(POSIX, 'posix only')
-    def test_uids(self):
-        p = psutil.Process()
-        real, effective, saved = p.uids()
-        # os.getuid() refers to "real" uid
-        self.assertEqual(real, os.getuid())
-        # os.geteuid() refers to "effective" uid
-        self.assertEqual(effective, os.geteuid())
-        # no such thing as os.getsuid() ("saved" uid), but starting
-        # from python 2.7 we have os.getresuid()[2]
-        if hasattr(os, "getresuid"):
-            self.assertEqual(saved, os.getresuid()[2])
-
-    @unittest.skipUnless(POSIX, 'posix only')
-    def test_gids(self):
-        p = psutil.Process()
-        real, effective, saved = p.gids()
-        # os.getuid() refers to "real" uid
-        self.assertEqual(real, os.getgid())
-        # os.geteuid() refers to "effective" uid
-        self.assertEqual(effective, os.getegid())
-        # no such thing as os.getsuid() ("saved" uid), but starting
-        # from python 2.7 we have os.getresgid()[2]
-        if hasattr(os, "getresuid"):
-            self.assertEqual(saved, os.getresgid()[2])
-
-    def test_nice(self):
-        p = psutil.Process()
-        self.assertRaises(TypeError, p.nice, "str")
-        if WINDOWS:
-            try:
-                init = p.nice()
-                if sys.version_info > (3, 4):
-                    self.assertIsInstance(init, enum.IntEnum)
-                else:
-                    self.assertIsInstance(init, int)
-                self.assertEqual(init, psutil.NORMAL_PRIORITY_CLASS)
-                p.nice(psutil.HIGH_PRIORITY_CLASS)
-                self.assertEqual(p.nice(), psutil.HIGH_PRIORITY_CLASS)
-                p.nice(psutil.NORMAL_PRIORITY_CLASS)
-                self.assertEqual(p.nice(), psutil.NORMAL_PRIORITY_CLASS)
-            finally:
-                p.nice(psutil.NORMAL_PRIORITY_CLASS)
-        else:
-            try:
-                first_nice = p.nice()
-                p.nice(1)
-                self.assertEqual(p.nice(), 1)
-                # going back to previous nice value raises
-                # AccessDenied on OSX
-                if not OSX:
-                    p.nice(0)
-                    self.assertEqual(p.nice(), 0)
-            except psutil.AccessDenied:
-                pass
-            finally:
-                try:
-                    p.nice(first_nice)
-                except psutil.AccessDenied:
-                    pass
-
-    def test_status(self):
-        p = psutil.Process()
-        self.assertEqual(p.status(), psutil.STATUS_RUNNING)
-
-    def test_username(self):
-        sproc = get_test_subprocess()
-        p = psutil.Process(sproc.pid)
-        if POSIX:
-            import pwd
-            self.assertEqual(p.username(), pwd.getpwuid(os.getuid()).pw_name)
-            with mock.patch("psutil.pwd.getpwuid",
-                            side_effect=KeyError) as fun:
-                p.username() == str(p.uids().real)
-                assert fun.called
-
-        elif WINDOWS and 'USERNAME' in os.environ:
-            expected_username = os.environ['USERNAME']
-            expected_domain = os.environ['USERDOMAIN']
-            domain, username = p.username().split('\\')
-            self.assertEqual(domain, expected_domain)
-            self.assertEqual(username, expected_username)
-        else:
-            p.username()
-
-    def test_cwd(self):
-        sproc = get_test_subprocess(wait=True)
-        p = psutil.Process(sproc.pid)
-        self.assertEqual(p.cwd(), os.getcwd())
-
-    def test_cwd_2(self):
-        cmd = [PYTHON, "-c", "import os, time; os.chdir('..'); time.sleep(60)"]
-        sproc = get_test_subprocess(cmd, wait=True)
-        p = psutil.Process(sproc.pid)
-        call_until(p.cwd, "ret == os.path.dirname(os.getcwd())")
-
-    @unittest.skipUnless(WINDOWS or LINUX or FREEBSD,
-                         'not available on this platform')
-    @unittest.skipIf(LINUX and TRAVIS, "unknown failure on travis")
-    def test_cpu_affinity(self):
-        p = psutil.Process()
-        initial = p.cpu_affinity()
-        if hasattr(os, "sched_getaffinity"):
-            self.assertEqual(initial, list(os.sched_getaffinity(p.pid)))
-        self.assertEqual(len(initial), len(set(initial)))
-        all_cpus = list(range(len(psutil.cpu_percent(percpu=True))))
-        # setting on travis doesn't seem to work (always return all
-        # CPUs on get):
-        # AssertionError: Lists differ: [0, 1, 2, 3, 4, 5, 6, ... != [0]
-        for n in all_cpus:
-            p.cpu_affinity([n])
-            self.assertEqual(p.cpu_affinity(), [n])
-            if hasattr(os, "sched_getaffinity"):
-                self.assertEqual(p.cpu_affinity(),
-                                 list(os.sched_getaffinity(p.pid)))
-        #
-        p.cpu_affinity(all_cpus)
-        self.assertEqual(p.cpu_affinity(), all_cpus)
-        if hasattr(os, "sched_getaffinity"):
-            self.assertEqual(p.cpu_affinity(),
-                             list(os.sched_getaffinity(p.pid)))
-        #
-        self.assertRaises(TypeError, p.cpu_affinity, 1)
-        p.cpu_affinity(initial)
-        # it should work with all iterables, not only lists
-        p.cpu_affinity(set(all_cpus))
-        p.cpu_affinity(tuple(all_cpus))
-        invalid_cpu = [len(psutil.cpu_times(percpu=True)) + 10]
-        self.assertRaises(ValueError, p.cpu_affinity, invalid_cpu)
-        self.assertRaises(ValueError, p.cpu_affinity, range(10000, 11000))
-        self.assertRaises(TypeError, p.cpu_affinity, [0, "1"])
-
-    # TODO
-    @unittest.skipIf(BSD, "broken on BSD, see #595")
-    @unittest.skipIf(APPVEYOR,
-                     "can't find any process file on Appveyor")
-    def test_open_files(self):
-        # current process
-        p = psutil.Process()
-        files = p.open_files()
-        self.assertFalse(TESTFN in files)
-        with open(TESTFN, 'wb') as f:
-            f.write(b'x' * 1024)
-            f.flush()
-            # give the kernel some time to see the new file
-            files = call_until(p.open_files, "len(ret) != %i" % len(files))
-            for file in files:
-                if file.path == TESTFN:
-                    if LINUX:
-                        self.assertEqual(file.position, 1024)
-                    break
-            else:
-                self.fail("no file found; files=%s" % repr(files))
-        for file in files:
-            assert os.path.isfile(file.path), file
-
-        # another process
-        cmdline = "import time; f = open(r'%s', 'r'); time.sleep(60);" % TESTFN
-        sproc = get_test_subprocess([PYTHON, "-c", cmdline], wait=True)
-        p = psutil.Process(sproc.pid)
-
-        for x in range(100):
-            filenames = [x.path for x in p.open_files()]
-            if TESTFN in filenames:
-                break
-            time.sleep(.01)
-        else:
-            self.assertIn(TESTFN, filenames)
-        for file in filenames:
-            assert os.path.isfile(file), file
-
-    # TODO
-    @unittest.skipIf(BSD, "broken on BSD, see #595")
-    @unittest.skipIf(APPVEYOR,
-                     "can't find any process file on Appveyor")
-    def test_open_files_2(self):
-        # test fd and path fields
-        with open(TESTFN, 'w') as fileobj:
-            p = psutil.Process()
-            for file in p.open_files():
-                if file.path == fileobj.name or file.fd == fileobj.fileno():
-                    break
-            else:
-                self.fail("no file found; files=%s" % repr(p.open_files()))
-            self.assertEqual(file.path, fileobj.name)
-            if WINDOWS:
-                self.assertEqual(file.fd, -1)
-            else:
-                self.assertEqual(file.fd, fileobj.fileno())
-            # test positions
-            ntuple = p.open_files()[0]
-            self.assertEqual(ntuple[0], ntuple.path)
-            self.assertEqual(ntuple[1], ntuple.fd)
-            # test file is gone
-            self.assertTrue(fileobj.name not in p.open_files())
-
-    def compare_proc_sys_cons(self, pid, proc_cons):
-        from psutil._common import pconn
-        sys_cons = []
-        for c in psutil.net_connections(kind='all'):
-            if c.pid == pid:
-                sys_cons.append(pconn(*c[:-1]))
-        if FREEBSD:
-            # on FreeBSD all fds are set to -1
-            proc_cons = [pconn(*[-1] + list(x[1:])) for x in proc_cons]
-        self.assertEqual(sorted(proc_cons), sorted(sys_cons))
-
-    @skip_on_access_denied(only_if=OSX)
-    def test_connections(self):
-        def check_conn(proc, conn, family, type, laddr, raddr, status, kinds):
-            all_kinds = ("all", "inet", "inet4", "inet6", "tcp", "tcp4",
-                         "tcp6", "udp", "udp4", "udp6")
-            check_connection_ntuple(conn)
-            self.assertEqual(conn.family, family)
-            self.assertEqual(conn.type, type)
-            self.assertEqual(conn.laddr, laddr)
-            self.assertEqual(conn.raddr, raddr)
-            self.assertEqual(conn.status, status)
-            for kind in all_kinds:
-                cons = proc.connections(kind=kind)
-                if kind in kinds:
-                    self.assertNotEqual(cons, [])
-                else:
-                    self.assertEqual(cons, [])
-            # compare against system-wide connections
-            # XXX Solaris can't retrieve system-wide UNIX
-            # sockets.
-            if not SUNOS:
-                self.compare_proc_sys_cons(proc.pid, [conn])
-
-        tcp_template = textwrap.dedent("""
-            import socket, time
-            s = socket.socket($family, socket.SOCK_STREAM)
-            s.bind(('$addr', 0))
-            s.listen(1)
-            with open('$testfn', 'w') as f:
-                f.write(str(s.getsockname()[:2]))
-            time.sleep(60)
-        """)
-
-        udp_template = textwrap.dedent("""
-            import socket, time
-            s = socket.socket($family, socket.SOCK_DGRAM)
-            s.bind(('$addr', 0))
-            with open('$testfn', 'w') as f:
-                f.write(str(s.getsockname()[:2]))
-            time.sleep(60)
-        """)
-
-        from string import Template
-        testfile = os.path.basename(TESTFN)
-        tcp4_template = Template(tcp_template).substitute(
-            family=int(AF_INET), addr="127.0.0.1", testfn=testfile)
-        udp4_template = Template(udp_template).substitute(
-            family=int(AF_INET), addr="127.0.0.1", testfn=testfile)
-        tcp6_template = Template(tcp_template).substitute(
-            family=int(AF_INET6), addr="::1", testfn=testfile)
-        udp6_template = Template(udp_template).substitute(
-            family=int(AF_INET6), addr="::1", testfn=testfile)
-
-        # launch various subprocess instantiating a socket of various
-        # families and types to enrich psutil results
-        tcp4_proc = pyrun(tcp4_template)
-        tcp4_addr = eval(wait_for_file(testfile))
-        udp4_proc = pyrun(udp4_template)
-        udp4_addr = eval(wait_for_file(testfile))
-        if supports_ipv6():
-            tcp6_proc = pyrun(tcp6_template)
-            tcp6_addr = eval(wait_for_file(testfile))
-            udp6_proc = pyrun(udp6_template)
-            udp6_addr = eval(wait_for_file(testfile))
-        else:
-            tcp6_proc = None
-            udp6_proc = None
-            tcp6_addr = None
-            udp6_addr = None
-
-        for p in psutil.Process().children():
-            cons = p.connections()
-            self.assertEqual(len(cons), 1)
-            for conn in cons:
-                # TCP v4
-                if p.pid == tcp4_proc.pid:
-                    check_conn(p, conn, AF_INET, SOCK_STREAM, tcp4_addr, (),
-                               psutil.CONN_LISTEN,
-                               ("all", "inet", "inet4", "tcp", "tcp4"))
-                # UDP v4
-                elif p.pid == udp4_proc.pid:
-                    check_conn(p, conn, AF_INET, SOCK_DGRAM, udp4_addr, (),
-                               psutil.CONN_NONE,
-                               ("all", "inet", "inet4", "udp", "udp4"))
-                # TCP v6
-                elif p.pid == getattr(tcp6_proc, "pid", None):
-                    check_conn(p, conn, AF_INET6, SOCK_STREAM, tcp6_addr, (),
-                               psutil.CONN_LISTEN,
-                               ("all", "inet", "inet6", "tcp", "tcp6"))
-                # UDP v6
-                elif p.pid == getattr(udp6_proc, "pid", None):
-                    check_conn(p, conn, AF_INET6, SOCK_DGRAM, udp6_addr, (),
-                               psutil.CONN_NONE,
-                               ("all", "inet", "inet6", "udp", "udp6"))
-
-    @unittest.skipUnless(hasattr(socket, 'AF_UNIX'),
-                         'AF_UNIX is not supported')
-    @skip_on_access_denied(only_if=OSX)
-    def test_connections_unix(self):
-        def check(type):
-            safe_remove(TESTFN)
-            sock = socket.socket(AF_UNIX, type)
-            with contextlib.closing(sock):
-                sock.bind(TESTFN)
-                cons = psutil.Process().connections(kind='unix')
-                conn = cons[0]
-                check_connection_ntuple(conn)
-                if conn.fd != -1:  # != sunos and windows
-                    self.assertEqual(conn.fd, sock.fileno())
-                self.assertEqual(conn.family, AF_UNIX)
-                self.assertEqual(conn.type, type)
-                self.assertEqual(conn.laddr, TESTFN)
-                if not SUNOS:
-                    # XXX Solaris can't retrieve system-wide UNIX
-                    # sockets.
-                    self.compare_proc_sys_cons(os.getpid(), cons)
-
-        check(SOCK_STREAM)
-        check(SOCK_DGRAM)
-
-    @unittest.skipUnless(hasattr(socket, "fromfd"),
-                         'socket.fromfd() is not availble')
-    @unittest.skipIf(WINDOWS or SUNOS,
-                     'connection fd not available on this platform')
-    def test_connection_fromfd(self):
-        with contextlib.closing(socket.socket()) as sock:
-            sock.bind(('localhost', 0))
-            sock.listen(1)
-            p = psutil.Process()
-            for conn in p.connections():
-                if conn.fd == sock.fileno():
-                    break
-            else:
-                self.fail("couldn't find socket fd")
-            dupsock = socket.fromfd(conn.fd, conn.family, conn.type)
-            with contextlib.closing(dupsock):
-                self.assertEqual(dupsock.getsockname(), conn.laddr)
-                self.assertNotEqual(sock.fileno(), dupsock.fileno())
-
-    def test_connection_constants(self):
-        ints = []
-        strs = []
-        for name in dir(psutil):
-            if name.startswith('CONN_'):
-                num = getattr(psutil, name)
-                str_ = str(num)
-                assert str_.isupper(), str_
-                assert str_ not in strs, str_
-                assert num not in ints, num
-                ints.append(num)
-                strs.append(str_)
-        if SUNOS:
-            psutil.CONN_IDLE
-            psutil.CONN_BOUND
-        if WINDOWS:
-            psutil.CONN_DELETE_TCB
-
-    @unittest.skipUnless(POSIX, 'posix only')
-    def test_num_fds(self):
-        p = psutil.Process()
-        start = p.num_fds()
-        file = open(TESTFN, 'w')
-        self.addCleanup(file.close)
-        self.assertEqual(p.num_fds(), start + 1)
-        sock = socket.socket()
-        self.addCleanup(sock.close)
-        self.assertEqual(p.num_fds(), start + 2)
-        file.close()
-        sock.close()
-        self.assertEqual(p.num_fds(), start)
-
-    @skip_on_not_implemented(only_if=LINUX)
-    @unittest.skipIf(OPENBSD or NETBSD, "not reliable on Open/NetBSD")
-    def test_num_ctx_switches(self):
-        p = psutil.Process()
-        before = sum(p.num_ctx_switches())
-        for x in range(500000):
-            after = sum(p.num_ctx_switches())
-            if after > before:
-                return
-        self.fail("num ctx switches still the same after 50.000 iterations")
-
-    def test_parent_ppid(self):
-        this_parent = os.getpid()
-        sproc = get_test_subprocess()
-        p = psutil.Process(sproc.pid)
-        self.assertEqual(p.ppid(), this_parent)
-        self.assertEqual(p.parent().pid, this_parent)
-        # no other process is supposed to have us as parent
-        reap_children(recursive=True)
-        for p in psutil.process_iter():
-            if p.pid == sproc.pid:
-                continue
-            self.assertNotEqual(p.ppid(), this_parent)
-
-    def test_children(self):
-        p = psutil.Process()
-        self.assertEqual(p.children(), [])
-        self.assertEqual(p.children(recursive=True), [])
-        sproc = get_test_subprocess()
-        children1 = p.children()
-        children2 = p.children(recursive=True)
-        for children in (children1, children2):
-            self.assertEqual(len(children), 1)
-            self.assertEqual(children[0].pid, sproc.pid)
-            self.assertEqual(children[0].ppid(), os.getpid())
-
-    def test_children_recursive(self):
-        # here we create a subprocess which creates another one as in:
-        # A (parent) -> B (child) -> C (grandchild)
-        s = "import subprocess, os, sys, time;"
-        s += "PYTHON = os.path.realpath(sys.executable);"
-        s += "cmd = [PYTHON, '-c', 'import time; time.sleep(60);'];"
-        s += "subprocess.Popen(cmd);"
-        s += "time.sleep(60);"
-        get_test_subprocess(cmd=[PYTHON, "-c", s])
-        p = psutil.Process()
-        self.assertEqual(len(p.children(recursive=False)), 1)
-        # give the grandchild some time to start
-        stop_at = time.time() + GLOBAL_TIMEOUT
-        while time.time() < stop_at:
-            children = p.children(recursive=True)
-            if len(children) > 1:
-                break
-        self.assertEqual(len(children), 2)
-        self.assertEqual(children[0].ppid(), os.getpid())
-        self.assertEqual(children[1].ppid(), children[0].pid)
-
-    def test_children_duplicates(self):
-        # find the process which has the highest number of children
-        table = collections.defaultdict(int)
-        for p in psutil.process_iter():
-            try:
-                table[p.ppid()] += 1
-            except psutil.Error:
-                pass
-        # this is the one, now let's make sure there are no duplicates
-        pid = sorted(table.items(), key=lambda x: x[1])[-1][0]
-        p = psutil.Process(pid)
-        try:
-            c = p.children(recursive=True)
-        except psutil.AccessDenied:  # windows
-            pass
-        else:
-            self.assertEqual(len(c), len(set(c)))
-
-    def test_suspend_resume(self):
-        sproc = get_test_subprocess(wait=True)
-        p = psutil.Process(sproc.pid)
-        p.suspend()
-        for x in range(100):
-            if p.status() == psutil.STATUS_STOPPED:
-                break
-            time.sleep(0.01)
-        p.resume()
-        self.assertNotEqual(p.status(), psutil.STATUS_STOPPED)
-
-    def test_invalid_pid(self):
-        self.assertRaises(TypeError, psutil.Process, "1")
-        self.assertRaises(ValueError, psutil.Process, -1)
-
-    def test_as_dict(self):
-        p = psutil.Process()
-        d = p.as_dict(attrs=['exe', 'name'])
-        self.assertEqual(sorted(d.keys()), ['exe', 'name'])
-
-        p = psutil.Process(min(psutil.pids()))
-        d = p.as_dict(attrs=['connections'], ad_value='foo')
-        if not isinstance(d['connections'], list):
-            self.assertEqual(d['connections'], 'foo')
-
-        with mock.patch('psutil.Process.name', create=True,
-                        side_effect=NotImplementedError):
-            # By default APIs raising NotImplementedError are
-            # supposed to be skipped.
-            d = p.as_dict()
-            self.assertNotIn('name', list(d.keys()))
-            # ...unless the user explicitly asked for some attr.
-            with self.assertRaises(NotImplementedError):
-                p.as_dict(attrs=["name"])
-        # errors
-        with self.assertRaises(TypeError):
-            p.as_dict('name')
-        with self.assertRaises(ValueError):
-            p.as_dict(['foo'])
-        with self.assertRaises(ValueError):
-            p.as_dict(['foo', 'bar'])
-
-    def test_halfway_terminated_process(self):
-        # Test that NoSuchProcess exception gets raised in case the
-        # process dies after we create the Process object.
-        # Example:
-        #  >>> proc = Process(1234)
-        # >>> time.sleep(2)  # time-consuming task, process dies in meantime
-        #  >>> proc.name()
-        # Refers to Issue #15
-        sproc = get_test_subprocess()
-        p = psutil.Process(sproc.pid)
-        p.terminate()
-        p.wait()
-        if WINDOWS:
-            call_until(psutil.pids, "%s not in ret" % p.pid)
-        self.assertFalse(p.is_running())
-        # self.assertFalse(p.pid in psutil.pids(), msg="retcode = %s" %
-        #   retcode)
-
-        excluded_names = ['pid', 'is_running', 'wait', 'create_time',
-                          'memory_info_ex']
-        if LINUX and not RLIMIT_SUPPORT:
-            excluded_names.append('rlimit')
-        for name in dir(p):
-            if (name.startswith('_') or
-                    name in excluded_names):
-                continue
-            try:
-                meth = getattr(p, name)
-                # get/set methods
-                if name == 'nice':
-                    if POSIX:
-                        ret = meth(1)
-                    else:
-                        ret = meth(psutil.NORMAL_PRIORITY_CLASS)
-                elif name == 'ionice':
-                    ret = meth()
-                    ret = meth(2)
-                elif name == 'rlimit':
-                    ret = meth(psutil.RLIMIT_NOFILE)
-                    ret = meth(psutil.RLIMIT_NOFILE, (5, 5))
-                elif name == 'cpu_affinity':
-                    ret = meth()
-                    ret = meth([0])
-                elif name == 'send_signal':
-                    ret = meth(signal.SIGTERM)
-                else:
-                    ret = meth()
-            except psutil.ZombieProcess:
-                self.fail("ZombieProcess for %r was not supposed to happen" %
-                          name)
-            except psutil.NoSuchProcess:
-                pass
-            except psutil.AccessDenied:
-                if OPENBSD and name in ('threads', 'num_threads'):
-                    pass
-                else:
-                    raise
-            except NotImplementedError:
-                pass
-            else:
-                self.fail(
-                    "NoSuchProcess exception not raised for %r, retval=%s" % (
-                        name, ret))
-
-    @unittest.skipUnless(POSIX, 'posix only')
-    def test_zombie_process(self):
-        def succeed_or_zombie_p_exc(fun, *args, **kwargs):
-            try:
-                return fun(*args, **kwargs)
-            except (psutil.ZombieProcess, psutil.AccessDenied):
-                pass
-
-        # Note: in this test we'll be creating two sub processes.
-        # Both of them are supposed to be freed / killed by
-        # reap_children() as they are attributable to 'us'
-        # (os.getpid()) via children(recursive=True).
-        src = textwrap.dedent("""\
-        import os, sys, time, socket, contextlib
-        child_pid = os.fork()
-        if child_pid > 0:
-            time.sleep(3000)
-        else:
-            # this is the zombie process
-            s = socket.socket(socket.AF_UNIX)
-            with contextlib.closing(s):
-                s.connect('%s')
-                if sys.version_info < (3, ):
-                    pid = str(os.getpid())
-                else:
-                    pid = bytes(str(os.getpid()), 'ascii')
-                s.sendall(pid)
-        """ % TESTFN)
-        with contextlib.closing(socket.socket(socket.AF_UNIX)) as sock:
-            try:
-                sock.settimeout(GLOBAL_TIMEOUT)
-                sock.bind(TESTFN)
-                sock.listen(1)
-                pyrun(src)
-                conn, _ = sock.accept()
-                self.addCleanup(conn.close)
-                select.select([conn.fileno()], [], [], GLOBAL_TIMEOUT)
-                zpid = int(conn.recv(1024))
-                zproc = psutil.Process(zpid)
-                call_until(lambda: zproc.status(),
-                           "ret == psutil.STATUS_ZOMBIE")
-                # A zombie process should always be instantiable
-                zproc = psutil.Process(zpid)
-                # ...and at least its status always be querable
-                self.assertEqual(zproc.status(), psutil.STATUS_ZOMBIE)
-                # ...and it should be considered 'running'
-                self.assertTrue(zproc.is_running())
-                # ...and as_dict() shouldn't crash
-                zproc.as_dict()
-                # if cmdline succeeds it should be an empty list
-                ret = succeed_or_zombie_p_exc(zproc.suspend)
-                if ret is not None:
-                    self.assertEqual(ret, [])
-
-                if hasattr(zproc, "rlimit"):
-                    succeed_or_zombie_p_exc(zproc.rlimit, psutil.RLIMIT_NOFILE)
-                    succeed_or_zombie_p_exc(zproc.rlimit, psutil.RLIMIT_NOFILE,
-                                            (5, 5))
-                # set methods
-                succeed_or_zombie_p_exc(zproc.parent)
-                if hasattr(zproc, 'cpu_affinity'):
-                    succeed_or_zombie_p_exc(zproc.cpu_affinity, [0])
-                succeed_or_zombie_p_exc(zproc.nice, 0)
-                if hasattr(zproc, 'ionice'):
-                    if LINUX:
-                        succeed_or_zombie_p_exc(zproc.ionice, 2, 0)
-                    else:
-                        succeed_or_zombie_p_exc(zproc.ionice, 0)  # Windows
-                if hasattr(zproc, 'rlimit'):
-                    succeed_or_zombie_p_exc(zproc.rlimit,
-                                            psutil.RLIMIT_NOFILE, (5, 5))
-                succeed_or_zombie_p_exc(zproc.suspend)
-                succeed_or_zombie_p_exc(zproc.resume)
-                succeed_or_zombie_p_exc(zproc.terminate)
-                succeed_or_zombie_p_exc(zproc.kill)
-
-                # ...its parent should 'see' it
-                # edit: not true on BSD and OSX
-                # descendants = [x.pid for x in psutil.Process().children(
-                #                recursive=True)]
-                # self.assertIn(zpid, descendants)
-                # XXX should we also assume ppid be usable?  Note: this
-                # would be an important use case as the only way to get
-                # rid of a zombie is to kill its parent.
-                # self.assertEqual(zpid.ppid(), os.getpid())
-                # ...and all other APIs should be able to deal with it
-                self.assertTrue(psutil.pid_exists(zpid))
-                self.assertIn(zpid, psutil.pids())
-                self.assertIn(zpid, [x.pid for x in psutil.process_iter()])
-                psutil._pmap = {}
-                self.assertIn(zpid, [x.pid for x in psutil.process_iter()])
-            finally:
-                reap_children(recursive=True)
-
-    def test_pid_0(self):
-        # Process(0) is supposed to work on all platforms except Linux
-        if 0 not in psutil.pids() and not OPENBSD:
-            self.assertRaises(psutil.NoSuchProcess, psutil.Process, 0)
-            return
-
-        p = psutil.Process(0)
-        self.assertTrue(p.name())
-
-        if POSIX:
-            try:
-                self.assertEqual(p.uids().real, 0)
-                self.assertEqual(p.gids().real, 0)
-            except psutil.AccessDenied:
-                pass
-
-            self.assertRaisesRegex(
-                ValueError, "preventing sending signal to process with PID 0",
-                p.send_signal, signal.SIGTERM)
-
-        self.assertIn(p.ppid(), (0, 1))
-        # self.assertEqual(p.exe(), "")
-        p.cmdline()
-        try:
-            p.num_threads()
-        except psutil.AccessDenied:
-            pass
-
-        try:
-            p.memory_info()
-        except psutil.AccessDenied:
-            pass
-
-        try:
-            if POSIX:
-                self.assertEqual(p.username(), 'root')
-            elif WINDOWS:
-                self.assertEqual(p.username(), 'NT AUTHORITY\\SYSTEM')
-            else:
-                p.username()
-        except psutil.AccessDenied:
-            pass
-
-        p.as_dict()
-
-        if not OPENBSD:
-            self.assertIn(0, psutil.pids())
-            self.assertTrue(psutil.pid_exists(0))
-
-    def test_Popen(self):
-        # Popen class test
-        # XXX this test causes a ResourceWarning on Python 3 because
-        # psutil.__subproc instance doesn't get propertly freed.
-        # Not sure what to do though.
-        cmd = [PYTHON, "-c", "import time; time.sleep(60);"]
-        proc = psutil.Popen(cmd, stdout=subprocess.PIPE,
-                            stderr=subprocess.PIPE)
-        try:
-            proc.name()
-            proc.stdin
-            self.assertTrue(hasattr(proc, 'name'))
-            self.assertTrue(hasattr(proc, 'stdin'))
-            self.assertTrue(dir(proc))
-            self.assertRaises(AttributeError, getattr, proc, 'foo')
-        finally:
-            proc.kill()
-            proc.wait()
-            self.assertIsNotNone(proc.returncode)
-
-    @unittest.skipUnless(hasattr(psutil.Process, "environ"),
-                         "environ not available")
-    def test_environ(self):
-        self.maxDiff = None
-        p = psutil.Process()
-        d = p.environ()
-        d2 = os.environ.copy()
-
-        removes = []
-        if OSX:
-            removes.extend([
-                "__CF_USER_TEXT_ENCODING",
-                "VERSIONER_PYTHON_PREFER_32_BIT",
-                "VERSIONER_PYTHON_VERSION"])
-        if LINUX or OSX:
-            removes.extend(['PLAT'])
-        if TOX:
-            removes.extend(['HOME'])
-        for key in removes:
-            d.pop(key, None)
-            d2.pop(key, None)
-
-        self.assertEqual(d, d2)
-
-    @unittest.skipUnless(hasattr(psutil.Process, "environ"),
-                         "environ not available")
-    @unittest.skipUnless(POSIX, "posix only")
-    def test_weird_environ(self):
-        # environment variables can contain values without an equals sign
-        code = textwrap.dedent("""
-        #include <unistd.h>
-        #include <fcntl.h>
-        char * const argv[] = {"cat", 0};
-        char * const envp[] = {"A=1", "X", "C=3", 0};
-        int main(void) {
-            /* Close stderr on exec so parent can wait for the execve to
-             * finish. */
-            if (fcntl(2, F_SETFD, FD_CLOEXEC) != 0)
-                return 0;
-            return execve("/bin/cat", argv, envp);
-        }
-        """)
-        path = create_temp_executable_file("x", c_code=code)
-        self.addCleanup(safe_remove, path)
-        sproc = get_test_subprocess([path],
-                                    stdin=subprocess.PIPE,
-                                    stderr=subprocess.PIPE)
-        p = psutil.Process(sproc.pid)
-        wait_for_pid(p.pid)
-        self.assertTrue(p.is_running())
-        # Wait for process to exec or exit.
-        self.assertEqual(sproc.stderr.read(), b"")
-        self.assertEqual(p.environ(), {"A": "1", "C": "3"})
-        sproc.communicate()
-        self.assertEqual(sproc.returncode, 0)
-
-
-# ===================================================================
-# --- Featch all processes test
-# ===================================================================
-
-class TestFetchAllProcesses(unittest.TestCase):
-    """Test which iterates over all running processes and performs
-    some sanity checks against Process API's returned values.
-    """
-
-    def setUp(self):
-        if POSIX:
-            import pwd
-            pall = pwd.getpwall()
-            self._uids = set([x.pw_uid for x in pall])
-            self._usernames = set([x.pw_name for x in pall])
-
-    def test_fetch_all(self):
-        valid_procs = 0
-        excluded_names = set([
-            'send_signal', 'suspend', 'resume', 'terminate', 'kill', 'wait',
-            'as_dict', 'cpu_percent', 'parent', 'children', 'pid',
-            'memory_info_ex',
-        ])
-        if LINUX and not RLIMIT_SUPPORT:
-            excluded_names.add('rlimit')
-        attrs = []
-        for name in dir(psutil.Process):
-            if name.startswith("_"):
-                continue
-            if name in excluded_names:
-                continue
-            attrs.append(name)
-
-        default = object()
-        failures = []
-        for name in attrs:
-            for p in psutil.process_iter():
-                ret = default
-                try:
-                    try:
-                        args = ()
-                        attr = getattr(p, name, None)
-                        if attr is not None and callable(attr):
-                            if name == 'rlimit':
-                                args = (psutil.RLIMIT_NOFILE,)
-                            ret = attr(*args)
-                        else:
-                            ret = attr
-                        valid_procs += 1
-                    except NotImplementedError:
-                        msg = "%r was skipped because not implemented" % (
-                            self.__class__.__name__ + '.test_' + name)
-                        warn(msg)
-                    except (psutil.NoSuchProcess, psutil.AccessDenied) as err:
-                        self.assertEqual(err.pid, p.pid)
-                        if err.name:
-                            # make sure exception's name attr is set
-                            # with the actual process name
-                            self.assertEqual(err.name, p.name())
-                        self.assertTrue(str(err))
-                        self.assertTrue(err.msg)
-                    else:
-                        if ret not in (0, 0.0, [], None, '', {}):
-                            assert ret, ret
-                        meth = getattr(self, name)
-                        meth(ret, p)
-                except Exception as err:
-                    s = '\n' + '=' * 70 + '\n'
-                    s += "FAIL: test_%s (proc=%s" % (name, p)
-                    if ret != default:
-                        s += ", ret=%s)" % repr(ret)
-                    s += ')\n'
-                    s += '-' * 70
-                    s += "\n%s" % traceback.format_exc()
-                    s = "\n".join((" " * 4) + i for i in s.splitlines())
-                    s += '\n'
-                    failures.append(s)
-                    break
-
-        if failures:
-            self.fail(''.join(failures))
-
-        # we should always have a non-empty list, not including PID 0 etc.
-        # special cases.
-        self.assertTrue(valid_procs > 0)
-
-    def cmdline(self, ret, proc):
-        pass
-
-    def exe(self, ret, proc):
-        if not ret:
-            self.assertEqual(ret, '')
-        else:
-            assert os.path.isabs(ret), ret
-            # Note: os.stat() may return False even if the file is there
-            # hence we skip the test, see:
-            # http://stackoverflow.com/questions/3112546/os-path-exists-lies
-            if POSIX and os.path.isfile(ret):
-                if hasattr(os, 'access') and hasattr(os, "X_OK"):
-                    # XXX may fail on OSX
-                    self.assertTrue(os.access(ret, os.X_OK))
-
-    def ppid(self, ret, proc):
-        self.assertTrue(ret >= 0)
-
-    def name(self, ret, proc):
-        self.assertIsInstance(ret, (str, unicode))
-        self.assertTrue(ret)
-
-    def create_time(self, ret, proc):
-        try:
-            self.assertGreaterEqual(ret, 0)
-        except AssertionError:
-            if OPENBSD and proc.status == psutil.STATUS_ZOMBIE:
-                pass
-            else:
-                raise
-        # this can't be taken for granted on all platforms
-        # self.assertGreaterEqual(ret, psutil.boot_time())
-        # make sure returned value can be pretty printed
-        # with strftime
-        time.strftime("%Y %m %d %H:%M:%S", time.localtime(ret))
-
-    def uids(self, ret, proc):
-        for uid in ret:
-            self.assertTrue(uid >= 0)
-            self.assertIn(uid, self._uids)
-
-    def gids(self, ret, proc):
-        # note: testing all gids as above seems not to be reliable for
-        # gid == 30 (nodoby); not sure why.
-        for gid in ret:
-            self.assertTrue(gid >= 0)
-            # self.assertIn(uid, self.gids
-
-    def username(self, ret, proc):
-        self.assertTrue(ret)
-        if POSIX:
-            self.assertIn(ret, self._usernames)
-
-    def status(self, ret, proc):
-        self.assertTrue(ret != "")
-        self.assertTrue(ret != '?')
-        self.assertIn(ret, VALID_PROC_STATUSES)
-
-    def io_counters(self, ret, proc):
-        for field in ret:
-            if field != -1:
-                self.assertTrue(field >= 0)
-
-    def ionice(self, ret, proc):
-        if LINUX:
-            self.assertTrue(ret.ioclass >= 0)
-            self.assertTrue(ret.value >= 0)
-        else:
-            self.assertTrue(ret >= 0)
-            self.assertIn(ret, (0, 1, 2))
-
-    def num_threads(self, ret, proc):
-        self.assertTrue(ret >= 1)
-
-    def threads(self, ret, proc):
-        for t in ret:
-            self.assertTrue(t.id >= 0)
-            self.assertTrue(t.user_time >= 0)
-            self.assertTrue(t.system_time >= 0)
-
-    def cpu_times(self, ret, proc):
-        self.assertTrue(ret.user >= 0)
-        self.assertTrue(ret.system >= 0)
-
-    def memory_info(self, ret, proc):
-        for name in ret._fields:
-            self.assertGreaterEqual(getattr(ret, name), 0)
-        if POSIX and ret.vms != 0:
-            # VMS is always supposed to be the highest
-            for name in ret._fields:
-                if name != 'vms':
-                    value = getattr(ret, name)
-                    assert ret.vms > value, ret
-        elif WINDOWS:
-            assert ret.peak_wset >= ret.wset, ret
-            assert ret.peak_paged_pool >= ret.paged_pool, ret
-            assert ret.peak_nonpaged_pool >= ret.nonpaged_pool, ret
-            assert ret.peak_pagefile >= ret.pagefile, ret
-
-    def memory_full_info(self, ret, proc):
-        for name in ret._fields:
-            self.assertGreaterEqual(getattr(ret, name), 0)
-        if LINUX:
-            self.assertGreaterEqual(ret.pss, ret.uss)
-
-    def open_files(self, ret, proc):
-        for f in ret:
-            if WINDOWS:
-                assert f.fd == -1, f
-            else:
-                self.assertIsInstance(f.fd, int)
-            if LINUX:
-                self.assertIsInstance(f.position, int)
-                self.assertGreaterEqual(f.position, 0)
-                self.assertIn(f.mode, ('r', 'w', 'a', 'r+', 'a+'))
-                self.assertGreater(f.flags, 0)
-            if BSD and not f.path:
-                # XXX see: https://github.com/giampaolo/psutil/issues/595
-                continue
-            assert os.path.isabs(f.path), f
-            assert os.path.isfile(f.path), f
-
-    def num_fds(self, ret, proc):
-        self.assertTrue(ret >= 0)
-
-    def connections(self, ret, proc):
-        self.assertEqual(len(ret), len(set(ret)))
-        for conn in ret:
-            check_connection_ntuple(conn)
-
-    def cwd(self, ret, proc):
-        if ret is not None:  # BSD may return None
-            assert os.path.isabs(ret), ret
-            try:
-                st = os.stat(ret)
-            except OSError as err:
-                # directory has been removed in mean time
-                if err.errno != errno.ENOENT:
-                    raise
-            else:
-                self.assertTrue(stat.S_ISDIR(st.st_mode))
-
-    def memory_percent(self, ret, proc):
-        assert 0 <= ret <= 100, ret
-
-    def is_running(self, ret, proc):
-        self.assertTrue(ret)
-
-    def cpu_affinity(self, ret, proc):
-        assert ret != [], ret
-
-    def terminal(self, ret, proc):
-        if ret is not None:
-            assert os.path.isabs(ret), ret
-            assert os.path.exists(ret), ret
-
-    def memory_maps(self, ret, proc):
-        for nt in ret:
-            for fname in nt._fields:
-                value = getattr(nt, fname)
-                if fname == 'path':
-                    if not value.startswith('['):
-                        assert os.path.isabs(nt.path), nt.path
-                        # commented as on Linux we might get
-                        # '/foo/bar (deleted)'
-                        # assert os.path.exists(nt.path), nt.path
-                elif fname in ('addr', 'perms'):
-                    self.assertTrue(value)
-                else:
-                    self.assertIsInstance(value, (int, long))
-                    assert value >= 0, value
-
-    def num_handles(self, ret, proc):
-        if WINDOWS:
-            self.assertGreaterEqual(ret, 0)
-        else:
-            self.assertGreaterEqual(ret, 0)
-
-    def nice(self, ret, proc):
-        if POSIX:
-            assert -20 <= ret <= 20, ret
-        else:
-            priorities = [getattr(psutil, x) for x in dir(psutil)
-                          if x.endswith('_PRIORITY_CLASS')]
-            self.assertIn(ret, priorities)
-
-    def num_ctx_switches(self, ret, proc):
-        self.assertGreaterEqual(ret.voluntary, 0)
-        self.assertGreaterEqual(ret.involuntary, 0)
-
-    def rlimit(self, ret, proc):
-        self.assertEqual(len(ret), 2)
-        self.assertGreaterEqual(ret[0], -1)
-        self.assertGreaterEqual(ret[1], -1)
-
-    def environ(self, ret, proc):
-        self.assertIsInstance(ret, dict)
-
-
-# ===================================================================
-# --- Limited user tests
-# ===================================================================
-
-if POSIX and os.getuid() == 0:
-    class LimitedUserTestCase(TestProcess):
-        """Repeat the previous tests by using a limited user.
-        Executed only on UNIX and only if the user who run the test script
-        is root.
-        """
-        # the uid/gid the test suite runs under
-        if hasattr(os, 'getuid'):
-            PROCESS_UID = os.getuid()
-            PROCESS_GID = os.getgid()
-
-        def __init__(self, *args, **kwargs):
-            TestProcess.__init__(self, *args, **kwargs)
-            # re-define all existent test methods in order to
-            # ignore AccessDenied exceptions
-            for attr in [x for x in dir(self) if x.startswith('test')]:
-                meth = getattr(self, attr)
-
-                def test_(self):
-                    try:
-                        meth()
-                    except psutil.AccessDenied:
-                        pass
-                setattr(self, attr, types.MethodType(test_, self))
-
-        def setUp(self):
-            safe_remove(TESTFN)
-            TestProcess.setUp(self)
-            os.setegid(1000)
-            os.seteuid(1000)
-
-        def tearDown(self):
-            os.setegid(self.PROCESS_UID)
-            os.seteuid(self.PROCESS_GID)
-            TestProcess.tearDown(self)
-
-        def test_nice(self):
-            try:
-                psutil.Process().nice(-1)
-            except psutil.AccessDenied:
-                pass
-            else:
-                self.fail("exception not raised")
-
-        def test_zombie_process(self):
-            # causes problems if test test suite is run as root
-            pass
-
-
-# ===================================================================
-# --- Unicode tests
-# ===================================================================
-
-class TestUnicode(unittest.TestCase):
-    # See: https://github.com/giampaolo/psutil/issues/655
-
-    @classmethod
-    def setUpClass(cls):
-        cls.uexe = create_temp_executable_file('è')
-        cls.ubasename = os.path.basename(cls.uexe)
-        assert 'è' in cls.ubasename
-
-    @classmethod
-    def tearDownClass(cls):
-        if not APPVEYOR:
-            safe_remove(cls.uexe)
-
-    def setUp(self):
-        reap_children()
-
-    tearDown = setUp
-
-    def test_proc_exe(self):
-        subp = get_test_subprocess(cmd=[self.uexe])
-        p = psutil.Process(subp.pid)
-        self.assertIsInstance(p.name(), str)
-        self.assertEqual(os.path.basename(p.name()), self.ubasename)
-
-    def test_proc_name(self):
-        subp = get_test_subprocess(cmd=[self.uexe])
-        if WINDOWS:
-            from psutil._pswindows import py2_strencode
-            name = py2_strencode(psutil._psplatform.cext.proc_name(subp.pid))
-        else:
-            name = psutil.Process(subp.pid).name()
-        self.assertEqual(name, self.ubasename)
-
-    def test_proc_cmdline(self):
-        subp = get_test_subprocess(cmd=[self.uexe])
-        p = psutil.Process(subp.pid)
-        self.assertIsInstance("".join(p.cmdline()), str)
-        self.assertEqual(p.cmdline(), [self.uexe])
-
-    def test_proc_cwd(self):
-        tdir = os.path.realpath(tempfile.mkdtemp(prefix="psutil-è-"))
-        self.addCleanup(safe_rmdir, tdir)
-        with chdir(tdir):
-            p = psutil.Process()
-            self.assertIsInstance(p.cwd(), str)
-            self.assertEqual(p.cwd(), tdir)
-
-    @unittest.skipIf(APPVEYOR, "")
-    def test_proc_open_files(self):
-        p = psutil.Process()
-        start = set(p.open_files())
-        with open(self.uexe, 'rb'):
-            new = set(p.open_files())
-        path = (new - start).pop().path
-        if BSD and not path:
-            # XXX
-            # see https://github.com/giampaolo/psutil/issues/595
-            self.skipTest("open_files on BSD is broken")
-        self.assertIsInstance(path, str)
-        self.assertEqual(os.path.normcase(path), os.path.normcase(self.uexe))
-
-    @unittest.skipUnless(hasattr(psutil.Process, "environ"),
-                         "environ not available")
-    def test_proc_environ(self):
-        env = os.environ.copy()
-        env['FUNNY_ARG'] = self.uexe
-        sproc = get_test_subprocess(env=env)
-        p = psutil.Process(sproc.pid)
-        if WINDOWS and not PY3:
-            uexe = self.uexe.decode(sys.getfilesystemencoding())
-        else:
-            uexe = self.uexe
-        self.assertEqual(p.environ()['FUNNY_ARG'], uexe)
-
-    def test_disk_usage(self):
-        path = tempfile.mkdtemp(prefix='psutil', suffix='è')
-        psutil.disk_usage(path)
-
-
-class TestNonUnicode(unittest.TestCase):
-    """Test handling of non-utf8 data."""
-
-    @classmethod
-    def setUpClass(cls):
-        if PY3:
-            # Fix around https://bugs.python.org/issue24230
-            cls.temp_directory = tempfile.mkdtemp().encode('utf8')
-        else:
-            cls.temp_directory = tempfile.mkdtemp(suffix=b"")
-
-        # Return an executable that runs until we close its stdin.
-        if WINDOWS:
-            cls.test_executable = which("cmd.exe")
-        else:
-            cls.test_executable = which("cat")
-
-    @classmethod
-    def tearDownClass(cls):
-        shutil.rmtree(cls.temp_directory, ignore_errors=True)
-
-    def setUp(self):
-        reap_children()
-
-    tearDown = setUp
-
-    def copy_file(self, src, dst):
-        # A wrapper around shutil.copy() which is broken on py < 3.4
-        # when passed bytes paths.
-        with open(src, 'rb') as input_:
-            with open(dst, 'wb') as output:
-                output.write(input_.read())
-        shutil.copymode(src, dst)
-
-    def test_proc_exe(self):
-        funny_executable = os.path.join(self.temp_directory, b"\xc0\x80")
-        self.copy_file(self.test_executable, funny_executable)
-        self.addCleanup(safe_remove, funny_executable)
-        subp = get_test_subprocess(cmd=[decode_path(funny_executable)],
-                                   stdin=subprocess.PIPE,
-                                   stdout=subprocess.PIPE,
-                                   stderr=subprocess.STDOUT)
-        p = psutil.Process(subp.pid)
-        self.assertIsInstance(p.exe(), str)
-        self.assertEqual(encode_path(os.path.basename(p.exe())), b"\xc0\x80")
-        subp.communicate()
-        self.assertEqual(subp.returncode, 0)
-
-    def test_proc_name(self):
-        funny_executable = os.path.join(self.temp_directory, b"\xc0\x80")
-        self.copy_file(self.test_executable, funny_executable)
-        self.addCleanup(safe_remove, funny_executable)
-        subp = get_test_subprocess(cmd=[decode_path(funny_executable)],
-                                   stdin=subprocess.PIPE,
-                                   stdout=subprocess.PIPE,
-                                   stderr=subprocess.STDOUT)
-        p = psutil.Process(subp.pid)
-        self.assertEqual(encode_path(os.path.basename(p.name())), b"\xc0\x80")
-        subp.communicate()
-        self.assertEqual(subp.returncode, 0)
-
-    def test_proc_cmdline(self):
-        funny_executable = os.path.join(self.temp_directory, b"\xc0\x80")
-        self.copy_file(self.test_executable, funny_executable)
-        self.addCleanup(safe_remove, funny_executable)
-        subp = get_test_subprocess(cmd=[decode_path(funny_executable)],
-                                   stdin=subprocess.PIPE,
-                                   stdout=subprocess.PIPE,
-                                   stderr=subprocess.STDOUT)
-        p = psutil.Process(subp.pid)
-        self.assertEqual(p.cmdline(), [decode_path(funny_executable)])
-        subp.communicate()
-        self.assertEqual(subp.returncode, 0)
-
-    def test_proc_cwd(self):
-        funny_directory = os.path.realpath(
-            os.path.join(self.temp_directory, b"\xc0\x80"))
-        os.mkdir(funny_directory)
-        self.addCleanup(safe_rmdir, funny_directory)
-        with chdir(funny_directory):
-            p = psutil.Process()
-            self.assertIsInstance(p.cwd(), str)
-            self.assertEqual(encode_path(p.cwd()), funny_directory)
-
-    @unittest.skipIf(WINDOWS, "does not work on windows")
-    def test_proc_open_files(self):
-        funny_file = os.path.join(self.temp_directory, b"\xc0\x80")
-        p = psutil.Process()
-        start = set(p.open_files())
-        with open(funny_file, 'wb'):
-            new = set(p.open_files())
-        path = (new - start).pop().path
-        if BSD and not path:
-            # XXX
-            # see https://github.com/giampaolo/psutil/issues/595
-            self.skipTest("open_files on BSD is broken")
-        self.assertIsInstance(path, str)
-        self.assertIn(funny_file, encode_path(path))
-
-    @unittest.skipUnless(hasattr(psutil.Process, "environ"),
-                         "environ not available")
-    def test_proc_environ(self):
-        env = os.environ.copy()
-        funny_path = self.temp_directory
-        # ...otherwise subprocess.Popen fails with TypeError (it
-        # wants a string)
-        env['FUNNY_ARG'] = \
-            decode_path(funny_path) if WINDOWS and PY3 else funny_path
-        sproc = get_test_subprocess(env=env)
-        p = psutil.Process(sproc.pid)
-        self.assertEqual(
-            encode_path(p.environ()['FUNNY_ARG']), funny_path)
-
-    def test_disk_usage(self):
-        funny_directory = os.path.realpath(
-            os.path.join(self.temp_directory, b"\xc0\x80"))
-        os.mkdir(funny_directory)
-        self.addCleanup(safe_rmdir, funny_directory)
-        if WINDOWS and PY3:
-            # Python 3 on Windows is moving towards accepting unicode
-            # paths only:
-            # http://bugs.python.org/issue26330
-            funny_directory = decode_path(funny_directory)
-        psutil.disk_usage(funny_directory)
-
-
-if __name__ == '__main__':
-    run_test_module_by_name(__file__)
diff --git a/psutil/tests/test_sunos.py b/psutil/tests/test_sunos.py
deleted file mode 100644
index 2afc8776e9..0000000000
--- a/psutil/tests/test_sunos.py
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Sun OS specific tests."""
-
-import os
-
-import psutil
-from psutil import SUNOS
-from psutil.tests import run_test_module_by_name
-from psutil.tests import sh
-from psutil.tests import unittest
-
-
-@unittest.skipUnless(SUNOS, "not a SunOS system")
-class SunOSSpecificTestCase(unittest.TestCase):
-
-    def test_swap_memory(self):
-        out = sh('env PATH=/usr/sbin:/sbin:%s swap -l' % os.environ['PATH'])
-        lines = out.strip().split('\n')[1:]
-        if not lines:
-            raise ValueError('no swap device(s) configured')
-        total = free = 0
-        for line in lines:
-            line = line.split()
-            t, f = line[-2:]
-            total += int(int(t) * 512)
-            free += int(int(f) * 512)
-        used = total - free
-
-        psutil_swap = psutil.swap_memory()
-        self.assertEqual(psutil_swap.total, total)
-        self.assertEqual(psutil_swap.used, used)
-        self.assertEqual(psutil_swap.free, free)
-
-
-if __name__ == '__main__':
-    run_test_module_by_name(__file__)
diff --git a/psutil/tests/test_system.py b/psutil/tests/test_system.py
deleted file mode 100644
index f5c9abd65d..0000000000
--- a/psutil/tests/test_system.py
+++ /dev/null
@@ -1,692 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Tests for system APIS."""
-
-import contextlib
-import datetime
-import errno
-import os
-import pprint
-import shutil
-import signal
-import socket
-import sys
-import tempfile
-import time
-
-import psutil
-from psutil import BSD
-from psutil import FREEBSD
-from psutil import LINUX
-from psutil import NETBSD
-from psutil import OPENBSD
-from psutil import OSX
-from psutil import POSIX
-from psutil import SUNOS
-from psutil import WINDOWS
-from psutil._compat import long
-from psutil.tests import AF_INET6
-from psutil.tests import APPVEYOR
-from psutil.tests import check_net_address
-from psutil.tests import DEVNULL
-from psutil.tests import enum
-from psutil.tests import get_test_subprocess
-from psutil.tests import mock
-from psutil.tests import reap_children
-from psutil.tests import retry_before_failing
-from psutil.tests import run_test_module_by_name
-from psutil.tests import safe_remove
-from psutil.tests import safe_rmdir
-from psutil.tests import skip_on_access_denied
-from psutil.tests import TESTFN
-from psutil.tests import TESTFN_UNICODE
-from psutil.tests import TRAVIS
-from psutil.tests import unittest
-
-
-# ===================================================================
-# --- System-related API tests
-# ===================================================================
-
-
-class TestSystemAPIs(unittest.TestCase):
-    """Tests for system-related APIs."""
-
-    def setUp(self):
-        safe_remove(TESTFN)
-
-    def tearDown(self):
-        reap_children()
-
-    def test_process_iter(self):
-        self.assertIn(os.getpid(), [x.pid for x in psutil.process_iter()])
-        sproc = get_test_subprocess()
-        self.assertIn(sproc.pid, [x.pid for x in psutil.process_iter()])
-        p = psutil.Process(sproc.pid)
-        p.kill()
-        p.wait()
-        self.assertNotIn(sproc.pid, [x.pid for x in psutil.process_iter()])
-
-        with mock.patch('psutil.Process',
-                        side_effect=psutil.NoSuchProcess(os.getpid())):
-            self.assertEqual(list(psutil.process_iter()), [])
-        with mock.patch('psutil.Process',
-                        side_effect=psutil.AccessDenied(os.getpid())):
-            with self.assertRaises(psutil.AccessDenied):
-                list(psutil.process_iter())
-
-    def test_wait_procs(self):
-        def callback(p):
-            l.append(p.pid)
-
-        l = []
-        sproc1 = get_test_subprocess()
-        sproc2 = get_test_subprocess()
-        sproc3 = get_test_subprocess()
-        procs = [psutil.Process(x.pid) for x in (sproc1, sproc2, sproc3)]
-        self.assertRaises(ValueError, psutil.wait_procs, procs, timeout=-1)
-        self.assertRaises(TypeError, psutil.wait_procs, procs, callback=1)
-        t = time.time()
-        gone, alive = psutil.wait_procs(procs, timeout=0.01, callback=callback)
-
-        self.assertLess(time.time() - t, 0.5)
-        self.assertEqual(gone, [])
-        self.assertEqual(len(alive), 3)
-        self.assertEqual(l, [])
-        for p in alive:
-            self.assertFalse(hasattr(p, 'returncode'))
-
-        @retry_before_failing(30)
-        def test(procs, callback):
-            gone, alive = psutil.wait_procs(procs, timeout=0.03,
-                                            callback=callback)
-            self.assertEqual(len(gone), 1)
-            self.assertEqual(len(alive), 2)
-            return gone, alive
-
-        sproc3.terminate()
-        gone, alive = test(procs, callback)
-        self.assertIn(sproc3.pid, [x.pid for x in gone])
-        if POSIX:
-            self.assertEqual(gone.pop().returncode, signal.SIGTERM)
-        else:
-            self.assertEqual(gone.pop().returncode, 1)
-        self.assertEqual(l, [sproc3.pid])
-        for p in alive:
-            self.assertFalse(hasattr(p, 'returncode'))
-
-        @retry_before_failing(30)
-        def test(procs, callback):
-            gone, alive = psutil.wait_procs(procs, timeout=0.03,
-                                            callback=callback)
-            self.assertEqual(len(gone), 3)
-            self.assertEqual(len(alive), 0)
-            return gone, alive
-
-        sproc1.terminate()
-        sproc2.terminate()
-        gone, alive = test(procs, callback)
-        self.assertEqual(set(l), set([sproc1.pid, sproc2.pid, sproc3.pid]))
-        for p in gone:
-            self.assertTrue(hasattr(p, 'returncode'))
-
-    def test_wait_procs_no_timeout(self):
-        sproc1 = get_test_subprocess()
-        sproc2 = get_test_subprocess()
-        sproc3 = get_test_subprocess()
-        procs = [psutil.Process(x.pid) for x in (sproc1, sproc2, sproc3)]
-        for p in procs:
-            p.terminate()
-        gone, alive = psutil.wait_procs(procs)
-
-    def test_boot_time(self):
-        bt = psutil.boot_time()
-        self.assertIsInstance(bt, float)
-        self.assertGreater(bt, 0)
-        self.assertLess(bt, time.time())
-
-    @unittest.skipUnless(POSIX, 'posix only')
-    def test_PAGESIZE(self):
-        # pagesize is used internally to perform different calculations
-        # and it's determined by using SC_PAGE_SIZE; make sure
-        # getpagesize() returns the same value.
-        import resource
-        self.assertEqual(os.sysconf("SC_PAGE_SIZE"), resource.getpagesize())
-
-    def test_virtual_memory(self):
-        mem = psutil.virtual_memory()
-        assert mem.total > 0, mem
-        assert mem.available > 0, mem
-        assert 0 <= mem.percent <= 100, mem
-        assert mem.used > 0, mem
-        assert mem.free >= 0, mem
-        for name in mem._fields:
-            value = getattr(mem, name)
-            if name != 'percent':
-                self.assertIsInstance(value, (int, long))
-            if name != 'total':
-                if not value >= 0:
-                    self.fail("%r < 0 (%s)" % (name, value))
-                if value > mem.total:
-                    self.fail("%r > total (total=%s, %s=%s)"
-                              % (name, mem.total, name, value))
-
-    def test_swap_memory(self):
-        mem = psutil.swap_memory()
-        assert mem.total >= 0, mem
-        assert mem.used >= 0, mem
-        if mem.total > 0:
-            # likely a system with no swap partition
-            assert mem.free > 0, mem
-        else:
-            assert mem.free == 0, mem
-        assert 0 <= mem.percent <= 100, mem
-        assert mem.sin >= 0, mem
-        assert mem.sout >= 0, mem
-
-    def test_pid_exists(self):
-        sproc = get_test_subprocess(wait=True)
-        self.assertTrue(psutil.pid_exists(sproc.pid))
-        p = psutil.Process(sproc.pid)
-        p.kill()
-        p.wait()
-        self.assertFalse(psutil.pid_exists(sproc.pid))
-        self.assertFalse(psutil.pid_exists(-1))
-        self.assertEqual(psutil.pid_exists(0), 0 in psutil.pids())
-        # pid 0
-        psutil.pid_exists(0) == 0 in psutil.pids()
-
-    def test_pid_exists_2(self):
-        reap_children()
-        pids = psutil.pids()
-        for pid in pids:
-            try:
-                assert psutil.pid_exists(pid)
-            except AssertionError:
-                # in case the process disappeared in meantime fail only
-                # if it is no longer in psutil.pids()
-                time.sleep(.1)
-                if pid in psutil.pids():
-                    self.fail(pid)
-        pids = range(max(pids) + 5000, max(pids) + 6000)
-        for pid in pids:
-            self.assertFalse(psutil.pid_exists(pid), msg=pid)
-
-    def test_pids(self):
-        plist = [x.pid for x in psutil.process_iter()]
-        pidlist = psutil.pids()
-        self.assertEqual(plist.sort(), pidlist.sort())
-        # make sure every pid is unique
-        self.assertEqual(len(pidlist), len(set(pidlist)))
-
-    def test_test(self):
-        # test for psutil.test() function
-        stdout = sys.stdout
-        sys.stdout = DEVNULL
-        try:
-            psutil.test()
-        finally:
-            sys.stdout = stdout
-
-    def test_cpu_count(self):
-        logical = psutil.cpu_count()
-        self.assertEqual(logical, len(psutil.cpu_times(percpu=True)))
-        self.assertGreaterEqual(logical, 1)
-        #
-        if os.path.exists("/proc/cpuinfo"):
-            with open("/proc/cpuinfo") as fd:
-                cpuinfo_data = fd.read()
-            if "physical id" not in cpuinfo_data:
-                raise unittest.SkipTest("cpuinfo doesn't include physical id")
-        physical = psutil.cpu_count(logical=False)
-        self.assertGreaterEqual(physical, 1)
-        self.assertGreaterEqual(logical, physical)
-
-    def test_cpu_times(self):
-        # Check type, value >= 0, str().
-        total = 0
-        times = psutil.cpu_times()
-        sum(times)
-        for cp_time in times:
-            self.assertIsInstance(cp_time, float)
-            self.assertGreaterEqual(cp_time, 0.0)
-            total += cp_time
-        self.assertEqual(total, sum(times))
-        str(times)
-        # CPU times are always supposed to increase over time
-        # or at least remain the same and that's because time
-        # cannot go backwards.
-        # Surprisingly sometimes this might not be the case (at
-        # least on Windows and Linux), see:
-        # https://github.com/giampaolo/psutil/issues/392
-        # https://github.com/giampaolo/psutil/issues/645
-        # if not WINDOWS:
-        #     last = psutil.cpu_times()
-        #     for x in range(100):
-        #         new = psutil.cpu_times()
-        #         for field in new._fields:
-        #             new_t = getattr(new, field)
-        #             last_t = getattr(last, field)
-        #             self.assertGreaterEqual(new_t, last_t,
-        #                                     msg="%s %s" % (new_t, last_t))
-        #         last = new
-
-    def test_cpu_times_time_increases(self):
-        # Make sure time increases between calls.
-        t1 = sum(psutil.cpu_times())
-        time.sleep(0.1)
-        t2 = sum(psutil.cpu_times())
-        difference = t2 - t1
-        if not difference >= 0.05:
-            self.fail("difference %s" % difference)
-
-    def test_per_cpu_times(self):
-        # Check type, value >= 0, str().
-        for times in psutil.cpu_times(percpu=True):
-            total = 0
-            sum(times)
-            for cp_time in times:
-                self.assertIsInstance(cp_time, float)
-                self.assertGreaterEqual(cp_time, 0.0)
-                total += cp_time
-            self.assertEqual(total, sum(times))
-            str(times)
-        self.assertEqual(len(psutil.cpu_times(percpu=True)[0]),
-                         len(psutil.cpu_times(percpu=False)))
-
-        # Note: in theory CPU times are always supposed to increase over
-        # time or remain the same but never go backwards. In practice
-        # sometimes this is not the case.
-        # This issue seemd to be afflict Windows:
-        # https://github.com/giampaolo/psutil/issues/392
-        # ...but it turns out also Linux (rarely) behaves the same.
-        # last = psutil.cpu_times(percpu=True)
-        # for x in range(100):
-        #     new = psutil.cpu_times(percpu=True)
-        #     for index in range(len(new)):
-        #         newcpu = new[index]
-        #         lastcpu = last[index]
-        #         for field in newcpu._fields:
-        #             new_t = getattr(newcpu, field)
-        #             last_t = getattr(lastcpu, field)
-        #             self.assertGreaterEqual(
-        #                 new_t, last_t, msg="%s %s" % (lastcpu, newcpu))
-        #     last = new
-
-    def test_per_cpu_times_2(self):
-        # Simulate some work load then make sure time have increased
-        # between calls.
-        tot1 = psutil.cpu_times(percpu=True)
-        stop_at = time.time() + 0.1
-        while True:
-            if time.time() >= stop_at:
-                break
-        tot2 = psutil.cpu_times(percpu=True)
-        for t1, t2 in zip(tot1, tot2):
-            t1, t2 = sum(t1), sum(t2)
-            difference = t2 - t1
-            if difference >= 0.05:
-                return
-        self.fail()
-
-    def test_cpu_times_comparison(self):
-        # Make sure the sum of all per cpu times is almost equal to
-        # base "one cpu" times.
-        base = psutil.cpu_times()
-        per_cpu = psutil.cpu_times(percpu=True)
-        summed_values = base._make([sum(num) for num in zip(*per_cpu)])
-        for field in base._fields:
-            self.assertAlmostEqual(
-                getattr(base, field), getattr(summed_values, field), delta=1)
-
-    def _test_cpu_percent(self, percent, last_ret, new_ret):
-        try:
-            self.assertIsInstance(percent, float)
-            self.assertGreaterEqual(percent, 0.0)
-            self.assertIsNot(percent, -0.0)
-            self.assertLessEqual(percent, 100.0 * psutil.cpu_count())
-        except AssertionError as err:
-            raise AssertionError("\n%s\nlast=%s\nnew=%s" % (
-                err, pprint.pformat(last_ret), pprint.pformat(new_ret)))
-
-    def test_cpu_percent(self):
-        last = psutil.cpu_percent(interval=0.001)
-        for x in range(100):
-            new = psutil.cpu_percent(interval=None)
-            self._test_cpu_percent(new, last, new)
-            last = new
-
-    def test_per_cpu_percent(self):
-        last = psutil.cpu_percent(interval=0.001, percpu=True)
-        self.assertEqual(len(last), psutil.cpu_count())
-        for x in range(100):
-            new = psutil.cpu_percent(interval=None, percpu=True)
-            for percent in new:
-                self._test_cpu_percent(percent, last, new)
-            last = new
-
-    def test_cpu_times_percent(self):
-        last = psutil.cpu_times_percent(interval=0.001)
-        for x in range(100):
-            new = psutil.cpu_times_percent(interval=None)
-            for percent in new:
-                self._test_cpu_percent(percent, last, new)
-            self._test_cpu_percent(sum(new), last, new)
-            last = new
-
-    def test_per_cpu_times_percent(self):
-        last = psutil.cpu_times_percent(interval=0.001, percpu=True)
-        self.assertEqual(len(last), psutil.cpu_count())
-        for x in range(100):
-            new = psutil.cpu_times_percent(interval=None, percpu=True)
-            for cpu in new:
-                for percent in cpu:
-                    self._test_cpu_percent(percent, last, new)
-                self._test_cpu_percent(sum(cpu), last, new)
-            last = new
-
-    def test_per_cpu_times_percent_negative(self):
-        # see: https://github.com/giampaolo/psutil/issues/645
-        psutil.cpu_times_percent(percpu=True)
-        zero_times = [x._make([0 for x in range(len(x._fields))])
-                      for x in psutil.cpu_times(percpu=True)]
-        with mock.patch('psutil.cpu_times', return_value=zero_times):
-            for cpu in psutil.cpu_times_percent(percpu=True):
-                for percent in cpu:
-                    self._test_cpu_percent(percent, None, None)
-
-    @unittest.skipIf(POSIX and not hasattr(os, 'statvfs'),
-                     "os.statvfs() function not available on this platform")
-    def test_disk_usage(self):
-        usage = psutil.disk_usage(os.getcwd())
-        assert usage.total > 0, usage
-        assert usage.used > 0, usage
-        assert usage.free > 0, usage
-        assert usage.total > usage.used, usage
-        assert usage.total > usage.free, usage
-        assert 0 <= usage.percent <= 100, usage.percent
-        if hasattr(shutil, 'disk_usage'):
-            # py >= 3.3, see: http://bugs.python.org/issue12442
-            shutil_usage = shutil.disk_usage(os.getcwd())
-            tolerance = 5 * 1024 * 1024  # 5MB
-            self.assertEqual(usage.total, shutil_usage.total)
-            self.assertAlmostEqual(usage.free, shutil_usage.free,
-                                   delta=tolerance)
-            self.assertAlmostEqual(usage.used, shutil_usage.used,
-                                   delta=tolerance)
-
-        # if path does not exist OSError ENOENT is expected across
-        # all platforms
-        fname = tempfile.mktemp()
-        try:
-            psutil.disk_usage(fname)
-        except OSError as err:
-            if err.args[0] != errno.ENOENT:
-                raise
-        else:
-            self.fail("OSError not raised")
-
-    @unittest.skipIf(POSIX and not hasattr(os, 'statvfs'),
-                     "os.statvfs() function not available on this platform")
-    def test_disk_usage_unicode(self):
-        # see: https://github.com/giampaolo/psutil/issues/416
-        safe_rmdir(TESTFN_UNICODE)
-        self.addCleanup(safe_rmdir, TESTFN_UNICODE)
-        os.mkdir(TESTFN_UNICODE)
-        psutil.disk_usage(TESTFN_UNICODE)
-
-    @unittest.skipIf(POSIX and not hasattr(os, 'statvfs'),
-                     "os.statvfs() function not available on this platform")
-    @unittest.skipIf(LINUX and TRAVIS, "unknown failure on travis")
-    def test_disk_partitions(self):
-        # all = False
-        ls = psutil.disk_partitions(all=False)
-        # on travis we get:
-        #     self.assertEqual(p.cpu_affinity(), [n])
-        # AssertionError: Lists differ: [0, 1, 2, 3, 4, 5, 6, 7,... != [0]
-        self.assertTrue(ls, msg=ls)
-        for disk in ls:
-            if WINDOWS and 'cdrom' in disk.opts:
-                continue
-            if not POSIX:
-                assert os.path.exists(disk.device), disk
-            else:
-                # we cannot make any assumption about this, see:
-                # http://goo.gl/p9c43
-                disk.device
-            if SUNOS:
-                # on solaris apparently mount points can also be files
-                assert os.path.exists(disk.mountpoint), disk
-            else:
-                assert os.path.isdir(disk.mountpoint), disk
-            assert disk.fstype, disk
-            self.assertIsInstance(disk.opts, str)
-
-        # all = True
-        ls = psutil.disk_partitions(all=True)
-        self.assertTrue(ls, msg=ls)
-        for disk in psutil.disk_partitions(all=True):
-            if not WINDOWS:
-                try:
-                    os.stat(disk.mountpoint)
-                except OSError as err:
-                    if TRAVIS and OSX and err.errno == errno.EIO:
-                        continue
-                    # http://mail.python.org/pipermail/python-dev/
-                    #     2012-June/120787.html
-                    if err.errno not in (errno.EPERM, errno.EACCES):
-                        raise
-                else:
-                    if SUNOS:
-                        # on solaris apparently mount points can also be files
-                        assert os.path.exists(disk.mountpoint), disk
-                    else:
-                        assert os.path.isdir(disk.mountpoint), disk
-            self.assertIsInstance(disk.fstype, str)
-            self.assertIsInstance(disk.opts, str)
-
-        def find_mount_point(path):
-            path = os.path.abspath(path)
-            while not os.path.ismount(path):
-                path = os.path.dirname(path)
-            return path
-
-        mount = find_mount_point(__file__)
-        mounts = [x.mountpoint for x in psutil.disk_partitions(all=True)]
-        self.assertIn(mount, mounts)
-        psutil.disk_usage(mount)
-
-    @skip_on_access_denied()
-    def test_net_connections(self):
-        def check(cons, families, types_):
-            for conn in cons:
-                self.assertIn(conn.family, families, msg=conn)
-                if conn.family != getattr(socket, 'AF_UNIX', object()):
-                    self.assertIn(conn.type, types_, msg=conn)
-
-        from psutil._common import conn_tmap
-        for kind, groups in conn_tmap.items():
-            if SUNOS and kind == 'unix':
-                continue
-            families, types_ = groups
-            cons = psutil.net_connections(kind)
-            self.assertEqual(len(cons), len(set(cons)))
-            check(cons, families, types_)
-
-    def test_net_io_counters(self):
-        def check_ntuple(nt):
-            self.assertEqual(nt[0], nt.bytes_sent)
-            self.assertEqual(nt[1], nt.bytes_recv)
-            self.assertEqual(nt[2], nt.packets_sent)
-            self.assertEqual(nt[3], nt.packets_recv)
-            self.assertEqual(nt[4], nt.errin)
-            self.assertEqual(nt[5], nt.errout)
-            self.assertEqual(nt[6], nt.dropin)
-            self.assertEqual(nt[7], nt.dropout)
-            assert nt.bytes_sent >= 0, nt
-            assert nt.bytes_recv >= 0, nt
-            assert nt.packets_sent >= 0, nt
-            assert nt.packets_recv >= 0, nt
-            assert nt.errin >= 0, nt
-            assert nt.errout >= 0, nt
-            assert nt.dropin >= 0, nt
-            assert nt.dropout >= 0, nt
-
-        ret = psutil.net_io_counters(pernic=False)
-        check_ntuple(ret)
-        ret = psutil.net_io_counters(pernic=True)
-        self.assertNotEqual(ret, [])
-        for key in ret:
-            self.assertTrue(key)
-            check_ntuple(ret[key])
-
-    def test_net_if_addrs(self):
-        nics = psutil.net_if_addrs()
-        assert nics, nics
-
-        # Not reliable on all platforms (net_if_addrs() reports more
-        # interfaces).
-        # self.assertEqual(sorted(nics.keys()),
-        #                  sorted(psutil.net_io_counters(pernic=True).keys()))
-
-        families = set([socket.AF_INET, AF_INET6, psutil.AF_LINK])
-        for nic, addrs in nics.items():
-            self.assertEqual(len(set(addrs)), len(addrs))
-            for addr in addrs:
-                self.assertIsInstance(addr.family, int)
-                self.assertIsInstance(addr.address, str)
-                self.assertIsInstance(addr.netmask, (str, type(None)))
-                self.assertIsInstance(addr.broadcast, (str, type(None)))
-                self.assertIn(addr.family, families)
-                if sys.version_info >= (3, 4):
-                    self.assertIsInstance(addr.family, enum.IntEnum)
-                if addr.family == socket.AF_INET:
-                    s = socket.socket(addr.family)
-                    with contextlib.closing(s):
-                        s.bind((addr.address, 0))
-                elif addr.family == socket.AF_INET6:
-                    info = socket.getaddrinfo(
-                        addr.address, 0, socket.AF_INET6, socket.SOCK_STREAM,
-                        0, socket.AI_PASSIVE)[0]
-                    af, socktype, proto, canonname, sa = info
-                    s = socket.socket(af, socktype, proto)
-                    with contextlib.closing(s):
-                        s.bind(sa)
-                for ip in (addr.address, addr.netmask, addr.broadcast,
-                           addr.ptp):
-                    if ip is not None:
-                        # TODO: skip AF_INET6 for now because I get:
-                        # AddressValueError: Only hex digits permitted in
-                        # u'c6f3%lxcbr0' in u'fe80::c8e0:fff:fe54:c6f3%lxcbr0'
-                        if addr.family != AF_INET6:
-                            check_net_address(ip, addr.family)
-                # broadcast and ptp addresses are mutually exclusive
-                if addr.broadcast:
-                    self.assertIsNone(addr.ptp)
-                elif addr.ptp:
-                    self.assertIsNone(addr.broadcast)
-
-        if BSD or OSX or SUNOS:
-            if hasattr(socket, "AF_LINK"):
-                self.assertEqual(psutil.AF_LINK, socket.AF_LINK)
-        elif LINUX:
-            self.assertEqual(psutil.AF_LINK, socket.AF_PACKET)
-        elif WINDOWS:
-            self.assertEqual(psutil.AF_LINK, -1)
-
-    def test_net_if_addrs_mac_null_bytes(self):
-        # Simulate that the underlying C function returns an incomplete
-        # MAC address. psutil is supposed to fill it with null bytes.
-        # https://github.com/giampaolo/psutil/issues/786
-        if POSIX:
-            ret = [('em1', psutil.AF_LINK, '06:3d:29', None, None, None)]
-        else:
-            ret = [('em1', -1, '06-3d-29', None, None, None)]
-        with mock.patch('psutil._psplatform.net_if_addrs',
-                        return_value=ret) as m:
-            addr = psutil.net_if_addrs()['em1'][0]
-            assert m.called
-            if POSIX:
-                self.assertEqual(addr.address, '06:3d:29:00:00:00')
-            else:
-                self.assertEqual(addr.address, '06-3d-29-00-00-00')
-
-    @unittest.skipIf(TRAVIS, "EPERM on travis")
-    def test_net_if_stats(self):
-        nics = psutil.net_if_stats()
-        assert nics, nics
-        all_duplexes = (psutil.NIC_DUPLEX_FULL,
-                        psutil.NIC_DUPLEX_HALF,
-                        psutil.NIC_DUPLEX_UNKNOWN)
-        for nic, stats in nics.items():
-            isup, duplex, speed, mtu = stats
-            self.assertIsInstance(isup, bool)
-            self.assertIn(duplex, all_duplexes)
-            self.assertIn(duplex, all_duplexes)
-            self.assertGreaterEqual(speed, 0)
-            self.assertGreaterEqual(mtu, 0)
-
-    @unittest.skipIf(LINUX and not os.path.exists('/proc/diskstats'),
-                     '/proc/diskstats not available on this linux version')
-    @unittest.skipIf(APPVEYOR,
-                     "can't find any physical disk on Appveyor")
-    def test_disk_io_counters(self):
-        def check_ntuple(nt):
-            self.assertEqual(nt[0], nt.read_count)
-            self.assertEqual(nt[1], nt.write_count)
-            self.assertEqual(nt[2], nt.read_bytes)
-            self.assertEqual(nt[3], nt.write_bytes)
-            if not (OPENBSD or NETBSD):
-                self.assertEqual(nt[4], nt.read_time)
-                self.assertEqual(nt[5], nt.write_time)
-                if LINUX:
-                    self.assertEqual(nt[6], nt.read_merged_count)
-                    self.assertEqual(nt[7], nt.write_merged_count)
-                    self.assertEqual(nt[8], nt.busy_time)
-                elif FREEBSD:
-                    self.assertEqual(nt[6], nt.busy_time)
-            for name in nt._fields:
-                assert getattr(nt, name) >= 0, nt
-
-        ret = psutil.disk_io_counters(perdisk=False)
-        check_ntuple(ret)
-        ret = psutil.disk_io_counters(perdisk=True)
-        # make sure there are no duplicates
-        self.assertEqual(len(ret), len(set(ret)))
-        for key in ret:
-            assert key, key
-            check_ntuple(ret[key])
-            if LINUX and key[-1].isdigit():
-                # if 'sda1' is listed 'sda' shouldn't, see:
-                # https://github.com/giampaolo/psutil/issues/338
-                while key[-1].isdigit():
-                    key = key[:-1]
-                self.assertNotIn(key, ret.keys())
-
-    def test_users(self):
-        users = psutil.users()
-        if not APPVEYOR:
-            self.assertNotEqual(users, [])
-        for user in users:
-            assert user.name, user
-            user.terminal
-            user.host
-            assert user.started > 0.0, user
-            datetime.datetime.fromtimestamp(user.started)
-
-    def test_cpu_stats(self):
-        # Tested more extensively in per-platform test modules.
-        infos = psutil.cpu_stats()
-        for name in infos._fields:
-            value = getattr(infos, name)
-            self.assertGreaterEqual(value, 0)
-            if name in ('ctx_switches', 'interrupts'):
-                self.assertGreater(value, 0)
-
-
-if __name__ == '__main__':
-    run_test_module_by_name(__file__)
diff --git a/psutil/tests/test_windows.py b/psutil/tests/test_windows.py
deleted file mode 100644
index 962af74cdb..0000000000
--- a/psutil/tests/test_windows.py
+++ /dev/null
@@ -1,667 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: UTF-8 -*
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Windows specific tests."""
-
-import errno
-import glob
-import os
-import platform
-import signal
-import subprocess
-import sys
-import time
-import traceback
-
-try:
-    import wmi  # requires "pip install wmi"
-except ImportError:
-    wmi = None
-try:
-    import win32api  # requires "pip install pypiwin32"
-    import win32con
-except ImportError:
-    win32api = win32con = None
-
-import psutil
-from psutil import WINDOWS
-from psutil._compat import basestring
-from psutil._compat import callable
-from psutil._compat import long
-from psutil._compat import PY3
-from psutil.tests import APPVEYOR
-from psutil.tests import get_test_subprocess
-from psutil.tests import mock
-from psutil.tests import reap_children
-from psutil.tests import retry_before_failing
-from psutil.tests import run_test_module_by_name
-from psutil.tests import unittest
-
-
-cext = psutil._psplatform.cext
-
-# are we a 64 bit process
-IS_64_BIT = sys.maxsize > 2**32
-
-
-def wrap_exceptions(fun):
-    def wrapper(self, *args, **kwargs):
-        try:
-            return fun(self, *args, **kwargs)
-        except OSError as err:
-            from psutil._pswindows import ACCESS_DENIED_SET
-            if err.errno in ACCESS_DENIED_SET:
-                raise psutil.AccessDenied(None, None)
-            if err.errno == errno.ESRCH:
-                raise psutil.NoSuchProcess(None, None)
-            raise
-    return wrapper
-
-
-@unittest.skipUnless(WINDOWS, "not a Windows system")
-class WindowsSpecificTestCase(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        cls.pid = get_test_subprocess().pid
-
-    @classmethod
-    def tearDownClass(cls):
-        reap_children()
-
-    def test_issue_24(self):
-        p = psutil.Process(0)
-        self.assertRaises(psutil.AccessDenied, p.kill)
-
-    def test_special_pid(self):
-        p = psutil.Process(4)
-        self.assertEqual(p.name(), 'System')
-        # use __str__ to access all common Process properties to check
-        # that nothing strange happens
-        str(p)
-        p.username()
-        self.assertTrue(p.create_time() >= 0.0)
-        try:
-            rss, vms = p.memory_info()[:2]
-        except psutil.AccessDenied:
-            # expected on Windows Vista and Windows 7
-            if not platform.uname()[1] in ('vista', 'win-7', 'win7'):
-                raise
-        else:
-            self.assertTrue(rss > 0)
-
-    def test_send_signal(self):
-        p = psutil.Process(self.pid)
-        self.assertRaises(ValueError, p.send_signal, signal.SIGINT)
-
-    def test_nic_names(self):
-        p = subprocess.Popen(['ipconfig', '/all'], stdout=subprocess.PIPE)
-        out = p.communicate()[0]
-        if PY3:
-            out = str(out, sys.stdout.encoding or sys.getfilesystemencoding())
-        nics = psutil.net_io_counters(pernic=True).keys()
-        for nic in nics:
-            if "pseudo-interface" in nic.replace(' ', '-').lower():
-                continue
-            if nic not in out:
-                self.fail(
-                    "%r nic wasn't found in 'ipconfig /all' output" % nic)
-
-    def test_exe(self):
-        for p in psutil.process_iter():
-            try:
-                self.assertEqual(os.path.basename(p.exe()), p.name())
-            except psutil.Error:
-                pass
-
-    # --- Process class tests
-
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    def test_process_name(self):
-        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
-        p = psutil.Process(self.pid)
-        self.assertEqual(p.name(), w.Caption)
-
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    def test_process_exe(self):
-        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
-        p = psutil.Process(self.pid)
-        # Note: wmi reports the exe as a lower case string.
-        # Being Windows paths case-insensitive we ignore that.
-        self.assertEqual(p.exe().lower(), w.ExecutablePath.lower())
-
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    def test_process_cmdline(self):
-        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
-        p = psutil.Process(self.pid)
-        self.assertEqual(' '.join(p.cmdline()),
-                         w.CommandLine.replace('"', ''))
-
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    def test_process_username(self):
-        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
-        p = psutil.Process(self.pid)
-        domain, _, username = w.GetOwner()
-        username = "%s\\%s" % (domain, username)
-        self.assertEqual(p.username(), username)
-
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    def test_process_rss_memory(self):
-        time.sleep(0.1)
-        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
-        p = psutil.Process(self.pid)
-        rss = p.memory_info().rss
-        self.assertEqual(rss, int(w.WorkingSetSize))
-
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    def test_process_vms_memory(self):
-        time.sleep(0.1)
-        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
-        p = psutil.Process(self.pid)
-        vms = p.memory_info().vms
-        # http://msdn.microsoft.com/en-us/library/aa394372(VS.85).aspx
-        # ...claims that PageFileUsage is represented in Kilo
-        # bytes but funnily enough on certain platforms bytes are
-        # returned instead.
-        wmi_usage = int(w.PageFileUsage)
-        if (vms != wmi_usage) and (vms != wmi_usage * 1024):
-            self.fail("wmi=%s, psutil=%s" % (wmi_usage, vms))
-
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    def test_process_create_time(self):
-        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
-        p = psutil.Process(self.pid)
-        wmic_create = str(w.CreationDate.split('.')[0])
-        psutil_create = time.strftime("%Y%m%d%H%M%S",
-                                      time.localtime(p.create_time()))
-        self.assertEqual(wmic_create, psutil_create)
-
-    # --- psutil namespace functions and constants tests
-
-    @unittest.skipUnless('NUMBER_OF_PROCESSORS' in os.environ,
-                         'NUMBER_OF_PROCESSORS env var is not available')
-    def test_cpu_count(self):
-        num_cpus = int(os.environ['NUMBER_OF_PROCESSORS'])
-        self.assertEqual(num_cpus, psutil.cpu_count())
-
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    def test_total_phymem(self):
-        w = wmi.WMI().Win32_ComputerSystem()[0]
-        self.assertEqual(int(w.TotalPhysicalMemory),
-                         psutil.virtual_memory().total)
-
-    # @unittest.skipIf(wmi is None, "wmi module is not installed")
-    # def test__UPTIME(self):
-    #     # _UPTIME constant is not public but it is used internally
-    #     # as value to return for pid 0 creation time.
-    #     # WMI behaves the same.
-    #     w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
-    #     p = psutil.Process(0)
-    #     wmic_create = str(w.CreationDate.split('.')[0])
-    #     psutil_create = time.strftime("%Y%m%d%H%M%S",
-    #                                   time.localtime(p.create_time()))
-    #
-
-    # Note: this test is not very reliable
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    @unittest.skipIf(APPVEYOR, "test not relieable on appveyor")
-    def test_pids(self):
-        # Note: this test might fail if the OS is starting/killing
-        # other processes in the meantime
-        w = wmi.WMI().Win32_Process()
-        wmi_pids = set([x.ProcessId for x in w])
-        psutil_pids = set(psutil.pids())
-        self.assertEqual(wmi_pids, psutil_pids)
-
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    @retry_before_failing()
-    def test_disks(self):
-        ps_parts = psutil.disk_partitions(all=True)
-        wmi_parts = wmi.WMI().Win32_LogicalDisk()
-        for ps_part in ps_parts:
-            for wmi_part in wmi_parts:
-                if ps_part.device.replace('\\', '') == wmi_part.DeviceID:
-                    if not ps_part.mountpoint:
-                        # this is usually a CD-ROM with no disk inserted
-                        break
-                    try:
-                        usage = psutil.disk_usage(ps_part.mountpoint)
-                    except OSError as err:
-                        if err.errno == errno.ENOENT:
-                            # usually this is the floppy
-                            break
-                        else:
-                            raise
-                    self.assertEqual(usage.total, int(wmi_part.Size))
-                    wmi_free = int(wmi_part.FreeSpace)
-                    self.assertEqual(usage.free, wmi_free)
-                    # 10 MB tollerance
-                    if abs(usage.free - wmi_free) > 10 * 1024 * 1024:
-                        self.fail("psutil=%s, wmi=%s" % (
-                            usage.free, wmi_free))
-                    break
-            else:
-                self.fail("can't find partition %s" % repr(ps_part))
-
-    @unittest.skipIf(win32api is None, "pywin32 module is not installed")
-    def test_num_handles(self):
-        p = psutil.Process(os.getpid())
-        before = p.num_handles()
-        handle = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION,
-                                      win32con.FALSE, os.getpid())
-        after = p.num_handles()
-        self.assertEqual(after, before + 1)
-        win32api.CloseHandle(handle)
-        self.assertEqual(p.num_handles(), before)
-
-    @unittest.skipIf(win32api is None, "pywin32 module is not installed")
-    def test_num_handles_2(self):
-        # Note: this fails from time to time; I'm keen on thinking
-        # it doesn't mean something is broken
-        def call(p, attr):
-            attr = getattr(p, name, None)
-            if attr is not None and callable(attr):
-                attr()
-            else:
-                attr
-
-        p = psutil.Process(self.pid)
-        failures = []
-        for name in dir(psutil.Process):
-            if name.startswith('_') \
-                or name in ('terminate', 'kill', 'suspend', 'resume',
-                            'nice', 'send_signal', 'wait', 'children',
-                            'as_dict'):
-                continue
-            else:
-                try:
-                    call(p, name)
-                    num1 = p.num_handles()
-                    call(p, name)
-                    num2 = p.num_handles()
-                except (psutil.NoSuchProcess, psutil.AccessDenied):
-                    pass
-                else:
-                    if num2 > num1:
-                        fail = \
-                            "failure while processing Process.%s method " \
-                            "(before=%s, after=%s)" % (name, num1, num2)
-                        failures.append(fail)
-        if failures:
-            self.fail('\n' + '\n'.join(failures))
-
-    def test_name_always_available(self):
-        # On Windows name() is never supposed to raise AccessDenied,
-        # see https://github.com/giampaolo/psutil/issues/627
-        for p in psutil.process_iter():
-            try:
-                p.name()
-            except psutil.NoSuchProcess:
-                pass
-
-    @unittest.skipUnless(sys.version_info >= (2, 7),
-                         "CTRL_* signals not supported")
-    def test_ctrl_signals(self):
-        p = psutil.Process(get_test_subprocess().pid)
-        p.send_signal(signal.CTRL_C_EVENT)
-        p.send_signal(signal.CTRL_BREAK_EVENT)
-        p.kill()
-        p.wait()
-        self.assertRaises(psutil.NoSuchProcess,
-                          p.send_signal, signal.CTRL_C_EVENT)
-        self.assertRaises(psutil.NoSuchProcess,
-                          p.send_signal, signal.CTRL_BREAK_EVENT)
-
-    @unittest.skipIf(wmi is None, "wmi module is not installed")
-    def test_net_if_stats(self):
-        ps_names = set(cext.net_if_stats())
-        wmi_adapters = wmi.WMI().Win32_NetworkAdapter()
-        wmi_names = set()
-        for wmi_adapter in wmi_adapters:
-            wmi_names.add(wmi_adapter.Name)
-            wmi_names.add(wmi_adapter.NetConnectionID)
-        self.assertTrue(ps_names & wmi_names,
-                        "no common entries in %s, %s" % (ps_names, wmi_names))
-
-
-@unittest.skipUnless(WINDOWS, "not a Windows system")
-class TestDualProcessImplementation(unittest.TestCase):
-    """
-    Certain APIs on Windows have 2 internal implementations, one
-    based on documented Windows APIs, another one based
-    NtQuerySystemInformation() which gets called as fallback in
-    case the first fails because of limited permission error.
-    Here we test that the two methods return the exact same value,
-    see:
-    https://github.com/giampaolo/psutil/issues/304
-    """
-
-    fun_names = [
-        # function name, tolerance
-        ('proc_cpu_times', 0.2),
-        ('proc_create_time', 0.5),
-        ('proc_num_handles', 1),  # 1 because impl #1 opens a handle
-        ('proc_memory_info', 1024),  # KB
-        ('proc_io_counters', 0),
-    ]
-
-    def test_compare_values(self):
-        def assert_ge_0(obj):
-            if isinstance(obj, tuple):
-                for value in obj:
-                    self.assertGreaterEqual(value, 0, msg=obj)
-            elif isinstance(obj, (int, long, float)):
-                self.assertGreaterEqual(obj, 0)
-            else:
-                assert 0  # case not handled which needs to be fixed
-
-        def compare_with_tolerance(ret1, ret2, tolerance):
-            if ret1 == ret2:
-                return
-            else:
-                if isinstance(ret2, (int, long, float)):
-                    diff = abs(ret1 - ret2)
-                    self.assertLessEqual(diff, tolerance)
-                elif isinstance(ret2, tuple):
-                    for a, b in zip(ret1, ret2):
-                        diff = abs(a - b)
-                        self.assertLessEqual(diff, tolerance)
-
-        from psutil._pswindows import ntpinfo
-        failures = []
-        for p in psutil.process_iter():
-            try:
-                nt = ntpinfo(*cext.proc_info(p.pid))
-            except psutil.NoSuchProcess:
-                continue
-            assert_ge_0(nt)
-
-            for name, tolerance in self.fun_names:
-                if name == 'proc_memory_info' and p.pid == os.getpid():
-                    continue
-                if name == 'proc_create_time' and p.pid in (0, 4):
-                    continue
-                meth = wrap_exceptions(getattr(cext, name))
-                try:
-                    ret = meth(p.pid)
-                except (psutil.NoSuchProcess, psutil.AccessDenied):
-                    continue
-                # compare values
-                try:
-                    if name == 'proc_cpu_times':
-                        compare_with_tolerance(ret[0], nt.user_time, tolerance)
-                        compare_with_tolerance(ret[1],
-                                               nt.kernel_time, tolerance)
-                    elif name == 'proc_create_time':
-                        compare_with_tolerance(ret, nt.create_time, tolerance)
-                    elif name == 'proc_num_handles':
-                        compare_with_tolerance(ret, nt.num_handles, tolerance)
-                    elif name == 'proc_io_counters':
-                        compare_with_tolerance(ret[0], nt.io_rcount, tolerance)
-                        compare_with_tolerance(ret[1], nt.io_wcount, tolerance)
-                        compare_with_tolerance(ret[2], nt.io_rbytes, tolerance)
-                        compare_with_tolerance(ret[3], nt.io_wbytes, tolerance)
-                    elif name == 'proc_memory_info':
-                        try:
-                            rawtupl = cext.proc_memory_info_2(p.pid)
-                        except psutil.NoSuchProcess:
-                            continue
-                        compare_with_tolerance(ret, rawtupl, tolerance)
-                except AssertionError:
-                    trace = traceback.format_exc()
-                    msg = '%s\npid=%s, method=%r, ret_1=%r, ret_2=%r' % (
-                        trace, p.pid, name, ret, nt)
-                    failures.append(msg)
-                    break
-
-        if failures:
-            self.fail('\n\n'.join(failures))
-
-    # ---
-    # same tests as above but mimicks the AccessDenied failure of
-    # the first (fast) method failing with AD.
-    # TODO: currently does not take tolerance into account.
-
-    def test_name(self):
-        name = psutil.Process().name()
-        with mock.patch("psutil._psplatform.cext.proc_exe",
-                        side_effect=psutil.AccessDenied(os.getpid())) as fun:
-            psutil.Process().name() == name
-            assert fun.called
-
-    def test_memory_info(self):
-        mem = psutil.Process().memory_info()
-        with mock.patch("psutil._psplatform.cext.proc_memory_info",
-                        side_effect=OSError(errno.EPERM, "msg")) as fun:
-            psutil.Process().memory_info() == mem
-            assert fun.called
-
-    def test_create_time(self):
-        ctime = psutil.Process().create_time()
-        with mock.patch("psutil._psplatform.cext.proc_create_time",
-                        side_effect=OSError(errno.EPERM, "msg")) as fun:
-            psutil.Process().create_time() == ctime
-            assert fun.called
-
-    def test_cpu_times(self):
-        cpu_times = psutil.Process().cpu_times()
-        with mock.patch("psutil._psplatform.cext.proc_cpu_times",
-                        side_effect=OSError(errno.EPERM, "msg")) as fun:
-            psutil.Process().cpu_times() == cpu_times
-            assert fun.called
-
-    def test_io_counters(self):
-        io_counters = psutil.Process().io_counters()
-        with mock.patch("psutil._psplatform.cext.proc_io_counters",
-                        side_effect=OSError(errno.EPERM, "msg")) as fun:
-            psutil.Process().io_counters() == io_counters
-            assert fun.called
-
-    def test_num_handles(self):
-        io_counters = psutil.Process().io_counters()
-        with mock.patch("psutil._psplatform.cext.proc_io_counters",
-                        side_effect=OSError(errno.EPERM, "msg")) as fun:
-            psutil.Process().io_counters() == io_counters
-            assert fun.called
-
-    # --- other tests
-
-    def test_compare_name_exe(self):
-        for p in psutil.process_iter():
-            try:
-                a = os.path.basename(p.exe())
-                b = p.name()
-            except (psutil.NoSuchProcess, psutil.AccessDenied):
-                pass
-            else:
-                self.assertEqual(a, b)
-
-    def test_zombies(self):
-        # test that NPS is raised by the 2nd implementation in case a
-        # process no longer exists
-        ZOMBIE_PID = max(psutil.pids()) + 5000
-        for name, _ in self.fun_names:
-            meth = wrap_exceptions(getattr(cext, name))
-            self.assertRaises(psutil.NoSuchProcess, meth, ZOMBIE_PID)
-
-
-@unittest.skipUnless(WINDOWS, "not a Windows system")
-class RemoteProcessTestCase(unittest.TestCase):
-    """Certain functions require calling ReadProcessMemory.  This trivially
-    works when called on the current process.  Check that this works on other
-    processes, especially when they have a different bitness."""
-
-    @staticmethod
-    def find_other_interpreter():
-        # find a python interpreter that is of the opposite bitness from us
-        code = "import sys; sys.stdout.write(str(sys.maxsize > 2**32))"
-
-        # XXX: a different and probably more stable approach might be to access
-        # the registry but accessing 64 bit paths from a 32 bit process
-        for filename in glob.glob(r"C:\Python*\python.exe"):
-            proc = subprocess.Popen(args=[filename, "-c", code],
-                                    stdout=subprocess.PIPE,
-                                    stderr=subprocess.STDOUT)
-            output, _ = proc.communicate()
-            if output == str(not IS_64_BIT):
-                return filename
-
-    @classmethod
-    def setUpClass(cls):
-        other_python = cls.find_other_interpreter()
-
-        if other_python is None:
-            raise unittest.SkipTest(
-                "could not find interpreter with opposite bitness")
-
-        if IS_64_BIT:
-            cls.python64 = sys.executable
-            cls.python32 = other_python
-        else:
-            cls.python64 = other_python
-            cls.python32 = sys.executable
-
-    test_args = ["-c", "import sys; sys.stdin.read()"]
-
-    def setUp(self):
-        env = os.environ.copy()
-        env["THINK_OF_A_NUMBER"] = str(os.getpid())
-        self.proc32 = get_test_subprocess([self.python32] + self.test_args,
-                                          env=env,
-                                          stdin=subprocess.PIPE)
-        self.proc64 = get_test_subprocess([self.python64] + self.test_args,
-                                          env=env,
-                                          stdin=subprocess.PIPE)
-
-    def tearDown(self):
-        self.proc32.communicate()
-        self.proc64.communicate()
-        reap_children()
-
-    @classmethod
-    def tearDownClass(cls):
-        reap_children()
-
-    def test_cmdline_32(self):
-        p = psutil.Process(self.proc32.pid)
-        self.assertEqual(len(p.cmdline()), 3)
-        self.assertEqual(p.cmdline()[1:], self.test_args)
-
-    def test_cmdline_64(self):
-        p = psutil.Process(self.proc64.pid)
-        self.assertEqual(len(p.cmdline()), 3)
-        self.assertEqual(p.cmdline()[1:], self.test_args)
-
-    def test_cwd_32(self):
-        p = psutil.Process(self.proc32.pid)
-        self.assertEqual(p.cwd(), os.getcwd())
-
-    def test_cwd_64(self):
-        p = psutil.Process(self.proc64.pid)
-        self.assertEqual(p.cwd(), os.getcwd())
-
-    def test_environ_32(self):
-        p = psutil.Process(self.proc32.pid)
-        e = p.environ()
-        self.assertIn("THINK_OF_A_NUMBER", e)
-        self.assertEquals(e["THINK_OF_A_NUMBER"], str(os.getpid()))
-
-    def test_environ_64(self):
-        p = psutil.Process(self.proc64.pid)
-        e = p.environ()
-        self.assertIn("THINK_OF_A_NUMBER", e)
-        self.assertEquals(e["THINK_OF_A_NUMBER"], str(os.getpid()))
-
-
-@unittest.skipUnless(WINDOWS, "not a Windows system")
-class TestServices(unittest.TestCase):
-
-    def test_win_service_iter(self):
-        valid_statuses = set([
-            "running",
-            "paused",
-            "start",
-            "pause",
-            "continue",
-            "stop",
-            "stopped",
-        ])
-        valid_start_types = set([
-            "automatic",
-            "manual",
-            "disabled",
-        ])
-        valid_statuses = set([
-            "running",
-            "paused",
-            "start_pending",
-            "pause_pending",
-            "continue_pending",
-            "stop_pending",
-            "stopped"
-        ])
-        for serv in psutil.win_service_iter():
-            data = serv.as_dict()
-            self.assertIsInstance(data['name'], basestring)
-            self.assertNotEqual(data['name'].strip(), "")
-            self.assertIsInstance(data['display_name'], basestring)
-            self.assertIsInstance(data['username'], basestring)
-            self.assertIn(data['status'], valid_statuses)
-            if data['pid'] is not None:
-                psutil.Process(data['pid'])
-            self.assertIsInstance(data['binpath'], basestring)
-            self.assertIsInstance(data['username'], basestring)
-            self.assertIsInstance(data['start_type'], basestring)
-            self.assertIn(data['start_type'], valid_start_types)
-            self.assertIn(data['status'], valid_statuses)
-            self.assertIsInstance(data['description'], basestring)
-            pid = serv.pid()
-            if pid is not None:
-                p = psutil.Process(pid)
-                self.assertTrue(p.is_running())
-            # win_service_get
-            s = psutil.win_service_get(serv.name())
-            # test __eq__
-            self.assertEqual(serv, s)
-
-    def test_win_service_get(self):
-        name = next(psutil.win_service_iter()).name()
-
-        with self.assertRaises(psutil.NoSuchProcess) as cm:
-            psutil.win_service_get(name + '???')
-        self.assertEqual(cm.exception.name, name + '???')
-
-        # test NoSuchProcess
-        service = psutil.win_service_get(name)
-        exc = WindowsError(
-            psutil._psplatform.cext.ERROR_SERVICE_DOES_NOT_EXIST, "")
-        with mock.patch("psutil._psplatform.cext.winservice_query_status",
-                        side_effect=exc):
-            self.assertRaises(psutil.NoSuchProcess, service.status)
-        with mock.patch("psutil._psplatform.cext.winservice_query_config",
-                        side_effect=exc):
-            self.assertRaises(psutil.NoSuchProcess, service.username)
-
-        # test AccessDenied
-        exc = WindowsError(
-            psutil._psplatform.cext.ERROR_ACCESS_DENIED, "")
-        with mock.patch("psutil._psplatform.cext.winservice_query_status",
-                        side_effect=exc):
-            self.assertRaises(psutil.AccessDenied, service.status)
-        with mock.patch("psutil._psplatform.cext.winservice_query_config",
-                        side_effect=exc):
-            self.assertRaises(psutil.AccessDenied, service.username)
-
-        # test __str__ and __repr__
-        self.assertIn(service.name(), str(service))
-        self.assertIn(service.display_name(), str(service))
-        self.assertIn(service.name(), repr(service))
-        self.assertIn(service.display_name(), repr(service))
-
-
-if __name__ == '__main__':
-    run_test_module_by_name(__file__)
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000000..4c1f8e852b
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,313 @@
+[build-system]
+build-backend = "setuptools.build_meta"
+requires = ["setuptools>=75.3.4"]  # latest version supporting Python 3.8
+
+[dependency-groups]
+# Dev-only deps (PEP 735), not part of the published package
+# metadata. Install with `pip install --group <name>` or the
+# `make install-pydeps-*` targets.
+build = [
+    "setuptools>=75.3.4",  # latest version supporting Python 3.8
+]
+test = [
+    # BSD VMs have no git
+    "psleak @ git+https://github.com/giampaolo/psleak@master ; platform_system not in 'FreeBSD OpenBSD NetBSD'",
+    "psleak @ https://github.com/giampaolo/psleak/archive/refs/heads/master.tar.gz ; platform_system in 'FreeBSD OpenBSD NetBSD'",
+    "pytest ; python_version < '3.10'",
+    "pytest-instafail",
+    "pytest-xdist",
+    "pytest>=9 ; python_version >= '3.10'",
+    "pywin32 ; os_name == 'nt' and implementation_name != 'pypy'",
+    "wmi ; os_name == 'nt' and implementation_name != 'pypy'",
+    {include-group = "build"},
+]
+lint = [
+    "black",
+    "rstwrap",
+    "ruff",
+    "sphinx-lint",
+    "toml-sort",
+]
+dev = [
+    "abi3audit",
+    "check-manifest",
+    "colorama ; os_name == 'nt'",
+    "coverage",
+    "packaging",
+    "pylint",  # not enforced
+    "pyperf",
+    "pypinfo",
+    "pyreadline3 ; os_name == 'nt'",
+    "pytest-cov",
+    "requests",
+    "twine",
+    "validate-pyproject[all]",
+    "virtualenv",
+    "vulture",
+    "wheel",
+    {include-group = "build"},
+    {include-group = "lint"},
+    {include-group = "test"},
+]
+docs = [
+    "ablog==0.11.13",
+    "matplotlib==3.10.8",
+    "sphinx-autobuild",
+    "sphinx-codeautolink==0.18.1",
+    "sphinx-last-updated-by-git==0.3.8",
+    "sphinx-notfound-page==1.1.0",
+    "sphinx-sitemap==2.9.0",
+    "sphinx==9.1.0",
+    "sphinx_copybutton==0.5.2",
+    "sphinx_design==0.7.0",
+    "sphinxext-opengraph==0.13.0",
+]
+
+[tool.black]
+target-version = ["py38"]
+line-length = 79
+skip-string-normalization = true
+preview = true
+enable-unstable-feature = ["hug_parens_with_braces_and_square_brackets", "string_processing", "wrap_long_dict_values_in_parens"]
+
+[tool.check-manifest]
+ignore = ["docs", "docs/**"]
+
+[tool.ruff]
+# https://beta.ruff.rs/docs/settings/
+target-version = "py38"
+line-length = 79
+output-prefer-rule-codes = true
+
+[tool.ruff.lint]
+preview = true
+extend-safe-fixes = [
+    "PLR6201",  # turn `1 in (1, 2)` into `1 in {1, 2}`
+]
+select = [
+    # To get a list of all values: `python3 -m ruff linter`.
+    "ALL",
+    "D200",  # [*] One-line docstring should fit on one line
+    "D204",  # [*] 1 blank line required after class docstring
+    "D209",  # [*] Multi-line docstring closing quotes should be on a separate line
+    "D212",  # [*] Multi-line docstring summary should start at the first line
+    "D301",  # Use `r"""` if any backslashes in a docstring
+    "D403",  # [*] First word of the first line should be capitalized
+    "PERF102",  # [*] When using only the keys of a dict use the `keys()` method
+    "PERF401",  # Use a list comprehension to create a transformed list
+    "S113",  # Probable use of requests call without timeout
+    "S602",  # `subprocess` call with `shell=True` identified, security issue
+]
+ignore = [
+    "A",  # flake8-builtins (shadowing of builtins like all, any, ...)
+    "ANN",  # flake8-annotations
+    "ARG001",  # unused-function-argument
+    "ARG002",  # unused-method-argument
+    "B007",  # Loop control variable `x` not used within loop body
+    "C408",  # Unnecessary dict() call
+    "C90",  # mccabe (function `X` is too complex)
+    "COM812",  # Trailing comma missing
+    "D",  # pydocstyle
+    "DOC",  # various docstring warnings
+    "DTZ",  # flake8-datetimez
+    "ERA001",  # Found commented-out code
+    "FBT",  # flake8-boolean-trap (makes zero sense)
+    "FIX",  # Line contains TODO / XXX / ..., consider resolving the issue
+    "FLY002",  # static-join-to-f-string / Consider {expression} instead of string join
+    "FURB101",  # `open` and `read` should be replaced by `Path(src).read_text()`
+    "FURB103",  # `open` and `write` should be replaced by `Path(src).write_text()`
+    "FURB116",  # [*] Replace `hex` call with `f"{start:x}"`
+    "FURB118",  # [*] Use `operator.add` instead of defining a lambda
+    "FURB140",  # [*] Use `itertools.starmap` instead of the generator
+    "INP",  # flake8-no-pep420
+    "N801",  # Class name `async_chat` should use CapWords convention (ASYNCORE COMPAT)
+    "N802",  # Function name X should be lowercase.
+    "N806",  # Variable X in function should be lowercase.
+    "N818",  # Exception name `FooBar` should be named with an Error suffix
+    "PERF",  # Perflint
+    "PLC0415",  # `import` should be at the top-level of a file
+    "PLC2701",  # Private name import `x` from external module `y`
+    "PLR0904",  # Too many public methods (x > y)
+    "PLR0911",  # Too many return statements (8 > 6)
+    "PLR0912",  # Too many branches (x > y)
+    "PLR0913",  # Too many arguments in function definition (x > y)
+    "PLR0914",  # Too many local variables (x/y)
+    "PLR0915",  # Too many statements (x > y)
+    "PLR0917",  # Too many positional arguments (x/y)
+    "PLR1702",  # Too many nested blocks (x > y)
+    "PLR1704",  # Redefining argument with the local name `type_`
+    "PLR2004",  # Magic value used in comparison, consider replacing X with a constant variable
+    "PLR6301",  # Method `x` could be a function, class method, or static method
+    "PLW0603",  # Using the global statement to update `lineno` is discouraged
+    "PLW0717",  # Try clause contains too many statements (6 > 5)
+    "PLW1514",  # `open` in text mode without explicit `encoding` argument
+    "PLW2901",  # `for` loop variable `x` overwritten by assignment target
+    "PT028",  # pytest-parameter-with-default-argument
+    "PTH",  # flake8-use-pathlib
+    "PYI",  # flake8-pyi (python types stuff)
+    "Q000",  # Single quotes found but double quotes preferred
+    "RET502",  # Do not implicitly `return None` in function able to return non-`None` value
+    "RET503",  # Missing explicit `return` at the end of function able to return non-`None` value
+    "RET504",  # Unnecessary assignment to `result` before `return` statement
+    "RET505",  # [*] Unnecessary `else` after `return` statement
+    "RUF005",  # Consider iterable unpacking instead of concatenation
+    "RUF012",  # Mutable class attributes should be annotated with `typing.ClassVar`
+    "RUF022",  # `__all__` is not sorted
+    "RUF028",  # This suppression comment is invalid
+    "RUF031",  # [*] Avoid parentheses for tuples in subscripts
+    "RUF067",  # `__init__` module should only contain docstrings and re-exports
+    "RUF105",  # `noqa` comment used instead of `ruff: ignore`
+    "S",  # flake8-bandit
+    "SIM102",  # Use a single `if` statement instead of nested `if` statements
+    "SIM105",  # Use `contextlib.suppress(OSError)` instead of `try`-`except`-`pass`
+    "SIM117",  # Use a single `with` statement with multiple contexts instead of nested `with` statements
+    "SLF",  # flake8-self
+    "TD",  # all TODOs, XXXs, etc.
+    "TRY300",  # Consider moving this statement to an `else` block
+    "TRY301",  # Abstract `raise` to an inner function
+    "UP032",  # [*] Use f-string instead of `format` call
+]
+
+[tool.ruff.lint.per-file-ignores]
+# B904 == Use `raise from` to specify exception cause
+# EM101 == raw-string-in-exception
+# EM102 == f-string-in-exception
+# EM103 == dot-format-in-exception
+# PLC1901 == `x == ""` can be simplified to `not x` as an empty string is falsey
+# PT009 == Use a regular `assert` instead of unittest-style `self.assert*`
+# T201 == print()
+# T203 == pprint()
+# TRY003 == raise-vanilla-args
+".github/workflows/*" = [
+    "B904",
+    "EM101",
+    "EM102",
+    "EM103",
+    "T201",
+    "T203",
+    "TRY003",
+]
+"**/test_*.py" = ["B904", "EM101", "EM102", "EM103", "PLC1901", "RUF069", "TRY003"]
+"tests/__init__.py" = ["B904", "EM101", "EM102", "EM103", "PLC1901", "RUF069", "TRY003"]
+"tests/test_sudo.py" = ["PT009"]
+"scripts/*" = ["B904", "EM101", "EM102", "EM103", "T201", "T203"]
+"scripts/internal/*" = ["B904", "EM101", "EM102", "EM103", "T201", "T203", "TRY003"]
+"doc/internal/*" = ["B904", "EM101", "EM102", "EM103", "T201", "T203", "TRY003"]
+"setup.py" = [
+    "T201",
+    "T203",
+]
+
+[tool.ruff.lint.isort]
+# https://beta.ruff.rs/docs/settings/#isort
+force-single-line = true  # one import per line
+
+[tool.coverage.report]
+exclude_lines = [
+    "except ImportError:",
+    "globals().update",
+    "if BSD",
+    "if FREEBSD",
+    "if LINUX",
+    "if LITTLE_ENDIAN:",
+    "if MACOS",
+    "if NETBSD",
+    "if OPENBSD",
+    "if SUNOS",
+    "if WINDOWS",
+    "if _WINDOWS:",
+    "if __name__ == .__main__.:",
+    "if ppid_map is None:",
+    "if sys.platform.startswith",
+    "pragma: no cover",
+    "raise NotImplementedError",
+]
+omit = [
+    "setup.py",
+    "tests/*",
+]
+
+[tool.pylint.messages_control]
+# Important ones:
+# undefined-all-variable, invalid-envvar-default, reimported, raising-format-tuple, simplifiable-if-expression, useless-object-inheritance
+disable = [
+    "broad-except",  # except Exception:
+    "consider-using-dict-comprehension",
+    "consider-using-f-string",
+    "consider-using-set-comprehension",
+    "consider-using-with",
+    "disallowed-name",
+    "fixme",
+    "global-statement",
+    "import-error",
+    "import-outside-toplevel",
+    "inconsistent-return-statements",
+    "invalid-name",
+    "missing-class-docstring",
+    "missing-function-docstring",
+    "no-else-raise",
+    "no-else-return",
+    "protected-access",
+    "raise-missing-from",
+    "redefined-builtin",
+    "super-with-arguments",
+    "too-few-public-methods",
+    "too-many-arguments",
+    "too-many-branches",
+    "too-many-instance-attributes",
+    "too-many-lines",
+    "too-many-locals",
+    "too-many-public-methods",
+    "too-many-return-statements",
+    "too-many-statements",
+    "ungrouped-imports",
+    "unspecified-encoding",
+    "wrong-import-position",
+]
+
+[tool.vulture]
+exclude = [
+    "docs/conf.py",
+    "tests/",
+]
+ignore_decorators = [
+    "@_common.deprecated_method",
+    "@atexit.register",
+    "@pytest.fixture",
+]
+
+[tool.tomlsort]
+in_place = true
+no_sort_tables = true
+sort_inline_arrays = true
+spaces_before_inline_comment = 2
+spaces_indent_inline_array = 4
+trailing_comma_inline_array = true
+
+# Avoid recent [tool.pytest] to stay compatible with pytest < 9.
+[tool.pytest.ini_options]
+addopts = [
+    "--capture=no",
+    "--instafail",
+    "--no-header",
+    "--tb=short",
+    "--verbose",
+    "-p instafail",
+    "-p no:doctest",
+    "-p no:junitxml",
+    "-p no:nose",
+    "-p no:pastebin",
+    "-p xdist",
+]
+strict_config = true
+strict_markers = true
+verbosity_subtests = "0"
+verbosity_assertions = "2"
+testpaths = ["tests/"]
+python_files = ["test_*.py"]
+markers = [
+    "isolated: run in a separate serial pytest phase, not under -n auto",
+]
+
+[tool.rstwrap]
+width = 79
diff --git a/scripts/battery.py b/scripts/battery.py
new file mode 100755
index 0000000000..d73b8cb8b6
--- /dev/null
+++ b/scripts/battery.py
@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Show battery information.
+
+$ python3 scripts/battery.py
+charge:     74%
+left:       2:11:31
+status:     discharging
+plugged in: no
+"""
+
+import sys
+
+import psutil
+
+
+def secs2hours(secs):
+    mm, ss = divmod(secs, 60)
+    hh, mm = divmod(mm, 60)
+    return f"{int(hh)}:{int(mm):02}:{int(ss):02}"
+
+
+def main():
+    if not hasattr(psutil, "sensors_battery"):
+        return sys.exit("platform not supported")
+    batt = psutil.sensors_battery()
+    if batt is None:
+        return sys.exit("no battery is installed")
+
+    print(f"charge:     {round(batt.percent, 2)}%")
+    if batt.power_plugged:
+        print(
+            "status:    "
+            f" {'charging' if batt.percent < 100 else 'fully charged'}"
+        )
+        print("plugged in: yes")
+    else:
+        print(f"left:      {secs2hours(batt.secsleft)}")
+        print("status:     discharging")
+        print("plugged in: no")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/cpu_distribution.py b/scripts/cpu_distribution.py
new file mode 100755
index 0000000000..b462033f9e
--- /dev/null
+++ b/scripts/cpu_distribution.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Shows CPU workload split across different CPUs.
+
+$ python3 scripts/cpu_workload.py
+CPU 0     CPU 1     CPU 2     CPU 3     CPU 4     CPU 5     CPU 6     CPU 7
+19.8      20.6      18.2      15.8      6.9       17.3      5.0       20.4
+gvfsd     pytho     kwork     chrom     unity     kwork     kwork     kwork
+chrom     chrom     indic     ibus-     whoop     nfsd      (sd-p     gvfsd
+ibus-     cat       at-sp     chrom     Modem     nfsd4     light     upsta
+ibus-     iprt-     ibus-     nacl_     cfg80     kwork     nfsd      bluet
+chrom     irqba     gpg-a     chrom     ext4-     biose     nfsd      dio/n
+chrom     acpid     bamfd     nvidi     kwork     scsi_     sshd      rpc.m
+upsta     rsysl     dbus-     nfsd      biose     scsi_     ext4-     polki
+rtkit     avahi     upowe     Netwo     scsi_     biose     UVM T     irq/9
+light     rpcbi     snapd     cron      ipv6_     biose     kwork     dbus-
+agett     kvm-i     avahi     kwork     biose     biose     scsi_     syste
+nfsd      syste     rpc.i     biose     biose     kbloc     kthro     UVM g
+nfsd      kwork     kwork     biose     vmsta     kwork     crypt     kaudi
+nfsd      scsi_     charg     biose     md        ksoft     kwork     kwork
+memca     biose     ksmd      ecryp     ksoft     watch     migra     nvme
+therm     biose     kcomp     kswap     migra     cpuhp     watch     biose
+syste     biose     kdevt     khuge     watch               cpuhp     biose
+led_w     devfr     kwork     write     cpuhp                         biose
+rpcio     oom_r     ksoft     kwork     syste                         biose
+kwork     kwork     watch     migra                                   acpi_
+biose     ksoft     cpuhp     watch                                   watch
+biose     migra               cpuhp                                   kinte
+biose     watch               rcu_s                                   netns
+biose     cpuhp               kthre                                   kwork
+cpuhp                                                                 ksoft
+watch                                                                 migra
+rcu_b                                                                 cpuhp
+kwork
+"""
+
+import collections
+import os
+import shutil
+import sys
+import time
+
+import psutil
+
+if not hasattr(psutil.Process, "cpu_num"):
+    sys.exit("platform not supported")
+
+
+def clean_screen():
+    if psutil.POSIX:
+        os.system('clear')
+    else:
+        os.system('cls')
+
+
+def main():
+    num_cpus = psutil.cpu_count()
+    if num_cpus > 8:
+        num_cpus = 8  # try to fit into screen
+        cpus_hidden = True
+    else:
+        cpus_hidden = False
+
+    while True:
+        # header
+        clean_screen()
+        cpus_percent = psutil.cpu_percent(percpu=True)
+        for i in range(num_cpus):
+            print(f"CPU {i:<6}", end="")
+        if cpus_hidden:
+            print(" (+ hidden)", end="")
+
+        print()
+        for _ in range(num_cpus):
+            print(f"{cpus_percent.pop(0):<10}", end="")
+        print()
+
+        # processes
+        procs = collections.defaultdict(list)
+        for p in psutil.process_iter(['name', 'cpu_num']):
+            procs[p.cpu_num()].append(p.name()[:5])
+
+        curr_line = 3
+        while True:
+            for num in range(num_cpus):
+                try:
+                    pname = procs[num].pop()
+                except IndexError:
+                    pname = ""
+                print(f"{pname[:10]:<10}", end="")
+            print()
+            curr_line += 1
+            if curr_line >= shutil.get_terminal_size()[1]:
+                break
+
+        time.sleep(1)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/disk_usage.py b/scripts/disk_usage.py
index 2bb928c0d6..e1d7239c03 100755
--- a/scripts/disk_usage.py
+++ b/scripts/disk_usage.py
@@ -1,62 +1,53 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-List all mounted disk partitions a-la "df -h" command.
+"""List all mounted disk partitions a-la "df -h" command.
 
-$ python scripts/disk_usage.py
+$ python3 scripts/disk_usage.py
 Device               Total     Used     Free  Use %      Type  Mount
 /dev/sdb3            18.9G    14.7G     3.3G    77%      ext4  /
 /dev/sda6           345.9G    83.8G   244.5G    24%      ext4  /home
 /dev/sda1           296.0M    43.1M   252.9M    14%      vfat  /boot/efi
 /dev/sda2           600.0M   312.4M   287.6M    52%   fuseblk  /media/Recovery
+
 """
 
-import sys
 import os
-import psutil
-
+import sys
 
-def bytes2human(n):
-    # http://code.activestate.com/recipes/578019
-    # >>> bytes2human(10000)
-    # '9.8K'
-    # >>> bytes2human(100001221)
-    # '95.4M'
-    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
-    prefix = {}
-    for i, s in enumerate(symbols):
-        prefix[s] = 1 << (i + 1) * 10
-    for s in reversed(symbols):
-        if n >= prefix[s]:
-            value = float(n) / prefix[s]
-            return '%.1f%s' % (value, s)
-    return "%sB" % n
+import psutil
+from psutil import bytes2human
 
 
 def main():
-    templ = "%-17s %8s %8s %8s %5s%% %9s  %s"
-    print(templ % ("Device", "Total", "Used", "Free", "Use ", "Type",
-                   "Mount"))
+    templ = "{:<17} {:>8} {:>8} {:>8} {:>5}% {:>9}  {}"
+    print(
+        templ.format(
+            "Device", "Total", "Used", "Free", "Use ", "Type", "Mount"
+        )
+    )
     for part in psutil.disk_partitions(all=False):
         if os.name == 'nt':
-            if 'cdrom' in part.opts or part.fstype == '':
+            if 'cdrom' in part.opts or not part.fstype:
                 # skip cd-rom drives with no disk in it; they may raise
                 # ENOENT, pop-up a Windows GUI error for a non-ready
                 # partition or just hang.
                 continue
         usage = psutil.disk_usage(part.mountpoint)
-        print(templ % (
+        line = templ.format(
             part.device,
             bytes2human(usage.total),
             bytes2human(usage.used),
             bytes2human(usage.free),
             int(usage.percent),
             part.fstype,
-            part.mountpoint))
+            part.mountpoint,
+        )
+        print(line)
+
 
 if __name__ == '__main__':
     sys.exit(main())
diff --git a/scripts/fans.py b/scripts/fans.py
new file mode 100755
index 0000000000..16f0266709
--- /dev/null
+++ b/scripts/fans.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Show fans information.
+
+$ python fans.py
+asus
+    cpu_fan              3200 RPM
+"""
+
+import sys
+
+import psutil
+
+
+def main():
+    if not hasattr(psutil, "sensors_fans"):
+        return sys.exit("platform not supported")
+    fans = psutil.sensors_fans()
+    if not fans:
+        print("no fans detected")
+        return None
+    for name, entries in fans.items():
+        print(name)
+        for entry in entries:
+            print(f"    {entry.label or name:<20} {entry.current} RPM")
+        print()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/free.py b/scripts/free.py
index 897f006f90..c891b6fc92 100755
--- a/scripts/free.py
+++ b/scripts/free.py
@@ -1,13 +1,12 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-A clone of 'free' cmdline utility.
+"""A clone of 'free' cmdline utility.
 
-$ python scripts/free.py
+$ python3 scripts/free.py
              total       used       free     shared    buffers      cache
 Mem:      10125520    8625996    1499524          0     349500    3307836
 Swap:            0          0          0
@@ -19,23 +18,31 @@
 def main():
     virt = psutil.virtual_memory()
     swap = psutil.swap_memory()
-    templ = "%-7s %10s %10s %10s %10s %10s %10s"
-    print(templ % ('', 'total', 'used', 'free', 'shared', 'buffers', 'cache'))
-    print(templ % (
+    templ = "{:<7} {:>10} {:>10} {:>10} {:>10} {:>10} {:>10}"
+    print(
+        templ.format("", "total", "used", "free", "shared", "buffers", "cache")
+    )
+    sect = templ.format(
         'Mem:',
         int(virt.total / 1024),
         int(virt.used / 1024),
         int(virt.free / 1024),
         int(getattr(virt, 'shared', 0) / 1024),
         int(getattr(virt, 'buffers', 0) / 1024),
-        int(getattr(virt, 'cached', 0) / 1024)))
-    print(templ % (
-        'Swap:', int(swap.total / 1024),
+        int(getattr(virt, 'cached', 0) / 1024),
+    )
+    print(sect)
+    sect = templ.format(
+        'Swap:',
+        int(swap.total / 1024),
         int(swap.used / 1024),
         int(swap.free / 1024),
         '',
         '',
-        ''))
+        '',
+    )
+    print(sect)
+
 
 if __name__ == '__main__':
     main()
diff --git a/scripts/ifconfig.py b/scripts/ifconfig.py
index 72cc02fe86..4f34cb55ca 100755
--- a/scripts/ifconfig.py
+++ b/scripts/ifconfig.py
@@ -1,46 +1,51 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-A clone of 'ifconfig' on UNIX.
+"""A clone of 'ifconfig' on UNIX.
 
-$ python scripts/ifconfig.py
-lo (speed=0MB, duplex=?, mtu=65536, up=yes):
-    IPv4     address   : 127.0.0.1
-             broadcast : 127.0.0.1
-             netmask   : 255.0.0.0
-    IPv6     address   : ::1
-             netmask   : ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
-    MAC      address   : 00:00:00:00:00:00
-             broadcast : 00:00:00:00:00:00
+$ python3 scripts/ifconfig.py
+lo:
+    stats          : speed=0MB, duplex=?, mtu=65536, up=yes
+    incoming       : bytes=1.95M, pkts=22158, errs=0, drops=0
+    outgoing       : bytes=1.95M, pkts=22158, errs=0, drops=0
+    IPv4 address   : 127.0.0.1
+         netmask   : 255.0.0.0
+    IPv6 address   : ::1
+         netmask   : ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
+    MAC  address   : 00:00:00:00:00:00
 
-wlan0 (speed=0MB, duplex=?, mtu=1500, up=yes):
-    IPv4     address   : 10.0.3.1
-             broadcast : 10.0.3.255
-             netmask   : 255.255.255.0
-    IPv6     address   : fe80::3005:adff:fe31:8698
-             netmask   : ffff:ffff:ffff:ffff::
-    MAC      address   : 32:05:ad:31:86:98
-             broadcast : ff:ff:ff:ff:ff:ff
+docker0:
+    stats          : speed=0MB, duplex=?, mtu=1500, up=yes
+    incoming       : bytes=3.48M, pkts=65470, errs=0, drops=0
+    outgoing       : bytes=164.06M, pkts=112993, errs=0, drops=0
+    IPv4 address   : 172.17.0.1
+         broadcast : 172.17.0.1
+         netmask   : 255.255.0.0
+    IPv6 address   : fe80::42:27ff:fe5e:799e%docker0
+         netmask   : ffff:ffff:ffff:ffff::
+    MAC  address   : 02:42:27:5e:79:9e
+         broadcast : ff:ff:ff:ff:ff:ff
 
-eth0 (speed=100MB, duplex=full, mtu=1500, up=yes):
-    IPv4     address   : 192.168.1.2
-             broadcast : 192.168.1.255
-             netmask   : 255.255.255.0
-    IPv6     address   : fe80::c685:8ff:fe45:641
-             netmask   : ffff:ffff:ffff:ffff::
-    MAC      address   : c4:85:08:45:06:41
-             broadcast : ff:ff:ff:ff:ff:ff
+wlp3s0:
+    stats          : speed=0MB, duplex=?, mtu=1500, up=yes
+    incoming       : bytes=7.04G, pkts=5637208, errs=0, drops=0
+    outgoing       : bytes=372.01M, pkts=3200026, errs=0, drops=0
+    IPv4 address   : 10.0.0.2
+         broadcast : 10.255.255.255
+         netmask   : 255.0.0.0
+    IPv6 address   : fe80::ecb3:1584:5d17:937%wlp3s0
+         netmask   : ffff:ffff:ffff:ffff::
+    MAC  address   : 48:45:20:59:a4:0c
+         broadcast : ff:ff:ff:ff:ff:ff
 """
 
-from __future__ import print_function
 import socket
 
 import psutil
-
+from psutil import bytes2human
 
 af_map = {
     socket.AF_INET: 'IPv4',
@@ -57,23 +62,51 @@
 
 def main():
     stats = psutil.net_if_stats()
+    io_counters = psutil.net_io_counters(pernic=True)
     for nic, addrs in psutil.net_if_addrs().items():
+        print(f"{nic}:")
         if nic in stats:
-            print("%s (speed=%sMB, duplex=%s, mtu=%s, up=%s):" % (
-                nic, stats[nic].speed, duplex_map[stats[nic].duplex],
-                stats[nic].mtu, "yes" if stats[nic].isup else "no"))
-        else:
-            print("%s:" % (nic))
+            st = stats[nic]
+            print("    stats          : ", end='')
+            print(
+                "speed={}MB, duplex={}, mtu={}, up={}".format(
+                    st.speed,
+                    duplex_map[st.duplex],
+                    st.mtu,
+                    "yes" if st.isup else "no",
+                )
+            )
+        if nic in io_counters:
+            io = io_counters[nic]
+            print("    incoming       : ", end='')
+            print(
+                "bytes={}, pkts={}, errs={}, drops={}".format(
+                    bytes2human(io.bytes_recv),
+                    io.packets_recv,
+                    io.errin,
+                    io.dropin,
+                )
+            )
+            print("    outgoing       : ", end='')
+            print(
+                "bytes={}, pkts={}, errs={}, drops={}".format(
+                    bytes2human(io.bytes_sent),
+                    io.packets_sent,
+                    io.errout,
+                    io.dropout,
+                )
+            )
         for addr in addrs:
-            print("    %-8s" % af_map.get(addr.family, addr.family), end="")
-            print(" address   : %s" % addr.address)
+            fam = "    {:<4}".format(af_map.get(addr.family, addr.family))
+            print(fam, end="")
+            print(f" address   : {addr.address}")
             if addr.broadcast:
-                print("             broadcast : %s" % addr.broadcast)
+                print(f"         broadcast : {addr.broadcast}")
             if addr.netmask:
-                print("             netmask   : %s" % addr.netmask)
+                print(f"         netmask   : {addr.netmask}")
             if addr.ptp:
-                print("             p2p       : %s" % addr.ptp)
-        print("")
+                print(f"      p2p       : {addr.ptp}")
+        print()
 
 
 if __name__ == '__main__':
diff --git a/scripts/internal/README b/scripts/internal/README
new file mode 100644
index 0000000000..69a4c386f2
--- /dev/null
+++ b/scripts/internal/README
@@ -0,0 +1,2 @@
+This directory contains scripts which are meant to be used internally
+(benchmarks, CI automation, etc.).
diff --git a/scripts/internal/bench_oneshot.py b/scripts/internal/bench_oneshot.py
new file mode 100755
index 0000000000..29dae255e2
--- /dev/null
+++ b/scripts/internal/bench_oneshot.py
@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""A simple micro benchmark script which prints the speedup when using
+Process.oneshot() ctx manager.
+See: https://github.com/giampaolo/psutil/issues/799.
+"""
+
+import argparse
+import os
+import sys
+import textwrap
+import timeit
+
+import psutil
+
+TIMES = 1000
+PID = os.getpid()
+
+# The list of Process methods which gets collected in one shot and
+# as such get advantage of the speedup.
+NAMES = [
+    'cpu_times',
+    'cpu_percent',
+    'memory_info',
+    'memory_percent',
+    'ppid',
+    'parent',
+]
+
+if psutil.POSIX:
+    NAMES.extend(('uids', 'username'))
+
+if psutil.LINUX:
+    NAMES += [
+        # 'memory_footprint',
+        # 'memory_maps',
+        'cpu_num',
+        'cpu_times',
+        'gids',
+        'memory_extras',
+        'name',
+        'num_ctx_switches',
+        'num_threads',
+        'page_faults',
+        'ppid',
+        'status',
+        'terminal',
+        'uids',
+    ]
+elif psutil.BSD:
+    NAMES = [
+        'cpu_times',
+        'gids',
+        'io_counters',
+        'memory_info',
+        'name',
+        'num_ctx_switches',
+        'ppid',
+        'status',
+        'terminal',
+        'uids',
+    ]
+    if psutil.FREEBSD:
+        NAMES.append('cpu_num')
+elif psutil.SUNOS:
+    NAMES += [
+        'cmdline',
+        'gids',
+        'memory_footprint',
+        'memory_info',
+        'name',
+        'num_threads',
+        'ppid',
+        'status',
+        'terminal',
+        'uids',
+    ]
+elif psutil.MACOS:
+    NAMES += [
+        'cpu_times',
+        'create_time',
+        'gids',
+        'memory_info',
+        'name',
+        'num_ctx_switches',
+        'num_threads',
+        'ppid',
+        'terminal',
+        'uids',
+    ]
+elif psutil.WINDOWS:
+    NAMES += [
+        'num_ctx_switches',
+        'num_threads',
+        # dual implementation, called in case of AccessDenied
+        'num_handles',
+        'cpu_times',
+        'create_time',
+        'num_threads',
+        'io_counters',
+        'memory_info',
+    ]
+
+setup_code = textwrap.dedent("""
+    from __main__ import NAMES
+    import psutil
+
+    def call_normal(funs):
+        for fun in funs:
+            fun()
+
+    def call_oneshot(funs):
+        with p.oneshot():
+            for fun in funs:
+                fun()
+
+    p = psutil.Process({})
+    funs = [getattr(p, n) for n in NAMES]
+    """)
+
+
+def parse_cli():
+    global TIMES, PID, NAMES
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument("-i", "--times", type=int, default=TIMES)
+    parser.add_argument("-p", "--pid", type=int, default=PID)
+    parser.add_argument("-n", "--names", default=None, metavar="METHOD,METHOD")
+    args = parser.parse_args()
+    TIMES = args.times
+    PID = args.pid
+    if args.names:
+        NAMES = args.names.split(",")
+    NAMES = sorted(set(NAMES))
+
+
+def main():
+    parse_cli()
+    print(
+        f"{len(NAMES)} methods pre-fetched by oneshot() on platform"
+        f" {sys.platform!r} ({TIMES:,} times, psutil"
+        f" {psutil.__version__}):\n"
+    )
+    for name in sorted(NAMES):
+        print("  " + name)
+        attr = getattr(psutil.Process, name, None)
+        if attr is None or not callable(attr):
+            raise ValueError(f"invalid name {name!r}")
+
+    # regular run
+    setup = setup_code.format(PID)
+    elapsed1 = timeit.timeit("call_normal(funs)", setup=setup, number=TIMES)
+    print(f"\nregular:  {elapsed1:.3f} secs")
+
+    # oneshot() run
+    elapsed2 = timeit.timeit("call_oneshot(funs)", setup=setup, number=TIMES)
+    print(f"oneshot:  {elapsed2:.3f} secs")
+
+    # done
+    if elapsed2 < elapsed1:
+        print(f"speedup:  +{elapsed1 / elapsed2:.2f}x")
+    elif elapsed2 > elapsed1:
+        print(f"slowdown:  -{elapsed2 / elapsed1:.2f}x")
+    else:
+        print("same speed")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/internal/bench_oneshot_2.py b/scripts/internal/bench_oneshot_2.py
new file mode 100755
index 0000000000..2844cc0c5d
--- /dev/null
+++ b/scripts/internal/bench_oneshot_2.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Same as bench_oneshot.py but uses perf module instead, which is
+supposed to be more precise.
+"""
+
+import sys
+
+import pyperf  # requires "pip install pyperf"
+
+import psutil
+
+p = psutil.Process()
+
+
+def call_normal(funs):
+    for fun in funs:
+        fun()
+
+
+def call_oneshot(funs):
+    with p.oneshot():
+        for fun in funs:
+            fun()
+
+
+def main():
+    from bench_oneshot import NAMES
+
+    runner = pyperf.Runner()
+
+    args = runner.parse_args()
+    if not args.worker:
+        print(
+            f"{len(NAMES)} methods involved on platform"
+            f" {sys.platform!r} (psutil {psutil.__version__}):"
+        )
+        for name in sorted(NAMES):
+            print("    " + name)
+
+    funs = [getattr(p, n) for n in NAMES]
+    runner.bench_func("normal", call_normal, funs)
+    runner.bench_func("oneshot", call_oneshot, funs)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/internal/cfarm-test.sh b/scripts/internal/cfarm-test.sh
new file mode 100755
index 0000000000..4391d2b4ec
--- /dev/null
+++ b/scripts/internal/cfarm-test.sh
@@ -0,0 +1,216 @@
+#!/bin/sh
+
+# Sync this checkout to a remote host (e.g. one of the GCC compile farm
+# machines), build it in a venv there and run the test suite. Output is
+# streamed as it happens and also kept on the remote, so whatever was
+# produced before a dropped connection isn't lost. The run itself does
+# not survive the disconnect.
+
+set -e
+
+HOST=
+LOCAL_DIR=
+PYTHON=python3
+REMOTE_DIR=psutil
+CMD="make test-parallel"
+REMOTE_LOG=.cfarm-test.log
+REMOTE_RC=.cfarm-test.rc
+REMOTE_SH=.cfarm-test.sh
+
+files=
+stage=
+tmp=
+
+# --- utils
+
+usage() {
+    cat << EOF
+usage: $(basename "$0") [options] HOST
+
+Sync this checkout to HOST, build it in a venv and run the test suite.
+
+  --python=PATH     interpreter used to create the venv, if there isn't
+                    one already (default: python3)
+  --remote-dir=DIR  remote path, relative to the home dir (default: psutil)
+  --cmd=CMD         command to run remotely (default: "make test-parallel")
+  -h, --help        show this help
+
+Known hosts:
+EOF
+    if [ -r "$HOME/.ssh/config" ]; then
+        awk '/^Host / {
+            for (i = 2; i <= NF; i++)
+                if ($i !~ /[*?]/)
+                    print "  " $i
+        }' "$HOME/.ssh/config"
+    fi
+}
+
+log() {
+    printf '\n\033[1;36m=== %s\033[0m\n' "$1"
+}
+
+shquote() {
+    # Escape a value for embedding in a single-quoted remote string.
+    printf "%s" "$1" | sed "s/'/'\\\\''/g"
+}
+
+parse_args() {
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            -h | --help)
+                usage
+                exit 0
+                ;;
+            --python=*)
+                PYTHON=${1#*=}
+                ;;
+            --remote-dir=*)
+                REMOTE_DIR=${1#*=}
+                ;;
+            --cmd=*)
+                CMD=${1#*=}
+                ;;
+            -*)
+                echo "error: unknown option $1" >&2
+                exit 2
+                ;;
+            *)
+                if [ -n "$HOST" ]; then
+                    echo "error: too many arguments" >&2
+                    exit 2
+                fi
+                HOST=$1
+                ;;
+        esac
+        shift
+    done
+    if [ -z "$HOST" ]; then
+        echo "error: no host given" >&2
+        usage >&2
+        exit 2
+    fi
+    LOCAL_DIR=$(git -C "$(dirname "$0")" rev-parse --show-toplevel)
+}
+
+# --- sync
+
+sync_repo() {
+    log "syncing $LOCAL_DIR -> $HOST:$REMOTE_DIR"
+    # Stage the tracked files first, then mirror that directory. rsync
+    # then gets a real, complete source tree, so --delete means what it
+    # looks like, and the excludes double as protect rules keeping the
+    # remote venv, build dir and log alive.
+    files=$(mktemp)
+    stage=$(mktemp -d)
+    git -C "$LOCAL_DIR" ls-files -z > "$files"
+    if [ ! -s "$files" ]; then
+        echo "error: no tracked files to sync" >&2
+        return 1
+    fi
+    # git lists tracked files deleted from the working tree but not
+    # committed yet; skip them here so the mirror drops them too.
+    rsync \
+        --archive \
+        --ignore-missing-args \
+        --from0 \
+        --files-from="$files" \
+        "$LOCAL_DIR/" "$stage/"
+    # SC2016: $PATH is meant for the remote shell, not this one.
+    # shellcheck disable=SC2016
+    rsync \
+        --archive \
+        --compress \
+        --delete \
+        --exclude=/.venv \
+        --exclude=/build \
+        --exclude='/.cfarm-test.*' \
+        --partial \
+        --rsync-path='PATH=$PATH:/opt/freeware/bin rsync' \
+        "$stage/" "$HOST:$REMOTE_DIR"
+}
+
+# --- remote
+
+remote_script() {
+    cat << 'EOF'
+set -e
+
+if [ ! -d .venv ]; then
+    echo ">>> creating .venv with $PYTHON"
+    # Debian ships ensurepip in a separate python3-venv package which
+    # the farm machines don't always have. install-pydeps.sh bootstraps
+    # pip over the network anyway, so a venv without it will do.
+    "$PYTHON" -m venv .venv || {
+        rm -rf .venv
+        "$PYTHON" -m venv --without-pip .venv
+    }
+fi
+
+. .venv/bin/activate
+
+uname -srm
+python -VV
+python -c 'import os, platform, struct, sys; print("libc=%s%s | %s-endian | %d bit | page=%dK" % (platform.libc_ver()[0] or "?", platform.libc_ver()[1], sys.byteorder, struct.calcsize("P") * 8, os.sysconf("SC_PAGE_SIZE") // 1024))'
+
+echo ">>> make install-pydeps-test"
+make install-pydeps-test
+
+echo ">>> make build"
+make build
+
+echo ">>> $CMD"
+eval "$CMD"
+EOF
+}
+
+upload_script() {
+    tmp=$(mktemp)
+    remote_script > "$tmp"
+    scp -q "$tmp" "$HOST:$REMOTE_DIR/$REMOTE_SH"
+}
+
+remote_command() {
+    # The exit status goes through a file because the remote shell is
+    # sh, which has neither PIPESTATUS nor pipefail. tee also means
+    # pytest's stdout is a pipe rather than the pty, hence PY_COLORS.
+    cat << EOF
+cd '$(shquote "$REMOTE_DIR")' || exit 1
+export CMD='$(shquote "$CMD")' PYTHON='$(shquote "$PYTHON")'
+export PY_COLORS=1
+{ sh '$REMOTE_SH' 2>&1; echo \$? > '$REMOTE_RC'; } | tee '$REMOTE_LOG'
+rc=\$(cat '$REMOTE_RC')
+rm -f '$REMOTE_SH' '$REMOTE_RC'
+exit \$rc
+EOF
+}
+
+run_remote() {
+    log "building and testing on $HOST"
+    # The variables in remote_command expand here, not on the remote.
+    # shellcheck disable=SC2029
+    if [ -t 0 ]; then
+        # A pty lets ctrl-c reach the remote make and pytest. ssh can
+        # only allocate one if we have one ourselves.
+        ssh -t "$HOST" "$(remote_command)"
+    else
+        ssh "$HOST" "$(remote_command)"
+    fi
+}
+
+main() {
+    trap 'rm -rf "$files" "$stage" "$tmp"' EXIT
+    parse_args "$@"
+    sync_repo
+    upload_script
+    rc=0
+    run_remote || rc=$?
+    if [ "$rc" -eq 255 ]; then
+        log "connection lost; the log is still on $HOST:$REMOTE_DIR/$REMOTE_LOG"
+    else
+        log "done (exit $rc), remote log: $HOST:$REMOTE_DIR/$REMOTE_LOG"
+    fi
+    exit "$rc"
+}
+
+main "$@"
diff --git a/scripts/internal/convert_readme.py b/scripts/internal/convert_readme.py
new file mode 100755
index 0000000000..2985aed28b
--- /dev/null
+++ b/scripts/internal/convert_readme.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Strip raw HTML and other unsupported parts from README.rst
+so it renders correctly on PyPI when uploading a new release.
+"""
+
+import argparse
+import re
+
+quick_links = """\
+Quick links
+===========
+
+- `Home page <https://github.com/giampaolo/psutil>`_
+- `Documentation <https://psutil.io>`_
+- `Who uses psutil <https://psutil.io/adoption/>`_
+- `Download <https://pypi.org/project/psutil/#files>`_
+- `Blog <https://psutil.io/blog/>`_
+- `What's new <https://psutil.io/changelog/>`_
+"""
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('file', type=str)
+    args = parser.parse_args()
+
+    lines = []
+
+    with open(args.file) as f:
+        excluding = False
+        for line in f:
+            # Exclude sections which are not meant to be rendered on PYPI
+            if line.startswith(".. <PYPI-EXCLUDE>"):
+                excluding = True
+                continue
+            if line.startswith(".. </PYPI-EXCLUDE>"):
+                excluding = False
+                continue
+            if not excluding:
+                lines.append(line)
+
+    text = "".join(lines)
+
+    # Rewrite summary
+    text = re.sub(
+        r".. raw:: html\n+\s+<div align[\s\S]*?/div>", quick_links, text
+    )
+
+    print(text)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/internal/docs/build_versions.py b/scripts/internal/docs/build_versions.py
new file mode 100755
index 0000000000..4a41e6e83f
--- /dev/null
+++ b/scripts/internal/docs/build_versions.py
@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import argparse
+import json
+import pathlib
+import shutil
+import subprocess
+import sys
+import tempfile
+import venv
+
+SITE_DIR = None
+ONLY = None
+
+ROOT = pathlib.Path(__file__).resolve().parents[3]
+VERSIONS_JSON = ROOT / "docs" / "versions.json"
+FONT_DIRS = ("_static/fonts", "_static/css/fonts")
+LEGACY_FONTS = ("*.ttf", "*.eot", "*.svg", "*.woff")
+DROP = ("blog", "_sources", "_images/social_previews", ".doctrees")
+
+
+def run(cmd, cwd=None):
+    print("+ " + " ".join(str(c) for c in cmd))
+    subprocess.check_call(cmd, cwd=cwd)
+
+
+def load_versions():
+    data = json.loads(VERSIONS_JSON.read_text(encoding="utf-8"))
+    entries = [e for e in data["versions"] if e.get("ref")]
+    return data["current"], entries
+
+
+def banner(entry, current, root):
+    # Same component as docs/_templates/banner.html, loaded from the
+    # current site because these pages are built from an old tag.
+    name = entry["name"]
+    return (
+        '<meta name="robots" content="noindex">'
+        f'<link rel="stylesheet" href="{root}_static/css/banner.css">'
+        f'<script defer src="{root}_static/js/banner.js"></script>'
+        "<script>try{if(localStorage.getItem('psutil-banner')==="
+        f"'{name}')"
+        "{document.documentElement.classList.add("
+        "'site-banner-dismissed')}}catch(e){}</script>"
+        f'<div class="site-banner" role="note" data-banner-id="{name}">'
+        '<span>You are reading the documentation for psutil '
+        f'<b>{name}</b>. '
+        f'The current version is <a href="{root}">{current}</a>.</span>'
+        '<button class="site-banner-close" type="button" title="Dismiss" '
+        'aria-label="Dismiss this notice"></button>'
+        "</div>"
+    )
+
+
+def inject(html_dir, entry, current):
+    count = 0
+    for path in sorted(html_dir.rglob("*.html")):
+        text = path.read_text(encoding="utf-8")
+        if "</head>" not in text:
+            sys.stderr.write(f"warning: no </head> in {path}\n")
+            continue
+        depth = len(path.relative_to(html_dir).parts)
+        root = "../" * depth
+        snippet = banner(entry, current, root)
+        path.write_text(
+            text.replace("</head>", snippet + "</head>", 1), encoding="utf-8"
+        )
+        count += 1
+    return count
+
+
+def trim(html_dir):
+    for rel in DROP:
+        target = html_dir / rel
+        if target.is_dir():
+            shutil.rmtree(target)
+    for rel in FONT_DIRS:
+        font_dir = html_dir / rel
+        if not font_dir.is_dir():
+            continue
+        for pattern in LEGACY_FONTS:
+            for path in font_dir.rglob(pattern):
+                path.unlink()
+
+
+def build_one(entry, current, site_dir):
+    tmp = pathlib.Path(tempfile.mkdtemp(prefix="psutil-docs-"))
+    worktree = tmp / "src"
+    try:
+        run(
+            ["git", "worktree", "add", "--detach", worktree, entry["ref"]],
+            cwd=ROOT,
+        )
+        env = tmp / "venv"
+        venv.create(env, with_pip=True)
+        python = env / "bin" / "python"
+        run([
+            python,
+            "-m",
+            "pip",
+            "install",
+            "--quiet",
+            "-r",
+            worktree / "docs" / "requirements.txt",
+        ])
+        run(["make", "html", f"PYTHON={python}"], cwd=worktree / "docs")
+        html_dir = worktree / "docs" / "_build" / "html"
+        pages = inject(html_dir, entry, current)
+        trim(html_dir)
+        dst = site_dir / entry["url"].strip("/")
+        if dst.exists():
+            shutil.rmtree(dst)
+        shutil.copytree(html_dir, dst)
+        size = sum(p.stat().st_size for p in dst.rglob("*") if p.is_file())
+        print(f"  {entry['name']}: {pages} pages, {size / 1048576:.1f} MB")
+    finally:
+        subprocess.call(
+            ["git", "worktree", "remove", "--force", worktree], cwd=ROOT
+        )
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+def parse_cli():
+    global SITE_DIR, ONLY
+    parser = argparse.ArgumentParser(
+        description="Build past doc releases into a built site."
+    )
+    parser.add_argument("site", help="built HTML dir, e.g. docs/_build/html")
+    parser.add_argument(
+        "--only", default=None, help="build just this version name"
+    )
+    args = parser.parse_args()
+    SITE_DIR = pathlib.Path(args.site).resolve()
+    ONLY = args.only
+
+
+def main():
+    parse_cli()
+    if not SITE_DIR.is_dir():
+        sys.exit(f"error: {SITE_DIR} does not exist; run `make html` first")
+    current, entries = load_versions()
+    if ONLY:
+        entries = [e for e in entries if e["name"] == ONLY]
+        if not entries:
+            sys.exit(f"error: no version named {ONLY!r} with a ref")
+    if not entries:
+        print("no past versions to build")
+        return
+    for entry in entries:
+        print(f"building {entry['name']} from {entry['ref']}")
+        build_one(entry, current, SITE_DIR)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/internal/docs/find_adopters.py b/scripts/internal/docs/find_adopters.py
new file mode 100755
index 0000000000..4c28c9c381
--- /dev/null
+++ b/scripts/internal/docs/find_adopters.py
@@ -0,0 +1,799 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+r"""Search GitHub for notable projects that use a given project
+as a dependency.
+
+How it works:
+
+1. Enumerate all popular Python repos on GitHub via GraphQL
+   (paginated, >=MIN_STARS).
+2. Batch-fetch data needed for the requested filters
+   (README content, dependency files).
+3. Apply filters. Only repos passing ALL specified filters
+   are confirmed. Available filters:
+   - --inreadme : PROJECT mentioned in the README
+   - --indeps   : PROJECT mentioned in dep files
+     (pyproject.toml, setup.py, setup.cfg, requirements*.txt)
+
+At least one filter must be specified.
+
+Output is RsT formatted, ready to paste into docs/adoption.rst.
+
+Usage:
+    python3 scripts/internal/docs/find_adopters.py \
+        --project=psutil \
+        --token=~/.github.api.key \
+        --skip-file-urls=docs/adoption.rst \
+        --min-stars=10000 --indeps
+"""
+
+import argparse
+import os
+import pickle
+import re
+import sys
+import time
+
+import requests
+
+from psutil._common import hilite
+from psutil._common import print_color
+
+GITHUB_GRAPHQL = "https://api.github.com/graphql"
+_CACHE_FILE = ".find_adopters.cache"
+
+# Set by parse_cli().
+PROJECT = ""
+MIN_STARS = 0
+MAX_STARS = 0
+TOKEN = ""
+SKIP = set()
+INREADME = False
+INDEPS = False
+NO_CACHE = False
+
+# Fixed files to check for dependency declarations.
+_FIXED_DEP_FILES = {
+    "pyproject.toml": "pyprojectToml",
+    "setup.py": "setupPy",
+    "setup.cfg": "setupCfg",
+    "requirements.txt": "requirementsTxt",
+}
+
+# Max repos to batch in a single GraphQL query.
+_BATCH_SIZE = 5
+
+
+green = lambda msg: hilite(msg, color="green")  # noqa: E731
+yellow = lambda msg: hilite(msg, color="yellow")  # noqa: E731
+
+
+def stderr(msg="", color=None):
+    if color:
+        print_color(msg, color=color, file=sys.stderr)
+    else:
+        print(msg, file=sys.stderr)
+
+
+def graphql(session, query, variables=None):
+    """Execute a GraphQL query. Returns the 'data' dict."""
+    payload = {"query": query}
+    if variables:
+        payload["variables"] = variables
+    try:
+        resp = session.post(GITHUB_GRAPHQL, json=payload)
+    except requests.exceptions.RequestException as err:
+        stderr(f"  GraphQL request error: {err}")
+        return None
+    if resp.status_code != 200:
+        stderr(f"  GraphQL HTTP error: {resp.status_code} {resp.text}")
+        return None
+    body = resp.json()
+    if "errors" in body:
+        for err in body["errors"]:
+            stderr(f"  GraphQL error: {err.get('message', err)}")
+        return None
+    return body.get("data")
+
+
+def get_session(token):
+    s = requests.Session()
+    s.headers["Authorization"] = f"Bearer {token}"
+    s.headers["Content-Type"] = "application/json"
+    return s
+
+
+# --- Enumerate repos ---
+
+
+def enumerate_repos(session):
+    """Enumerate all Python repos with >=MIN_STARS on GitHub."""
+    stars_q = f"stars:>={MIN_STARS}"
+    if MAX_STARS:
+        stars_q = f"stars:{MIN_STARS}..{MAX_STARS}"
+    search_q = f"language:Python {stars_q}"
+    query = """
+    query($q: String!, $first: Int!, $after: String) {
+      search(query: $q, type: REPOSITORY,
+             first: $first, after: $after) {
+        repositoryCount
+        edges {
+          node {
+            ... on Repository {
+              nameWithOwner
+              owner { login }
+              name
+              url
+              description
+              stargazerCount
+              isArchived
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+    """
+    results = []
+    cursor = None
+    page = 0
+    while True:
+        page += 1
+        variables = {
+            "q": search_q,
+            "first": 100,
+            "after": cursor,
+        }
+        data = graphql(session, query, variables)
+        if data is None:
+            break
+        search_data = data["search"]
+        edges = search_data["edges"]
+        if not edges:
+            break
+        for edge in edges:
+            node = edge["node"]
+            if not node:
+                continue
+            results.append({
+                "full_name": node["nameWithOwner"],
+                "owner": node["owner"]["login"],
+                "repo": node["name"],
+                "stars": node["stargazerCount"],
+                "description": node.get("description") or "",
+                "html_url": node["url"],
+                "archived": node["isArchived"],
+            })
+        stderr(
+            f"  page {page}: got {len(edges)} repos "
+            f"(total so far: {len(results)})"
+        )
+        page_info = search_data["pageInfo"]
+        if not page_info["hasNextPage"]:
+            break
+        cursor = page_info["endCursor"]
+        time.sleep(1)
+    return results
+
+
+# --- Fetch README ---
+
+
+def fetch_readmes(session, repos):
+    """Batch-fetch README content for a list of repos.
+
+    Returns a dict mapping full_name to README text
+    (or empty string if not found).
+    """
+    result = {}
+    total = len(repos)
+    stderr(f"  fetching READMEs ({total} repos)...")
+    for start in range(0, total, _BATCH_SIZE):
+        batch = repos[start : start + _BATCH_SIZE]
+        stderr(f"    batch {start + 1}-{start + len(batch)}/{total}...")
+        repo_parts = []
+        for i, c in enumerate(batch):
+            # Try both README.md and README.rst.
+            repo_parts.append(
+                f"  repo{i}: repository("
+                f'owner: "{c["owner"]}", '
+                f'name: "{c["repo"]}") {{\n'
+                f"    readmeMd: object("
+                f'expression: "HEAD:README.md") {{\n'
+                f"      ... on Blob {{ text }}\n"
+                f"    }}\n"
+                f"    readmeRst: object("
+                f'expression: "HEAD:README.rst") {{\n'
+                f"      ... on Blob {{ text }}\n"
+                f"    }}\n"
+                f"  }}"
+            )
+        query = "query {\n" + "\n".join(repo_parts) + "\n}"
+        data = graphql(session, query)
+        if data is None:
+            for c in batch:
+                result[c["full_name"]] = ""
+            continue
+        for i, c in enumerate(batch):
+            repo_data = data.get(f"repo{i}")
+            text = ""
+            if repo_data:
+                for key in ("readmeMd", "readmeRst"):
+                    obj = repo_data.get(key)
+                    if obj and "text" in obj:
+                        text = obj["text"]
+                        break
+            result[c["full_name"]] = text
+    return result
+
+
+# --- Fetch dep files ---
+
+
+def _build_fixed_dep_fragment():
+    """Build GraphQL fields for fetching fixed dep files
+    + requirements/ dir listing.
+    """
+    fields = []
+    for dep_file, alias in _FIXED_DEP_FILES.items():
+        fields.append(
+            f"    {alias}: object("
+            f'expression: "HEAD:{dep_file}") {{\n'
+            f"      ... on Blob {{ text }}\n"
+            f"    }}"
+        )
+    # Also fetch the requirements/ directory listing.
+    fields.append(
+        "    requirementsDir: object("
+        "expression: \"HEAD:requirements\") {\n"  # noqa: Q003
+        "      ... on Tree { entries { name } }\n"
+        "    }"
+    )
+    return "\n".join(fields)
+
+
+def _make_req_alias(filename):
+    """Turn a requirements/*.txt filename into a GraphQL alias."""
+    base = filename.replace(".txt", "")
+    base = re.sub(r"[^a-zA-Z0-9]", "_", base)
+    return f"req_{base}"
+
+
+def fetch_dep_files(session, repos):
+    """Batch-fetch dependency files for a list of repos.
+
+    Phase 1: fetch fixed dep files + requirements/ dir listing.
+    Phase 2: for repos with a requirements/ dir, fetch all *.txt
+    files found there.
+
+    Returns a dict mapping full_name to a dict of
+    {dep_file: content}.
+    """
+    fixed_fragment = _build_fixed_dep_fragment()
+    result = {}
+    # Track which repos have requirements/ entries.
+    req_dir_entries = {}  # full_name -> [filename, ...]
+
+    # --- Phase 1: fixed files + dir listing ---
+    total = len(repos)
+    stderr(
+        "  phase 1: fixed files + requirements/ dir listing "
+        f"({total} repos)..."
+    )
+    for start in range(0, total, _BATCH_SIZE):
+        batch = repos[start : start + _BATCH_SIZE]
+        stderr(f"    batch {start + 1}-{start + len(batch)}/{total}...")
+        repo_parts = []
+        for i, c in enumerate(batch):
+            repo_parts.append(
+                f"  repo{i}: repository("
+                f'owner: "{c["owner"]}", '
+                f'name: "{c["repo"]}") {{\n'
+                f"{fixed_fragment}\n"
+                f"  }}"
+            )
+        query = "query {\n" + "\n".join(repo_parts) + "\n}"
+        data = graphql(session, query)
+        if data is None:
+            for c in batch:
+                result[c["full_name"]] = {}
+            continue
+        for i, c in enumerate(batch):
+            repo_data = data.get(f"repo{i}")
+            files = {}
+            if repo_data:
+                for dep_file, alias in _FIXED_DEP_FILES.items():
+                    obj = repo_data.get(alias)
+                    if obj and "text" in obj:
+                        files[dep_file] = obj["text"]
+                # Check for requirements/ directory.
+                req_obj = repo_data.get("requirementsDir")
+                if req_obj and "entries" in req_obj:
+                    txt_files = [
+                        e["name"]
+                        for e in req_obj["entries"]
+                        if e["name"].endswith(".txt")
+                    ]
+                    if txt_files:
+                        req_dir_entries[c["full_name"]] = txt_files
+            result[c["full_name"]] = files
+
+    # --- Phase 2: fetch discovered requirements/*.txt files ---
+    if req_dir_entries:
+        # Collect repos that need follow-up.
+        need_fetch = [c for c in repos if c["full_name"] in req_dir_entries]
+        stderr(
+            "  phase 2: fetching requirements/*.txt from "
+            f"{len(need_fetch)} repos..."
+        )
+        for start in range(0, len(need_fetch), _BATCH_SIZE):
+            batch = need_fetch[start : start + _BATCH_SIZE]
+            repo_parts = []
+            for i, c in enumerate(batch):
+                txt_files = req_dir_entries[c["full_name"]]
+                file_fields = []
+                for fname in txt_files:
+                    alias = _make_req_alias(fname)
+                    path = f"requirements/{fname}"
+                    file_fields.append(
+                        f"      {alias}: object("
+                        f'expression: "HEAD:{path}") {{\n'
+                        f"        ... on Blob {{ text }}\n"
+                        f"      }}"
+                    )
+                repo_parts.append(
+                    f"  repo{i}: repository("
+                    f'owner: "{c["owner"]}", '
+                    f'name: "{c["repo"]}") {{\n'
+                    + "\n".join(file_fields)
+                    + "\n  }"
+                )
+            query = "query {\n" + "\n".join(repo_parts) + "\n}"
+            data = graphql(session, query)
+            if data is None:
+                continue
+            for i, c in enumerate(batch):
+                repo_data = data.get(f"repo{i}")
+                if not repo_data:
+                    continue
+                txt_files = req_dir_entries[c["full_name"]]
+                for fname in txt_files:
+                    alias = _make_req_alias(fname)
+                    obj = repo_data.get(alias)
+                    if obj and "text" in obj:
+                        path = f"requirements/{fname}"
+                        result[c["full_name"]][path] = obj["text"]
+
+    return result
+
+
+# --- Classify ---
+
+
+def classify_dependency(file_contents):
+    """Classify the dependency type from fetched file contents.
+
+    Returns a tuple (status, detail) where status is one of:
+    - "direct"    : PROJECT in install/runtime dependencies
+    - "build"     : PROJECT in build/setup dependencies only
+    - "test"      : PROJECT in test/dev dependencies only
+    - "optional"  : PROJECT in optional/extras dependencies
+    - "no"        : not found in any dependency file
+    """
+    pat = re.escape(PROJECT)
+    found_in = []
+    for dep_file, content in file_contents.items():
+        if content is None:
+            continue
+        if not re.search(r"\b" + pat + r"\b", content):
+            continue
+        found_in.append(dep_file)
+
+    if not found_in:
+        return "no", ""
+
+    # Classify the dependency type based on which files it was
+    # found in.
+    for f in found_in:
+        content = file_contents[f]
+        if f == "pyproject.toml":
+            if re.search(
+                r"\[project\].*?dependencies\s*=\s*\[.*?" + pat,
+                content,
+                re.DOTALL,
+            ):
+                return "direct", f
+            if re.search(
+                r"\[tool\.poetry\.dependencies\].*?" + pat,
+                content,
+                re.DOTALL,
+            ):
+                return "direct", f
+            if re.search(
+                r"\[build-system\].*?requires\s*=\s*\[.*?" + pat,
+                content,
+                re.DOTALL,
+            ):
+                return "build", f
+            if r"optional-dependencies" in content:
+                return "optional", f
+            if re.search(r"test|dev", content):
+                return "test", f
+            return "direct", f
+        elif f == "setup.py":
+            if re.search(r"install_requires.*?" + pat, content, re.DOTALL):
+                return "direct", f
+            if re.search(r"setup_requires.*?" + pat, content, re.DOTALL):
+                return "build", f
+            if re.search(r"tests_require.*?" + pat, content, re.DOTALL):
+                return "test", f
+            if re.search(r"extras_require.*?" + pat, content, re.DOTALL):
+                return "optional", f
+            return "direct", f
+        elif f == "setup.cfg":
+            if re.search(r"install_requires.*?" + pat, content, re.DOTALL):
+                return "direct", f
+            if re.search(r"extras_require.*?" + pat, content, re.DOTALL):
+                return "optional", f
+            return "direct", f
+        elif "requirements" in f:
+            return "direct", f
+
+    return "direct", ", ".join(found_in)
+
+
+# --- Misc ---
+
+
+def make_subst_name(full_name):
+    """Turn 'owner/repo' into a substitution-safe base name."""
+    name = full_name.split("/")[1]
+    # Replace underscores and dots with hyphens.
+    name = re.sub(r"[_.]", "-", name)
+    return name.lower()
+
+
+def tier_label(stars):
+    if stars >= 40000:
+        return 1
+    elif stars >= 10000:
+        return 2
+    else:
+        return 3
+
+
+def generate_rst(projects):
+    """Generate RST output for adoption.rst."""
+    tiers = {1: [], 2: [], 3: []}
+    for p in projects:
+        t = tier_label(p["stars"])
+        tiers[t].append(p)
+
+    lines = []
+    star_badges = []
+    logo_images = []
+
+    tier_headers = {
+        1: "Tier 1 (>40k GitHub stars)",
+        2: "Tier 2 (10k-40k GitHub stars)",
+        3: "Tier 3 (1k-10k GitHub stars)",
+    }
+
+    for tier_num in (1, 2, 3):
+        tier_projects = sorted(tiers[tier_num], key=lambda x: -x["stars"])
+        if not tier_projects:
+            continue
+
+        header = tier_headers[tier_num]
+        lines.extend([
+            header,
+            "-" * len(header),
+            "",
+            ".. list-table::",
+            "   :header-rows: 1",
+            "   :widths: 18 42 12 28",
+            "",
+            "   * - Project",
+            "     - Description",
+            "     - Stars",
+            "     - Usage",
+        ])
+
+        for p in tier_projects:
+            name = make_subst_name(p["full_name"])
+            owner = p["owner"]
+            repo = p["repo"]
+            full = p["full_name"]
+            desc = p["description"]
+            # Truncate description to fit RST table.
+            if len(desc) > 60:
+                desc = desc[:57] + "..."
+            dep_type = p.get("dep_type", "")
+            usage = ""
+            if dep_type == "build":
+                usage = "build-time dependency"
+            elif dep_type == "test":
+                usage = "test dependency"
+            elif dep_type == "optional":
+                usage = "optional dependency"
+
+            proj_link = f"|{name}-logo| `{repo} <https://github.com/{full}>`__"
+            lines.extend([
+                f"   * - {proj_link}",
+                f"     - {desc}",
+                f"     - |{name}-stars|",
+                f"     - {usage}",
+            ])
+
+            star_badges.append(
+                f".. |{name}-stars| image:: "
+                "https://img.shields.io/github/stars/"
+                f"{full}.svg?style=plastic"
+            )
+
+            logo_images.append(
+                f".. |{name}-logo| image:: "
+                f"https://github.com/{owner}.png?s=28 :height: 28"
+            )
+
+        lines.append("")
+
+    # Combine everything.
+    output = []
+    output.extend(lines)
+    output.extend([
+        "",
+        ".. Star badges",
+        "",
+    ])
+    output.extend(star_badges)
+    output.extend([
+        "",
+        ".. Logo images",
+        "",
+    ])
+    output.extend(logo_images)
+    return "\n".join(output)
+
+
+# --- Cache ---
+
+
+def load_cache():
+    """Load cached data from disk.
+
+    Returns a dict with keys: min_stars, repos, readmes, dep_files.
+    Returns None if cache is missing, stale, or --no-cache is set.
+    The cache is invalidated if the current MIN_STARS is lower
+    than the min_stars used to build the cache (we'd be missing
+    repos).
+    """
+    if NO_CACHE:
+        return None
+    if not os.path.exists(_CACHE_FILE):
+        return None
+    try:
+        with open(_CACHE_FILE, "rb") as f:
+            data = pickle.load(f)
+    except (OSError, pickle.UnpicklingError, EOFError) as err:
+        stderr(f"  cache load error: {err}")
+        return None
+    cached_min_stars = data.get("min_stars", 0)
+    if cached_min_stars > MIN_STARS:
+        stderr(
+            f"  cache built with min_stars={cached_min_stars}, "
+            f"but current min_stars={MIN_STARS}; ignoring cache"
+        )
+        return None
+    stderr(
+        f"  loaded cache ({len(data.get('repos', []))} repos, "
+        f"min_stars={cached_min_stars})"
+    )
+    return data
+
+
+def save_cache(repos, readmes, dep_files):
+    """Save fetched data to disk."""
+    data = {
+        "min_stars": MIN_STARS,
+        "repos": repos,
+        "readmes": readmes,
+        "dep_files": dep_files,
+    }
+    with open(_CACHE_FILE, "wb") as f:
+        pickle.dump(data, f)
+    stderr(f"  saved cache to {_CACHE_FILE}")
+
+
+# --- CLI ---
+
+
+def parse_cli():
+    """Parse CLI arguments and set global constants."""
+    global PROJECT, MIN_STARS, MAX_STARS, TOKEN, SKIP, INREADME, INDEPS, NO_CACHE  # noqa: E501
+
+    parser = argparse.ArgumentParser(
+        description=(
+            "Find notable GitHub projects using a given "
+            "project as a dependency."
+        )
+    )
+    parser.add_argument(
+        "--project",
+        required=True,
+        help="Project name to search for (e.g. 'psutil').",
+    )
+    parser.add_argument(
+        "--min-stars",
+        type=int,
+        default=300,
+        help="Minimum GitHub stars to consider (default: 300).",
+    )
+    parser.add_argument(
+        "--max-stars",
+        type=int,
+        default=0,
+        help="Maximum GitHub stars (default: no limit).",
+    )
+    parser.add_argument(
+        "--token",
+        required=True,
+        help="Path to a file containing the GitHub token.",
+    )
+    parser.add_argument(
+        "--skip",
+        nargs="*",
+        default=[],
+        help="Repos URLs to skip.",
+    )
+    parser.add_argument(
+        "--skip-file-urls",
+        default=None,
+        help="Path to file with GitHub repo URLs to skip (found via regex).",
+    )
+    parser.add_argument(
+        "--inreadme",
+        action="store_true",
+        default=False,
+        help="Filter: PROJECT must be mentioned in README.",
+    )
+    parser.add_argument(
+        "--indeps",
+        action="store_true",
+        default=False,
+        help=(
+            "Filter: PROJECT must be mentioned in dep files "
+            "(pyproject.toml, setup.py, setup.cfg, "
+            "requirements*.txt)."
+        ),
+    )
+    parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        default=False,
+        help="Force fresh fetch, ignoring cached data.",
+    )
+    args = parser.parse_args()
+
+    if not args.inreadme and not args.indeps:
+        parser.error("at least one of --inreadme, --indeps is required")
+
+    PROJECT = args.project
+    MIN_STARS = args.min_stars
+    MAX_STARS = args.max_stars
+    with open(os.path.expanduser(args.token)) as f:
+        TOKEN = f.read().strip()
+    INREADME = args.inreadme
+    INDEPS = args.indeps
+
+    SKIP = set(args.skip)
+    SKIP.add("https://github.com/vinta/awesome-python")
+    NO_CACHE = args.no_cache
+    if args.skip_file_urls:
+        path = args.skip_file_urls
+        with open(path) as f:
+            text = f.read()
+        urls = [
+            m.group(1)
+            for m in re.finditer(
+                r"(https://github\.com/[\w.-]+/[\w.-]+)", text
+            )
+        ]
+        SKIP.update(urls)
+
+
+# --- Main ---
+
+
+def main():
+    parse_cli()
+    session = get_session(TOKEN)
+
+    cached = load_cache()
+    if cached is not None:
+        repos = cached["repos"]
+        readmes = cached.get("readmes", {})
+        dep_files = cached.get("dep_files", {})
+        need_save = False
+    else:
+        repos = None
+        readmes = {}
+        dep_files = {}
+        need_save = True
+
+    # Step 1: enumerate all popular Python repos.
+    if repos is None:
+        stderr(f"Enumerating Python repos (>={MIN_STARS} stars)...")
+        repos = enumerate_repos(session)
+        stderr(f"Found {len(repos)} repos.")
+
+    # Filter out skipped and archived repos.
+    filtered = []
+    for repo in repos:
+        if repo["html_url"] in SKIP:
+            print(f"skipping {yellow(repo['html_url'])}")
+            continue
+        if repo["archived"]:
+            print(f"skipping {yellow(repo['html_url'])}")
+            continue
+        filtered.append(repo)
+    active_repos = filtered
+    stderr(f"After skip/archive filtering: {len(active_repos)} repos.")
+
+    # Step 2: fetch data needed for the requested filters.
+    # Only fetch what's missing from cache.
+    if INREADME and not readmes:
+        stderr("Fetching READMEs...")
+        readmes = fetch_readmes(session, active_repos)
+        need_save = True
+    if INDEPS and not dep_files:
+        stderr("Fetching dependency files...")
+        dep_files = fetch_dep_files(session, active_repos)
+        need_save = True
+
+    if need_save:
+        save_cache(repos, readmes, dep_files)
+
+    # Step 3: apply filters.
+    confirmed = []
+    for repo in active_repos:
+        name = repo["full_name"]
+        pat = re.escape(PROJECT)
+
+        if INREADME:
+            readme = readmes.get(name, "")
+            if not re.search(r"\b" + pat + r"\b", readme):
+                continue
+
+        if INDEPS:
+            files = dep_files.get(name, {})
+            status, detail = classify_dependency(files)
+            if status == "no":
+                continue
+            repo["dep_type"] = status
+            repo["dep_detail"] = detail
+
+        confirmed.append(repo)
+
+    stderr()
+    stderr(f"Confirmed {len(confirmed)} projects:")
+    for c in confirmed:
+        stderr(f"  {c['stars']:,} stars: {green(c['html_url'])}")
+
+    # Generate RST.
+    if confirmed:
+        ans = input("\nGenerate RsT content? [y/N] ").strip().lower()
+        if ans in {"y", "yes"}:
+            rst = generate_rst(confirmed)
+            print(rst)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/internal/docs/new_blog_post.py b/scripts/internal/docs/new_blog_post.py
new file mode 100755
index 0000000000..b887bf9ad5
--- /dev/null
+++ b/scripts/internal/docs/new_blog_post.py
@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Create a skeleton RST file for a new blog post at
+docs/blog/<year>/<slug>.rst. Invoke via `make blog-post` from docs/.
+"""
+
+import argparse
+import datetime
+import pathlib
+import sys
+
+HERE = pathlib.Path(__file__).resolve().parent
+REPO_ROOT = HERE.parent.parent.parent
+AUTHOR = "Giampaolo Rodola"
+
+SLUG = ""
+TITLE = ""
+TAGS = ""
+
+
+def parse_cli():
+    global SLUG, TITLE, TAGS
+
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "slug", help="URL slug, e.g. 'event-driven-process-waiting'"
+    )
+    parser.add_argument(
+        "--title",
+        default=None,
+        help=(
+            "Post title. If omitted, derived from the slug, e.g. "
+            "'my-new-post' -> 'My new post'."
+        ),
+    )
+    parser.add_argument(
+        "--tags",
+        default="",
+        help="Comma-separated tags, e.g. 'performance, linux'",
+    )
+    args = parser.parse_args()
+
+    SLUG = args.slug
+    TITLE = args.title or args.slug.replace("-", " ").capitalize()
+    TAGS = args.tags
+
+
+SKELETON = """\
+.. post:: {date}
+   :tags: {tags}
+   :author: {author}
+   :exclude:
+
+   One-line summary for listing cards and Atom feeds.
+
+{title}
+{underline}
+
+Opening paragraph.
+
+Section
+-------
+
+Body.
+"""
+
+
+def main():
+    parse_cli()
+    today = datetime.date.today()
+    year_dir = REPO_ROOT / "docs" / "blog" / str(today.year)
+    year_dir.mkdir(parents=True, exist_ok=True)
+    path = year_dir / f"{SLUG}.rst"
+    if path.exists():
+        print(f"error: {path} already exists", file=sys.stderr)
+        return 1
+    content = SKELETON.format(
+        date=today.isoformat(),
+        tags=TAGS,
+        author=AUTHOR,
+        title=TITLE,
+        underline="=" * len(TITLE),
+    )
+    path.write_text(content)
+    print(f"created: {path}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/internal/docs/refresh_adoption_stats.py b/scripts/internal/docs/refresh_adoption_stats.py
new file mode 100755
index 0000000000..f0c6e3e5f4
--- /dev/null
+++ b/scripts/internal/docs/refresh_adoption_stats.py
@@ -0,0 +1,154 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can
+# be found in the LICENSE file.
+
+"""Refresh the dynamic numbers in docs/adoption.rst and README.rst
+(monthly downloads and GitHub repository dependents).
+"""
+
+import argparse
+import json
+import pathlib
+import re
+import sys
+import time
+import urllib.error
+import urllib.request
+
+ROOT = pathlib.Path(__file__).resolve().parents[3]
+TIMEOUT = 5
+RETRIES = 3
+BACKOFF = 5
+TARGETS = [
+    ROOT / "docs/adoption.rst",
+    ROOT / "docs/index.rst",
+    ROOT / "README.rst",
+]
+DEPENDENTS_URL = "https://github.com/giampaolo/psutil/network/dependents"
+DOWNLOADS_URL = "https://pypistats.org/api/packages/psutil/recent"
+
+
+def fetch(url, accept="text/html"):
+    req = urllib.request.Request(
+        url,
+        headers={
+            "User-Agent": (
+                "Mozilla/5.0 (X11; Linux x86_64) "
+                "AppleWebKit/537.36 (KHTML, like Gecko) "
+                "Chrome/120.0 Safari/537.36"
+            ),
+            "Accept": accept,
+        },
+    )
+    for attempt in range(1, RETRIES + 1):
+        try:
+            with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
+                return resp.read().decode("utf-8", errors="replace")
+        except urllib.error.HTTPError as err:
+            if err.code != 429 or attempt == RETRIES:
+                sys.exit(
+                    f"error: {url} returned HTTP {err.code} ({err.reason})"
+                )
+            wait = int(err.headers.get("Retry-After") or BACKOFF * attempt)
+            print(f"  rate limited, retrying in {wait}s ...", file=sys.stderr)
+            time.sleep(wait)
+
+
+def round_millions(n):
+    """338018876 -> '330+ million'. Floor to 10M."""
+    millions = (n // 10_000_000) * 10
+    return f"{millions}+ million"
+
+
+def floor_to(n, bucket):
+    """Floor n to a multiple of `bucket`. 769412, 10_000 -> 760000."""
+    return (n // bucket) * bucket
+
+
+def fetch_monthly_downloads():
+    data = json.loads(fetch(DOWNLOADS_URL, accept="application/json"))
+    return data["data"]["last_month"]
+
+
+def fetch_github_dependents():
+    """Scrape the 'Used by' repository count from GitHub's dependents
+    graph.
+    """
+    html = fetch(DEPENDENTS_URL)
+    repos_re = re.search(r"([\d,]+)\s+Repositories", html)
+    if not repos_re:
+        sys.exit("could not parse GitHub dependents page")
+    return int(repos_re.group(1).replace(",", ""))
+
+
+def parse_cli():
+    parser = argparse.ArgumentParser(
+        description="Refresh adoptions dynamic numbers"
+    )
+    parser.parse_args()
+
+
+def main():
+    parse_cli()
+    print(f"fetching {DOWNLOADS_URL} ...")
+    monthly = fetch_monthly_downloads()
+    print(f"  monthly downloads: {monthly:,}")
+
+    print(f"fetching {DEPENDENTS_URL} ...")
+    repos = fetch_github_dependents()
+    print(f"  repos:    {repos:,}")
+
+    new_downloads = round_millions(monthly)  # "330+ million"
+    new_repos = f"{floor_to(repos, 10_000):,}+"  # "760,000+"
+
+    subs = [
+        # adoption.rst / README.rst: **330+ million** downloads ...
+        (
+            re.compile(r"\*\*\d+\+\s+million\*\*"),
+            f"**{new_downloads}**",
+        ),
+        (
+            re.compile(r"\*\*[\d,]+\+\*\*(?=\s+`?GitHub repositories)"),
+            f"**{new_repos}**",
+        ),
+        # index.rst home-stats banner.
+        (
+            re.compile(
+                r'(<span class="home-stat-num">)\d+\+\s+million(</span>)'
+            ),
+            rf"\g<1>{new_downloads}\g<2>",
+        ),
+        (
+            re.compile(
+                r'(<span class="home-stat-num">)[\d,]+\+(</span>\s*\n\s*'
+                r'<span class="home-stat-label">GitHub)'
+            ),
+            rf"\g<1>{new_repos}\g<2>",
+        ),
+    ]
+
+    totals = [0] * len(subs)
+    for path in TARGETS:
+        text = path.read_text()
+        new_text = text
+        for i, (pat, repl) in enumerate(subs):
+            new_text, n = pat.subn(repl, new_text)
+            totals[i] += n
+        if new_text == text:
+            print(f"  {path.relative_to(ROOT)}: already current")
+        else:
+            path.write_text(new_text)
+            print(f"  {path.relative_to(ROOT)}: updated")
+
+    for i, (pat, _) in enumerate(subs):
+        if totals[i] == 0:
+            sys.exit(
+                f"no file matched {pat.pattern!r} "
+                "(expected at least 1 match across all targets)"
+            )
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/internal/docs/rst_unused_targets.py b/scripts/internal/docs/rst_unused_targets.py
new file mode 100755
index 0000000000..b9bac47f9e
--- /dev/null
+++ b/scripts/internal/docs/rst_unused_targets.py
@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can
+# be found in the LICENSE file.
+
+"""Check .rst files for URL hyperlink targets that are defined but
+never referenced.
+
+Undefined references (backtick refs pointing at a missing target) are
+already caught by Sphinx during the docs build, so this script only
+covers the unused-target case.
+"""
+
+import argparse
+import re
+import sys
+
+# .. _`Foo`: https://...   or   .. _foo: https://...
+RE_URL_TARGET = re.compile(r"^\.\. _`?([^`\n:]+)`?:\s*https?://", re.MULTILINE)
+
+# `Foo Bar`_  but NOT  `text <url>`_  and NOT  `text`__
+RE_BACKTICK_REF = re.compile(r"`([^`<\n]+)`_(?!_)")
+
+# bare ref:  BPO-12442_
+RE_BARE_REF = re.compile(r"(?<![`\w])([A-Za-z][\w-]*)_(?!\w)")
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("files", nargs="+", metavar="FILE")
+    args = parser.parse_args()
+
+    # URL targets are file-scoped: one defined in foo.rst can't be
+    # referenced from bar.rst, so check each file on its own.
+    errors = []
+    for path in args.files:
+        with open(path) as f:
+            text = f.read()
+        used = set()
+        for regex in (RE_BACKTICK_REF, RE_BARE_REF):
+            used.update(
+                m.group(1).strip().lower() for m in regex.finditer(text)
+            )
+        for m in RE_URL_TARGET.finditer(text):
+            name = m.group(1).strip()
+            if name.lower() not in used:
+                lineno = text.count("\n", 0, m.start()) + 1
+                msg = f"unreferenced hyperlink target: {name!r}"
+                errors.append((path, lineno, msg))
+
+    for path, lineno, msg in sorted(errors):
+        print(f"{path}:{lineno}: {msg}")
+    if errors:
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/internal/download_wheels.py b/scripts/internal/download_wheels.py
new file mode 100755
index 0000000000..2417e3ba50
--- /dev/null
+++ b/scripts/internal/download_wheels.py
@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009 Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Script which downloads wheel files hosted on GitHub:
+https://github.com/giampaolo/psutil/actions
+It needs an access token string generated from personal GitHub profile:
+https://github.com/settings/tokens
+The token must be created with at least "public_repo" scope/rights.
+If you lose it, just generate a new token.
+REST API doc:
+https://developer.github.com/v3/actions/artifacts/.
+"""
+
+import argparse
+import json
+import os
+import pathlib
+import shutil
+import sys
+import zipfile
+
+import requests
+
+ROOT_DIR = pathlib.Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(ROOT_DIR))
+from _bootstrap import load_module  # noqa: E402
+
+_common = load_module(ROOT_DIR / "psutil" / "_common.py")
+bytes2human = _common.bytes2human
+
+USER = "giampaolo"
+PROJECT = "psutil"
+OUTFILE = "wheels-github.zip"
+ARTIFACT_NAME = "wheels"
+TOKEN = ""
+TIMEOUT = 30
+
+
+def safe_rmpath(path):
+    """Convenience function for removing temporary test files or dirs."""
+    if os.path.isdir(path):
+        shutil.rmtree(path)
+    else:
+        try:
+            os.remove(path)
+        except FileNotFoundError:
+            pass
+
+
+def get_artifacts():
+    base_url = f"https://api.github.com/repos/{USER}/{PROJECT}"
+    url = base_url + "/actions/artifacts"
+    res = requests.get(
+        url=url, headers={"Authorization": f"token {TOKEN}"}, timeout=TIMEOUT
+    )
+    res.raise_for_status()
+    data = json.loads(res.content)
+    return data
+
+
+def download_zip(url):
+    print("downloading: " + url)
+    res = requests.get(
+        url=url, headers={"Authorization": f"token {TOKEN}"}, timeout=TIMEOUT
+    )
+    res.raise_for_status()
+    totbytes = 0
+    with open(OUTFILE, 'wb') as f:
+        for chunk in res.iter_content(chunk_size=16384):
+            f.write(chunk)
+            totbytes += len(chunk)
+    print(f"got {OUTFILE}, size {bytes2human(totbytes)})")
+
+
+def run():
+    data = get_artifacts()
+    artifacts = [x for x in data['artifacts'] if x['name'] == ARTIFACT_NAME]
+    if not artifacts:
+        return sys.exit(f"no artifact named {ARTIFACT_NAME!r} was found")
+    download_zip(artifacts[0]['archive_download_url'])
+    os.makedirs('dist', exist_ok=True)
+    with zipfile.ZipFile(OUTFILE, 'r') as zf:
+        zf.extractall('dist')
+
+
+def main():
+    global TOKEN
+    parser = argparse.ArgumentParser(description='GitHub wheels downloader')
+    parser.add_argument('--token')
+    parser.add_argument('--tokenfile')
+    args = parser.parse_args()
+
+    if args.tokenfile:
+        with open(os.path.expanduser(args.tokenfile)) as f:
+            TOKEN = f.read().strip()
+    elif args.token:
+        TOKEN = args.token
+    else:
+        return sys.exit('specify --token or --tokenfile args')
+
+    try:
+        run()
+    finally:
+        safe_rmpath(OUTFILE)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/internal/find_broken_links.py b/scripts/internal/find_broken_links.py
new file mode 100755
index 0000000000..0ed6911a97
--- /dev/null
+++ b/scripts/internal/find_broken_links.py
@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola', Himanshu Shekhar.
+# All rights reserved. Use of this source code is governed by a
+# BSD-style license that can be found in the LICENSE file.
+
+"""Checks for broken links in file names specified as command line
+parameters.
+
+There are a ton of a solutions available for validating URLs in string
+using regex, but less for searching, of which very few are accurate.
+This snippet is intended to just do the required work, and avoid
+complexities. Django Validator has pretty good regex for validation,
+but we have to find urls instead of validating them (REFERENCES [7]).
+There's always room for improvement.
+
+Method:
+* Match URLs using regex (REFERENCES [1]])
+* Some URLs need to be fixed, as they have < (or) > due to inefficient
+  regex.
+* Remove duplicates (because regex is not 100% efficient as of now).
+* Check validity of URL, using HEAD request. (HEAD to save bandwidth)
+  Uses requests module for others are painful to use. REFERENCES[9]
+  Handles redirects, http, https, ftp as well.
+
+REFERENCES:
+Using [1] with some modifications for including ftp
+[1] http://stackoverflow.com/a/6883094/5163807
+[2] http://stackoverflow.com/a/31952097/5163807
+[3] http://daringfireball.net/2010/07/improved_regex_for_matching_urls
+[4] https://mathiasbynens.be/demo/url-regex
+[5] https://github.com/django/django/blob/master/django/core/validators.py
+[6] https://data.iana.org/TLD/tlds-alpha-by-domain.txt
+[7] https://codereview.stackexchange.com/questions/19663/http-url-validating
+[8] https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/HEAD
+[9] http://docs.python-requests.org/
+
+Author: Himanshu Shekhar <https://github.com/himanshub16> (2017)
+"""
+
+import argparse
+import concurrent.futures
+import functools
+import os
+import re
+import sys
+import traceback
+
+import requests
+
+REGEX = re.compile(
+    r'(?:http|ftp|https)?://'
+    r'(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
+)
+REQUEST_TIMEOUT = 15
+# There are some status codes sent by websites on HEAD request.
+# Like 503 by Microsoft, and 401 by Apple
+# They need to be sent GET request
+RETRY_STATUSES = [503, 401, 403]
+
+
+def sanitize_url(url):
+    url = url.rstrip(',')
+    url = url.rstrip('.')
+    url = url.lstrip('(')
+    url = url.rstrip(')')
+    url = url.lstrip('[')
+    url = url.rstrip(']')
+    url = url.lstrip('<')
+    url = url.rstrip('>')
+    return url
+
+
+def find_urls(s):
+    matches = REGEX.findall(s) or []
+    return list({sanitize_url(x) for x in matches})
+
+
+def parse_rst(fname):
+    """Look for links in a .rst file."""
+    with open(fname) as f:
+        text = f.read()
+    return find_urls(text)
+
+
+def parse_py(fname):
+    """Look for links in a .py file."""
+    with open(fname) as f:
+        lines = f.readlines()
+    urls = set()
+    for i, line in enumerate(lines):
+        for url in find_urls(line):
+            # comment block
+            if line.lstrip().startswith('# '):
+                subidx = i + 1
+                while True:
+                    nextline = lines[subidx].strip()
+                    if re.match(r"^#     .+", nextline):
+                        url += nextline[1:].strip()
+                    else:
+                        break
+                    subidx += 1
+            urls.add(url)
+    return list(urls)
+
+
+def parse_c(fname):
+    """Look for links in a .py file."""
+    with open(fname) as f:
+        lines = f.readlines()
+    urls = set()
+    for i, line in enumerate(lines):
+        for url in find_urls(line):
+            # comment block //
+            if line.lstrip().startswith('// '):
+                subidx = i + 1
+                while True:
+                    nextline = lines[subidx].strip()
+                    if re.match(r"^//     .+", nextline):
+                        url += nextline[2:].strip()
+                    else:
+                        break
+                    subidx += 1
+            # comment block /*
+            elif line.lstrip().startswith('* '):
+                subidx = i + 1
+                while True:
+                    nextline = lines[subidx].strip()
+                    if re.match(r'^\*     .+', nextline):
+                        url += nextline[1:].strip()
+                    else:
+                        break
+                    subidx += 1
+            urls.add(url)
+    return list(urls)
+
+
+def parse_generic(fname):
+    with open(fname, errors='ignore') as f:
+        text = f.read()
+    return find_urls(text)
+
+
+def get_urls(fname):
+    """Extracts all URLs in fname and return them as a list."""
+    if fname.endswith('.rst'):
+        return parse_rst(fname)
+    elif fname.endswith('.py'):
+        return parse_py(fname)
+    elif fname.endswith(('.c', '.h')):
+        return parse_c(fname)
+    else:
+        with open(fname, errors='ignore') as f:
+            if f.readline().strip().startswith('#!/usr/bin/env python3'):
+                return parse_py(fname)
+        return parse_generic(fname)
+
+
+@functools.lru_cache
+def validate_url(url):
+    """Validate the URL by attempting an HTTP connection.
+    Makes an HTTP-HEAD request for each URL.
+    """
+    try:
+        res = requests.head(url, timeout=REQUEST_TIMEOUT)
+        # some websites deny 503, like Microsoft
+        # and some send 401, like Apple, observations
+        if (not res.ok) and (res.status_code in RETRY_STATUSES):
+            res = requests.get(url, timeout=REQUEST_TIMEOUT)
+        return res.ok
+    except requests.exceptions.RequestException:
+        return False
+
+
+def parallel_validator(urls):
+    """Validates all urls in parallel
+    urls: tuple(filename, url).
+    """
+    fails = []  # list of tuples (filename, url)
+    current = 0
+    total = len(urls)
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        fut_to_url = {
+            executor.submit(validate_url, url[1]): url for url in urls
+        }
+        for fut in concurrent.futures.as_completed(fut_to_url):
+            current += 1
+            sys.stdout.write(f"\r{current} / {total}")
+            sys.stdout.flush()
+            fname, url = fut_to_url[fut]
+            try:
+                ok = fut.result()
+            except Exception:  # noqa: BLE001
+                fails.append((fname, url))
+                print()
+                print(f"warn: error while validating {url}", file=sys.stderr)
+                traceback.print_exc()
+            else:
+                if not ok:
+                    fails.append((fname, url))
+
+    print()
+    return fails
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument('files', nargs="+")
+    parser.parse_args()
+    args = parser.parse_args()
+
+    all_urls = []
+    for fname in args.files:
+        urls = get_urls(fname)
+        if urls:
+            print(f"{len(urls):4} {fname}")
+            all_urls.extend((fname, url) for url in urls)
+
+    fails = parallel_validator(all_urls)
+    if not fails:
+        print("all links are valid; cheers!")
+    else:
+        for fail in fails:
+            fname, url = fail
+            print(f"{fname:<30}: {url} ")
+        print('-' * 20)
+        print(f"total: {len(fails)} fails!")
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    except (KeyboardInterrupt, SystemExit):
+        os._exit(0)
diff --git a/scripts/internal/generate_manifest.py b/scripts/internal/generate_manifest.py
new file mode 100755
index 0000000000..f6549ec58c
--- /dev/null
+++ b/scripts/internal/generate_manifest.py
@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009 Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Generate MANIFEST.in file."""
+
+import os
+import shlex
+import subprocess
+
+SKIP_EXTS = ('.png', '.jpg', '.jpeg')
+SKIP_FILES = ()
+SKIP_PREFIXES = ('.github/', 'docs/')
+
+
+def sh(cmd):
+    return subprocess.check_output(
+        shlex.split(cmd), universal_newlines=True
+    ).strip()
+
+
+def main():
+    files = set()
+    for file in sh("git ls-files").split('\n'):
+        if (
+            file.startswith(SKIP_PREFIXES)
+            or os.path.splitext(file)[1].lower() in SKIP_EXTS
+            or file in SKIP_FILES
+        ):
+            continue
+        files.add(file)
+
+    for file in sorted(files):
+        print("include " + file)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/internal/git_pre_commit.py b/scripts/internal/git_pre_commit.py
new file mode 100755
index 0000000000..b98eab768d
--- /dev/null
+++ b/scripts/internal/git_pre_commit.py
@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009 Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""This gets executed on 'git commit' and rejects the commit in case
+the submitted code does not pass validation. Validation is run only
+against the files which were modified in the commit.
+"""
+
+import os
+import pathlib
+import shlex
+import subprocess
+import sys
+
+ROOT_DIR = pathlib.Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(ROOT_DIR))
+from _bootstrap import load_module  # noqa: E402
+
+_common = load_module(ROOT_DIR / "psutil" / "_common.py")
+hilite = _common.hilite
+
+PYTHON = sys.executable
+
+
+def log(msg="", color=None, bold=None):
+    msg = "Git pre-commit > " + msg
+    if msg:
+        msg = hilite(msg, color=color, bold=bold, force_color=True)
+    print(msg, flush=True)
+
+
+def exit_with(msg):
+    log(msg + " Commit aborted.", color="red")
+    sys.exit(1)
+
+
+def sh(cmd):
+    if isinstance(cmd, str):
+        cmd = shlex.split(cmd)
+    p = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        universal_newlines=True,
+    )
+    stdout, stderr = p.communicate()
+    if p.returncode != 0:
+        raise RuntimeError(stderr)
+    if stderr:
+        log(stderr)
+    return stdout.rstrip()
+
+
+def git_commit_files():
+    out = [
+        f
+        for f in sh(["git", "diff", "--cached", "--name-only"]).splitlines()
+        if os.path.exists(f)
+    ]
+
+    py = [f for f in out if f.endswith(".py")]
+    c = [f for f in out if f.endswith((".c", ".h"))]
+    rst = [f for f in out if f.endswith(".rst")]
+    toml = [f for f in out if f.endswith(".toml")]
+    new_rm_mv = sh(
+        ["git", "diff", "--name-only", "--diff-filter=ADR", "--cached"]
+    ).split()
+    return py, c, rst, toml, new_rm_mv
+
+
+def lint_manifest():
+    out = sh([PYTHON, "scripts/internal/generate_manifest.py"])
+    with open("MANIFEST.in", encoding="utf8") as f:
+        if out.strip() != f.read().strip():
+            exit_with(
+                "Some files were added, deleted or renamed. "
+                "Run 'make generate-manifest' and commit again."
+            )
+
+
+def run_make(target, files):
+    ls = ", ".join([os.path.basename(x) for x in files])
+    plural = "s" if len(files) > 1 else ""
+    msg = f"Running 'make {target}' against {len(files)} file{plural}: {ls}"
+    log(msg, color="lightblue")
+    files = "FILES=" + " ".join(shlex.quote(f) for f in files)
+    if subprocess.call(["make", target, files]) != 0:
+        exit_with(f"'make {target}' failed.")
+
+
+def main():
+    py, c, rst, toml, new_rm_mv = git_commit_files()
+    if py:
+        run_make("black", py)
+        run_make("ruff", py)
+    if c:
+        run_make("lint-c", c)
+    if rst:
+        run_make("lint-rst", rst)
+    if toml:
+        run_make("lint-toml", toml)
+    if new_rm_mv:
+        lint_manifest()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/internal/install-pydeps.sh b/scripts/internal/install-pydeps.sh
new file mode 100755
index 0000000000..be1125eecd
--- /dev/null
+++ b/scripts/internal/install-pydeps.sh
@@ -0,0 +1,90 @@
+#!/bin/sh
+
+# Install Python deps with uv, installing uv itself if missing. Falls back
+# on pip where uv ships no binary for the platform (BSD, AIX, SunOS).
+# NOTE: this script MUST be kept compatible with the `sh` shell.
+
+set -e
+
+if [ -z "$PYTHON" ]; then
+    PYTHON=python3
+fi
+
+UV=
+
+# --- pip
+
+install_pip() {
+    echo "installing pip"
+    "$PYTHON" "$(dirname "$0")/install_pip.py"
+}
+
+pip_install() {
+    install_pip
+    echo "installing $* via pip"
+    PIP_BREAK_SYSTEM_PACKAGES=1 "$PYTHON" -m pip install \
+        --upgrade \
+        --upgrade-strategy eager \
+        "$@"
+}
+
+# --- uv
+
+find_uv() {
+    if command -v uv > /dev/null 2>&1; then
+        UV=$(command -v uv)
+    else
+        UV=$("$PYTHON" -c \
+            'from uv import find_uv_bin; print(find_uv_bin())' 2>/dev/null) || UV=
+    fi
+}
+
+install_uv() {
+    install_pip || return
+    echo "installing uv"
+    # --only-binary: pick up the .whl, else fail
+    PIP_BREAK_SYSTEM_PACKAGES=1 "$PYTHON" -m pip install \
+        --only-binary=:all: \
+        --upgrade \
+        'uv>=0.8.8'
+}
+
+uv_install() {
+    echo "installing $* via uv"
+    # When the interpreter is not writable, pip falls back to the user
+    # base; uv does not, so check ourselves. --prefix is not exactly
+    # pip --user, but avoids requiring a venv or root.
+    user_base=$("$PYTHON" -c \
+        'import os, site, sysconfig
+writable = os.access(sysconfig.get_path("purelib"), os.W_OK)
+print("" if writable else site.getuserbase())')
+    if [ -n "$user_base" ]; then
+        set -- --prefix "$user_base" "$@"
+    fi
+    "$UV" pip install \
+        --python "$("$PYTHON" -c 'import sys; print(sys.executable)')" \
+        --upgrade \
+        "$@"
+}
+
+main() {
+    if [ $# -eq 0 ]; then
+        echo "usage: $0 <pkg>" >&2
+        exit 1
+    fi
+
+    find_uv
+
+    if [ -z "$UV" ]; then
+        install_uv || echo "$0: uv unavailable on this platform, using pip" >&2
+        find_uv
+    fi
+
+    if [ -n "$UV" ]; then
+        uv_install "$@"
+    else
+        pip_install "$@"
+    fi
+}
+
+main "$@"
diff --git a/scripts/internal/install-sysdeps.sh b/scripts/internal/install-sysdeps.sh
new file mode 100755
index 0000000000..7cd768018a
--- /dev/null
+++ b/scripts/internal/install-sysdeps.sh
@@ -0,0 +1,115 @@
+#!/bin/sh
+
+# Install the system dependencies needed to compile psutil. With --test-only
+# install CLI tools needed by unit tests.
+# NOTE: this script MUST be kept compatible with the `sh` shell.
+
+set -e
+
+if [ "$1" = "--test-only" ]; then
+    TEST_ONLY=true
+fi
+
+UNAME_S=$(uname -s)
+
+case "$UNAME_S" in
+    Linux)
+        if command -v apt-get > /dev/null 2>&1; then
+            HAS_APT=true  # debian / ubuntu
+        elif command -v dnf > /dev/null 2>&1; then
+            RPM_MGR=dnf  # fedora, redhat 8+
+        elif command -v yum > /dev/null 2>&1; then
+            RPM_MGR=yum  # older redhat / centos
+        elif command -v pacman > /dev/null 2>&1; then
+            HAS_PACMAN=true  # arch
+        elif command -v apk > /dev/null 2>&1; then
+            HAS_APK=true  # musl
+        fi
+        ;;
+    FreeBSD)
+        FREEBSD=true
+        ;;
+    NetBSD)
+        NETBSD=true
+        ;;
+    OpenBSD)
+        OPENBSD=true
+        ;;
+    SunOS)
+        SUNOS=true
+        ;;
+esac
+
+# Check if running as root
+if [ "$(id -u)" -ne 0 ]; then
+    SUDO=sudo
+fi
+
+# Deps needed to compile psutil.
+install_build_deps() {
+    # Debian / Ubuntu
+    if [ $HAS_APT ]; then
+        $SUDO apt-get install -y python3-dev gcc
+    # Redhat / Fedora
+    elif [ $RPM_MGR ]; then
+        $SUDO $RPM_MGR install -y python3-devel gcc
+    # Arch
+    elif [ $HAS_PACMAN ]; then
+        $SUDO pacman -S --noconfirm python gcc
+    # Alpine
+    elif [ $HAS_APK ]; then
+        $SUDO apk add --no-interactive python3-dev gcc musl-dev linux-headers
+    # FreeBSD
+    elif [ $FREEBSD ]; then
+        $SUDO pkg install -y python3  # no gcc: base cc is clang, and that's what python uses
+    # NetBSD
+    elif [ $NETBSD ]; then
+        PKGIN=/usr/pkg/bin/pkgin
+        if [ ! -x "$PKGIN" ]; then
+            : "${PKG_PATH:=https://cdn.netbsd.org/pub/pkgsrc/packages/NetBSD/$(uname -m)/$(uname -r)/All}"
+            $SUDO env PKG_PATH="$PKG_PATH" /usr/sbin/pkg_add -v pkgin
+        fi
+        $SUDO "$PKGIN" update
+        $SUDO "$PKGIN" -y install 'python314-*'  # no gcc12: base gcc compiles psutil just fine
+        if [ ! -e /usr/pkg/bin/python3 ]; then
+            $SUDO ln -s /usr/pkg/bin/python3.14 /usr/pkg/bin/python3
+        fi
+    # OpenBSD
+    elif [ $OPENBSD ]; then
+        $SUDO pkg_add python%3  # there's no "python3" package, and no gcc: base cc is clang
+    # SunOS
+    elif [ $SUNOS ]; then
+        $SUDO pkg install developer/gcc
+    else
+        echo "Unsupported platform '$UNAME_S'. Ignoring."
+    fi
+}
+
+# CLI tools needed by unit tests.
+install_test_deps() {
+    # Debian / Ubuntu
+    if [ $HAS_APT ]; then
+        $SUDO apt-get install -y net-tools coreutils util-linux sudo procps
+    # Redhat / Fedora
+    elif [ $RPM_MGR ]; then
+        $SUDO $RPM_MGR install -y net-tools util-linux sudo procps-ng
+    # Arch
+    elif [ $HAS_PACMAN ]; then
+        $SUDO pacman -S --noconfirm net-tools coreutils util-linux sudo procps-ng
+    # Alpine
+    elif [ $HAS_APK ]; then
+        $SUDO apk add --no-interactive coreutils util-linux procps
+    else
+        echo "No supported package manager found on '$UNAME_S'. Ignoring."
+    fi
+}
+
+main() {
+    if [ $TEST_ONLY ]; then
+        install_test_deps
+    else
+        install_build_deps
+    fi
+}
+
+main
diff --git a/scripts/internal/install_pip.py b/scripts/internal/install_pip.py
new file mode 100755
index 0000000000..1ffdbd3d56
--- /dev/null
+++ b/scripts/internal/install_pip.py
@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Install pip, or upgrade it if it's too old.
+
+Note: we build wheels on Python 3.8 (the floor), but don't run tests
+for it, nor installs deps, so this script is never called there.
+"""
+
+import re
+import ssl
+import subprocess
+import sys
+import tempfile
+from urllib.request import urlopen
+
+try:
+    import pip
+except ImportError:
+    pip = None
+
+
+if sys.version_info >= (3, 10):
+    URL = "https://bootstrap.pypa.io/get-pip.py"
+else:
+    URL = "https://bootstrap.pypa.io/pip/{}.{}/get-pip.py".format(
+        *sys.version_info[:2]
+    )
+
+# Needed by "pip install --group" (PEP 735), used by the
+# install-pydeps-* makefile targets.
+MIN_VERSION = (25, 1)
+
+
+def get_pip_version():
+    if pip is not None:
+        match = re.match(r"(\d+)\.(\d+)", pip.__version__)
+        return (int(match.group(1)), int(match.group(2))) if match else (0, 0)
+
+
+def install_pip():
+    ssl_context = (
+        ssl._create_unverified_context()
+        if hasattr(ssl, "_create_unverified_context")
+        else None
+    )
+    opts = ["--upgrade", "--break-system-packages"]
+    if not hasattr(sys, "real_prefix") and sys.base_prefix == sys.prefix:
+        opts.append("--user")  # rejected when inside a virtualenv
+
+    with tempfile.NamedTemporaryFile(suffix=".py") as f:
+        print(f"downloading {URL} into {f.name}")
+        kwargs = dict(context=ssl_context) if ssl_context else {}
+        req = urlopen(URL, **kwargs)
+        data = req.read()
+        req.close()
+
+        f.write(data)
+        f.flush()
+        print("download finished, installing pip")
+
+        code = subprocess.call([sys.executable, f.name, *opts])
+
+    sys.exit(code)
+
+
+def main():
+    version = get_pip_version()
+    if version is None:
+        print("pip is not installed")
+    elif version < MIN_VERSION:
+        print(f"pip {pip.__version__} is too old; upgrading")
+    else:
+        print(f"pip (version {pip.__version__}) already installed")
+        return
+    install_pip()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/internal/print_access_denied.py b/scripts/internal/print_access_denied.py
new file mode 100755
index 0000000000..1633d6198c
--- /dev/null
+++ b/scripts/internal/print_access_denied.py
@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Helper script iterates over all processes and .
+It prints how many AccessDenied exceptions are raised in total and
+for what Process method.
+
+$ make print-access-denied
+API                  AD    Percent   Outcome
+memory_info          0        0.0%   SUCCESS
+uids                 0        0.0%   SUCCESS
+cmdline              0        0.0%   SUCCESS
+create_time          0        0.0%   SUCCESS
+status               0        0.0%   SUCCESS
+num_ctx_switches     0        0.0%   SUCCESS
+username             0        0.0%   SUCCESS
+ionice               0        0.0%   SUCCESS
+memory_percent       0        0.0%   SUCCESS
+gids                 0        0.0%   SUCCESS
+cpu_times            0        0.0%   SUCCESS
+nice                 0        0.0%   SUCCESS
+pid                  0        0.0%   SUCCESS
+cpu_percent          0        0.0%   SUCCESS
+num_threads          0        0.0%   SUCCESS
+cpu_num              0        0.0%   SUCCESS
+ppid                 0        0.0%   SUCCESS
+terminal             0        0.0%   SUCCESS
+name                 0        0.0%   SUCCESS
+threads              0        0.0%   SUCCESS
+cpu_affinity         0        0.0%   SUCCESS
+memory_maps          71      21.3%   ACCESS DENIED
+memory_footprint     71      21.3%   ACCESS DENIED
+exe                  174     52.1%   ACCESS DENIED
+environ              238     71.3%   ACCESS DENIED
+num_fds              238     71.3%   ACCESS DENIED
+io_counters          238     71.3%   ACCESS DENIED
+cwd                  238     71.3%   ACCESS DENIED
+connections          238     71.3%   ACCESS DENIED
+open_files           238     71.3%   ACCESS DENIED
+--------------------------------------------------
+Totals: access-denied=1744, calls=10020, processes=334
+"""
+
+import time
+from collections import defaultdict
+
+import psutil
+from psutil._common import print_color
+
+
+def main():
+    # collect
+    tot_procs = 0
+    tot_ads = 0
+    tot_calls = 0
+    signaler = object()
+    d = defaultdict(int)
+    start = time.time()
+    for p in psutil.process_iter(attrs=[], ad_value=signaler):
+        tot_procs += 1
+        for methname, value in p.info.items():
+            tot_calls += 1
+            if value is signaler:
+                tot_ads += 1
+                d[methname] += 1
+            else:
+                d[methname] += 0
+    elapsed = time.time() - start
+
+    # print
+    templ = "{:<20} {:<5} {:<9} {}"
+    s = templ.format("API", "AD", "Percent", "Outcome")
+    print_color(s, color=None, bold=True)
+    for methname, ads in sorted(d.items(), key=lambda x: (x[1], x[0])):
+        perc = (ads / tot_procs) * 100
+        outcome = "SUCCESS" if not ads else "ACCESS DENIED"
+        s = templ.format(methname, ads, f"{perc:6.1f}%", outcome)
+        print_color(s, "red" if ads else None)
+    tot_perc = round((tot_ads / tot_calls) * 100, 1)
+    print("-" * 50)
+    print(
+        f"Totals: access-denied={tot_ads} ({tot_perc}%%), calls={tot_calls},"
+        f" processes={tot_procs}, elapsed={round(elapsed, 2)}s"
+    )
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/internal/print_announce.py b/scripts/internal/print_announce.py
new file mode 100755
index 0000000000..af3e7601b8
--- /dev/null
+++ b/scripts/internal/print_announce.py
@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009 Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Prints release announce based on docs/changelog.rst file content.
+See: https://pip.pypa.io/en/stable/reference/pip_install/#hash-checking-mode.
+
+"""
+
+import pathlib
+import re
+import subprocess
+import sys
+
+from psutil import __version__
+
+ROOT_DIR = pathlib.Path(__file__).resolve().parent.parent.parent
+CHANGELOG = ROOT_DIR / 'docs' / 'changelog.rst'
+PRINT_HASHES_PY = ROOT_DIR / 'scripts' / 'internal' / 'print_hashes.py'
+
+PRJ_NAME = 'psutil'
+PRJ_VERSION = __version__
+PRJ_URL_HOME = 'https://github.com/giampaolo/psutil'
+PRJ_URL_DOC = 'https://psutil.io'
+PRJ_URL_DOWNLOAD = 'https://pypi.org/project/psutil/#files'
+PRJ_URL_WHATSNEW = 'https://psutil.io/changelog/'
+
+template = """\
+Hello all,
+I'm glad to announce the release of {prj_name} {prj_version}:
+{prj_urlhome}
+
+About
+=====
+
+psutil (process and system utilities) is a cross-platform library for \
+retrieving information on running processes and system utilization (CPU, \
+memory, disks, network) in Python. It is useful mainly for system \
+monitoring, profiling and limiting process resources and management of \
+running processes. It implements many functionalities offered by command \
+line tools such as: ps, top, lsof, netstat, ifconfig, who, df, kill, free, \
+nice, ionice, iostat, iotop, uptime, pidof, tty, taskset, pmap. It \
+currently supports Linux, Windows, macOS, Sun Solaris, FreeBSD, OpenBSD, \
+NetBSD and AIX. Supported Python versions are cPython 3.7+ and PyPy.
+
+What's new
+==========
+
+{changes}
+
+Links
+=====
+
+- Home page: {prj_urlhome}
+- Download: {prj_urldownload}
+- Documentation: {prj_urldoc}
+- What's new: {prj_urlwhatsnew}
+
+Hashes
+======
+
+{hashes}
+
+--
+
+Giampaolo - https://gmpy.dev/about
+"""
+
+
+def rst_to_text(s):
+    """Strip RST/Sphinx markup, returning plain text."""
+    # :gh:`123` -> #123
+    s = re.sub(r':gh:`(\d+)`', r'#\1', s)
+    # :meth:, :func:, :class:, :attr:, :exc:, :mod:, :data:, etc.
+    # :role:`text` -> text (also handles :role:`~text` and :role:`mod.text`)
+    s = re.sub(r':[a-z]+:`~?([^`]+)`', r'\1', s)
+    # ``code`` -> `code`
+    s = re.sub(r'``([^`]+)``', r'`\1`', s)
+    # **bold** -> bold
+    s = re.sub(r'\*\*([^*]+)\*\*', r'\1', s)
+    # *italic* -> italic
+    s = re.sub(r'\*([^*]+)\*', r'\1', s)
+    return s
+
+
+def get_changes():
+    """Get the most recent changes for this release by parsing
+    docs/changelog.rst file.
+    """
+    with open(CHANGELOG) as f:
+        lines = f.readlines()
+
+    block = []
+
+    # eliminate the part preceding the first block
+    while lines:
+        line = lines.pop(0)
+        if line.startswith('^^^^'):
+            break
+    else:
+        raise ValueError("something wrong")
+
+    lines.pop(0)
+    while lines:
+        line = lines.pop(0)
+        line = line.rstrip()
+        if re.match(r"^- \d+_", line):
+            line = re.sub(r"^- (\d+)_", r"- #\1", line)
+
+        if line.startswith('^^^^'):
+            break
+        block.append(line)
+    else:
+        raise ValueError("something wrong")
+
+    # eliminate bottom empty lines
+    block.pop(-1)
+    while not block[-1]:
+        block.pop(-1)
+
+    text = "\n".join(block)
+    text = rst_to_text(text)
+    return text
+
+
+def main():
+    changes = get_changes()
+    hashes = (
+        subprocess.check_output([sys.executable, PRINT_HASHES_PY, 'dist/'])
+        .strip()
+        .decode()
+    )
+    text = template.format(
+        prj_name=PRJ_NAME,
+        prj_version=PRJ_VERSION,
+        prj_urlhome=PRJ_URL_HOME,
+        prj_urldownload=PRJ_URL_DOWNLOAD,
+        prj_urldoc=PRJ_URL_DOC,
+        prj_urlwhatsnew=PRJ_URL_WHATSNEW,
+        changes=changes,
+        hashes=hashes,
+    )
+    print(text)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/internal/print_api_speed.py b/scripts/internal/print_api_speed.py
new file mode 100755
index 0000000000..9cc7b7d56f
--- /dev/null
+++ b/scripts/internal/print_api_speed.py
@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Benchmark all API calls and print them from fastest to slowest.
+
+$ make print_api_speed
+SYSTEM APIS                NUM CALLS      SECONDS
+-------------------------------------------------
+getloadavg                       300      0.00013
+heap_info                        300      0.00028
+heap_trim                        300      0.00039
+cpu_count                        300      0.00061
+disk_usage                       300      0.00066
+pid_exists                       300      0.00235
+users                            300      0.00455
+net_io_counters                  300      0.00550
+cpu_times                        300      0.00667
+boot_time                        300      0.00700
+cpu_percent                      300      0.00766
+net_if_stats                     300      0.00783
+virtual_memory                   300      0.00834
+cpu_times_percent                300      0.00885
+net_if_addrs                     300      0.01157
+cpu_stats                        300      0.01208
+swap_memory                      300      0.01558
+disk_partitions                  300      0.01664
+disk_io_counters                 300      0.02204
+sensors_battery                  300      0.02995
+pids                             300      0.05295
+cpu_count (cores)                300      0.06943
+process_iter (all)               300      0.08486
+cpu_freq                         300      0.18987
+sensors_fans                     300      0.74027
+net_connections                  161      2.00690
+sensors_temperatures             100      2.00742
+
+PROCESS APIS               NUM CALLS      SECONDS
+-------------------------------------------------
+exe                              300      0.00017
+create_time                      300      0.00020
+nice                             300      0.00025
+ionice                           300      0.00041
+cwd                              300      0.00052
+cpu_affinity                     300      0.00059
+num_fds                          300      0.00097
+memory_info                      300      0.00201
+cmdline                          300      0.00222
+io_counters                      300      0.00226
+cpu_num                          300      0.00242
+status                           300      0.00242
+terminal                         300      0.00243
+name                             300      0.00249
+page_faults                      300      0.00258
+memory_percent                   300      0.00259
+cpu_times                        300      0.00272
+threads                          300      0.00278
+num_threads                      300      0.00278
+gids                             300      0.00296
+num_ctx_switches                 300      0.00299
+uids                             300      0.00311
+cpu_percent                      300      0.00346
+net_connections                  300      0.00373
+open_files                       300      0.00378
+memory_extras                    300      0.00398
+username                         300      0.00500
+ppid                             300      0.00556
+environ                          300      0.01176
+memory_footprint                 300      0.02218
+memory_maps                      300      0.27158
+"""
+
+import argparse
+import inspect
+import os
+import sys
+from timeit import default_timer as timer
+
+import psutil
+from psutil._common import print_color
+
+TIMES = 300
+PID = os.getpid()
+timings = []
+templ = "{:<25} {:>10}   {:>10}"
+
+
+def print_header(what):
+    s = templ.format(what, "NUM CALLS", "SECONDS")
+    print_color(s, color=None, bold=True)
+    print("-" * len(s))
+
+
+def print_timings():
+    timings.sort(key=lambda x: (x[1], -x[2]), reverse=True)
+    i = 0
+    while timings[:]:
+        title, times, elapsed = timings.pop(0)
+        s = templ.format(title, str(times), f"{elapsed:.5f}")
+        if i > len(timings) - 5:
+            print_color(s, color="red")
+        else:
+            print(s)
+
+
+def timecall(title, fun, *args, **kw):
+    print(f"{title:<50}", end="")
+    sys.stdout.flush()
+    t = timer()
+    for n in range(TIMES):
+        try:
+            fun(*args, **kw)
+        except psutil.AccessDenied:
+            return
+        else:
+            elapsed = timer() - t
+            if elapsed > 2:
+                break
+    print("\033[2K\r", end="")
+    sys.stdout.flush()
+    timings.append((title, n + 1, elapsed))
+
+
+def set_highest_priority():
+    """Set highest CPU and I/O priority (requires root)."""
+    p = psutil.Process()
+    if psutil.WINDOWS:
+        p.nice(psutil.HIGH_PRIORITY_CLASS)
+    else:
+        p.nice(-20)
+
+    if psutil.LINUX:
+        p.ionice(psutil.IOPRIO_CLASS_RT, value=7)
+    elif psutil.WINDOWS:
+        p.ionice(psutil.IOPRIO_HIGH)
+
+
+def parse_cli():
+    global TIMES, PID
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument('-t', '--times', type=int, default=TIMES)
+    parser.add_argument('-p', '--pid', type=int, default=PID)
+    args = parser.parse_args()
+    TIMES = args.times
+    PID = args.pid
+    assert TIMES > 1, TIMES
+
+
+def main():
+    parse_cli()
+
+    try:
+        set_highest_priority()
+    except psutil.AccessDenied:
+        prio_set = False
+    else:
+        prio_set = True
+
+    # --- system
+
+    public_apis = []
+    ignore = [
+        'bytes2human',
+        'wait_procs',
+        'process_iter',
+        'win_service_get',
+        'win_service_iter',
+    ]
+    if psutil.MACOS:
+        ignore.append('net_connections')  # raises AD
+    for name in psutil.__all__:
+        obj = getattr(psutil, name, None)
+        if inspect.isfunction(obj):
+            if name not in ignore:
+                public_apis.append(name)
+
+    print_header("SYSTEM APIS")
+    for name in public_apis:
+        fun = getattr(psutil, name)
+        args = ()
+        if name == 'pid_exists':
+            args = (PID,)
+        elif name == 'disk_usage':
+            args = (os.getcwd(),)
+        timecall(name, fun, *args)
+    timecall('cpu_count (cores)', psutil.cpu_count, logical=False)
+    timecall('process_iter (all)', lambda: list(psutil.process_iter()))
+    print_timings()
+
+    # --- process
+    print()
+    print_header("PROCESS APIS")
+    p = psutil.Process(PID)
+    for name in sorted(p.attrs):
+        fun = getattr(p, name)
+        if callable(fun):
+            timecall(name, fun)
+
+    print_timings()
+
+    if not prio_set:
+        msg = "\nWARN: couldn't set highest process priority "
+        msg += "(requires root)"
+        print_color(msg, "red")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/internal/print_dist.py b/scripts/internal/print_dist.py
new file mode 100755
index 0000000000..2d4b82b5de
--- /dev/null
+++ b/scripts/internal/print_dist.py
@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009 Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""List and pretty print tarball & wheel files in the dist/ directory."""
+
+import argparse
+import collections
+import fnmatch
+import os
+import pathlib
+import sys
+
+ROOT_DIR = pathlib.Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(ROOT_DIR))
+from _bootstrap import load_module  # noqa: E402
+
+_common = load_module(ROOT_DIR / "psutil" / "_common.py")
+bytes2human = _common.bytes2human
+print_color = _common.print_color
+
+# Tags are spelled out because they change silently when a different
+# Python builds the wheel. Trailing manylinux ones follow the image.
+EXPECTED_WHEELS = [
+    # Linux
+    "*-cp38-abi3-manylinux2010_x86_64.*.whl",
+    "*-cp38-abi3-manylinux2014_aarch64.*.whl",
+    "*-cp38-abi3-manylinux2014_ppc64le.*.whl",
+    "*-cp38-abi3-manylinux2014_s390x.*.whl",
+    # Linux musl
+    "*-cp38-abi3-musllinux_1_2_x86_64.whl",
+    "*-cp38-abi3-musllinux_1_2_aarch64.whl",
+    # macOS
+    "*-cp38-abi3-macosx_10_15_x86_64.whl",
+    "*-cp38-abi3-macosx_11_0_arm64.whl",
+    # Windows
+    "*-cp38-abi3-win_amd64.whl",
+    "*-cp38-abi3-win_arm64.whl",
+    # Free-threading
+    "*-cp314-cp314t-manylinux2010_x86_64.*.whl",
+    "*-cp314-cp314t-manylinux2014_aarch64.*.whl",
+    "*-cp314-cp314t-macosx_10_15_x86_64.whl",
+    "*-cp314-cp314t-macosx_11_0_arm64.whl",
+    "*-cp314-cp314t-win_amd64.whl",
+    "*-cp314-cp314t-win_arm64.whl",
+]
+
+
+class Wheel:
+    def __init__(self, path):
+        self._path = path
+        self._name = os.path.basename(path)
+
+    def __repr__(self):
+        return "<{}(name={}, plat={}, arch={}, pyver={})>".format(
+            self.__class__.__name__,
+            self.name,
+            self.platform(),
+            self.arch(),
+            self.pyver(),
+        )
+
+    __str__ = __repr__
+
+    @property
+    def name(self):
+        return self._name
+
+    def platform(self):
+        plat = self.name.split('-')[-1]
+        pyimpl = self.name.split('-')[3]
+        ispypy = 'pypy' in pyimpl
+        if 'linux' in plat:
+            if ispypy:
+                return 'pypy_on_linux'
+            else:
+                return 'linux'
+        elif 'win' in plat:
+            if ispypy:
+                return 'pypy_on_windows'
+            else:
+                return 'windows'
+        elif 'macosx' in plat:
+            if ispypy:
+                return 'pypy_on_macos'
+            else:
+                return 'macos'
+        else:
+            raise ValueError(f"unknown platform {self.name!r}")
+
+    def arch(self):
+        if self.name.endswith(('x86_64.whl', 'amd64.whl')):
+            return '64-bit'
+        if self.name.endswith(("i686.whl", "win32.whl")):
+            return '32-bit'
+        if self.name.endswith("arm64.whl"):
+            return 'arm64'
+        if self.name.endswith("aarch64.whl"):
+            return 'aarch64'
+        if self.name.endswith("ppc64le.whl"):
+            return 'ppc64le'
+        if self.name.endswith("s390x.whl"):
+            return 's390x'
+        return '?'
+
+    def pyver(self):
+        pyver = 'pypy' if self.name.split('-')[3].startswith('pypy') else 'py'
+        pyver += self.name.split('-')[2][2:]
+        return pyver
+
+    def size(self):
+        return os.path.getsize(self._path)
+
+
+class Tarball(Wheel):
+    def platform(self):
+        return "source"
+
+    def arch(self):
+        return "-"
+
+    def pyver(self):
+        return "-"
+
+
+def check_dist(wheels, tarballs):
+    """Assert the full expected set of wheels + one sdist is present.
+    Returns a list of error strings (empty means all good).
+    """
+    names = [w.name for w in wheels]
+    errors = [
+        f"missing wheel: {pat}"
+        for pat in EXPECTED_WHEELS
+        if not any(fnmatch.fnmatch(n, pat) for n in names)
+    ]
+    errors += [
+        f"unexpected wheel: {n}"
+        for n in names
+        if not any(fnmatch.fnmatch(n, p) for p in EXPECTED_WHEELS)
+    ]
+    if len(tarballs) != 1:
+        errors.append(f"expected 1 sdist, found {len(tarballs)}")
+    return errors
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        'dir',
+        nargs="?",
+        default="dist",
+        help='directory containing tar.gz or wheel files',
+    )
+    parser.add_argument(
+        "--check",
+        action="store_true",
+        help="assert the full expected set of wheels is present",
+    )
+    args = parser.parse_args()
+
+    groups = collections.defaultdict(list)
+    ls = sorted(os.listdir(args.dir), key=lambda x: x.endswith("tar.gz"))
+    for name in ls:
+        path = os.path.join(args.dir, name)
+        if path.endswith(".whl"):
+            pkg = Wheel(path)
+        elif path.endswith(".tar.gz"):
+            pkg = Tarball(path)
+        else:
+            raise ValueError(f"invalid package {path!r}")
+        groups[pkg.platform()].append(pkg)
+
+    tot_files = 0
+    tot_size = 0
+    templ = "{:<120} {:>7} {:>8} {:>7}"
+    for platf, pkgs in groups.items():
+        ppn = f"{platf} ({len(pkgs)})"
+        s = templ.format(ppn, "size", "arch", "pyver")
+        print_color('\n' + s, color=None, bold=True)
+        for pkg in sorted(pkgs, key=lambda x: x.name):
+            tot_files += 1
+            tot_size += pkg.size()
+            s = templ.format(
+                "  " + pkg.name,
+                bytes2human(pkg.size()),
+                pkg.arch(),
+                pkg.pyver(),
+            )
+            if 'pypy' in pkg.pyver():
+                print_color(s, color='violet')
+            else:
+                print_color(s, color='brown')
+
+    print_color(
+        f"\n\ntotals: files={tot_files}, size={bytes2human(tot_size)}",
+        bold=True,
+    )
+
+    if args.check:
+        all_pkgs = [p for pkgs in groups.values() for p in pkgs]
+        tarballs = [p for p in all_pkgs if isinstance(p, Tarball)]
+        wheels = [p for p in all_pkgs if not isinstance(p, Tarball)]
+        errors = check_dist(wheels, tarballs)
+        if errors:
+            print_color("\ndist check FAILED:", color='red', bold=True)
+            for err in errors:
+                print_color("  " + err, color='red')
+            print_color(
+                "\nif intentional, update EXPECTED_WHEELS in "
+                + os.path.basename(__file__),
+                bold=True,
+            )
+            sys.exit(1)
+        print_color("\ndist check: OK", color='green', bold=True)
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/internal/print_downloads.py b/scripts/internal/print_downloads.py
new file mode 100755
index 0000000000..1a17650b71
--- /dev/null
+++ b/scripts/internal/print_downloads.py
@@ -0,0 +1,541 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009 Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Print PYPI download statistics.
+Useful sites:
+* https://pepy.tech/project/psutil
+* https://pypistats.org/packages/psutil
+* https://hugovk.github.io/top-pypi-packages/.
+"""
+
+import argparse
+import collections
+import datetime
+import functools
+import json
+import os
+import re
+import shlex
+import subprocess
+import sys
+import urllib.request
+
+from psutil._common import bytes2human
+from psutil._common import hilite
+
+AUTH_FILE = os.path.expanduser("~/.pypinfo.json")
+CACHE_FILE = os.path.expanduser("~/.cache/psutil-print-downloads.json")
+PKGNAME = 'psutil'
+DAYS = 30
+CACHE_DAYS = 7
+# pypinfo defaults to 10 rows, which would turn "%" into a share of the
+# top 10. Raising it is free: BigQuery scans the same bytes either way.
+LIMIT = 1000
+# pypinfo's own --all means "every installer, not just pip". Without it
+# we'd miss the ~46% of downloads that come from uv.
+PYPINFO = f"pypinfo --json --all --days {DAYS} --limit"
+SDIST = "sdist (built from source)"
+FREETHREADED = "wheel (free-threaded)"
+PYPISTATS_URL = "https://pypistats.org/api/packages/{}/{}"
+TOP_PACKAGES_URL = (
+    "https://hugovk.dev/top-pypi-packages/top-pypi-packages.min.json"
+)
+LABEL_WIDTH = 36
+LAST_UPDATE = None
+bytes_billed = 0
+MAX_ROWS = 20
+# Python versions that reached end-of-life.
+EOL_PYTHONS = {"2.6", "2.7", "3.4", "3.5", "3.6", "3.7", "3.8", "3.9"}
+
+# CLI args
+ALL = False
+
+
+def parse_cli():
+    global ALL
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "-a",
+        "--all",
+        action="store_true",
+        help="print more info via BigQuery (expensive)",
+    )
+    args = parser.parse_args()
+    ALL = args.all
+
+
+def file_cache(fun):
+    """Cache the decorated function's JSON-serializable return value on
+    disk for CACHE_DAYS days.
+    """
+
+    @functools.wraps(fun)
+    def wrapper(*args):
+        key = repr((fun.__name__, args))
+        today = datetime.date.today()
+        try:
+            with open(CACHE_FILE) as f:
+                cache = json.load(f)
+            written = datetime.date.fromisoformat(cache["date"])
+            if (today - written).days >= CACHE_DAYS:
+                raise ValueError("stale")
+        except (FileNotFoundError, ValueError, KeyError):
+            cache = {"date": str(today), "entries": {}}
+        entries = cache.get("entries", {})
+        if key in entries:
+            return entries[key]
+        ret = fun(*args)
+        entries[key] = ret
+        cache["entries"] = entries
+        os.makedirs(os.path.dirname(CACHE_FILE), exist_ok=True)
+        with open(CACHE_FILE, "w") as f:
+            json.dump(cache, f)
+        return ret
+
+    return wrapper
+
+
+# --- get (free: no credentials, no quota)
+
+
+@file_cache
+def pypistats_fetch(kind):
+    url = PYPISTATS_URL.format(PKGNAME, kind)
+    with urllib.request.urlopen(url, timeout=30) as resp:
+        return json.load(resp)["data"]
+
+
+@functools.lru_cache
+def pypistats(kind):
+    """Return a {category: downloads} Counter for the last DAYS days.
+    Mirror traffic is excluded.
+    """
+    global LAST_UPDATE
+    rows = pypistats_fetch(kind)
+    LAST_UPDATE = max(x["date"] for x in rows)
+    start = datetime.date.fromisoformat(LAST_UPDATE) - datetime.timedelta(
+        days=DAYS - 1
+    )
+    totals = collections.Counter()
+    for row in rows:
+        if datetime.date.fromisoformat(row["date"]) >= start:
+            totals[row["category"]] += row["downloads"]
+    return totals
+
+
+def downloads():
+    return sum(pypistats("python_minor").values())
+
+
+def downloads_pyver():
+    return pypistats("python_minor")
+
+
+def downloads_by_system():
+    return pypistats("system")
+
+
+@file_cache
+def ranking():
+    with urllib.request.urlopen(TOP_PACKAGES_URL, timeout=60) as resp:
+        rows = json.load(resp)["rows"]
+    for i, row in enumerate(rows, start=1):
+        if row["project"] == PKGNAME:
+            return i
+    raise ValueError(f"can't find {PKGNAME} in {TOP_PACKAGES_URL}")
+
+
+# --- get (BigQuery, --all only)
+#
+# Everything below costs money. Sizes were measured with `pypinfo -n`.
+
+
+def sh(cmd):
+    assert os.path.exists(AUTH_FILE)
+    env = os.environ.copy()
+    env['GOOGLE_APPLICATION_CREDENTIALS'] = AUTH_FILE
+    p = subprocess.Popen(
+        shlex.split(cmd),
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        universal_newlines=True,
+        env=env,
+    )
+    stdout, stderr = p.communicate()
+    if p.returncode != 0:
+        raise RuntimeError(stderr)
+    assert not stderr, stderr
+    return stdout.strip()
+
+
+@functools.lru_cache
+@file_cache
+def query(cmd):
+    global bytes_billed
+    import pypinfo  # noqa: F401
+
+    ret = json.loads(sh(cmd))
+    bytes_billed += ret['query']['bytes_billed']
+    return ret
+
+
+# EXPENSIVE: ~11 GB scanned per call.
+def downloads_by_distro():
+    return query(f"{PYPINFO} {LIMIT} {PKGNAME} distro")
+
+
+# EXPENSIVE: ~17 GB scanned per call (only once: it's cached).
+def downloads_by_system_release():
+    """(system, release) rows, shared by the per-OS tables below.
+    The high limit prevents the many distinct Linux kernel versions
+    from crowding out the niche OSes.
+    """
+    cmd = f"{PYPINFO} 20000 {PKGNAME} system system-release"
+    return query(cmd)['rows']
+
+
+def downloads_by_release(system):
+    totals = collections.Counter()
+    for row in downloads_by_system_release():
+        if row['system_name'] == system:
+            totals[row['system_release']] += row['download_count']
+    return totals
+
+
+def downloads_by_windows_release():
+    # "10" also includes Windows 11: older interpreters report both
+    # as "10".
+    return downloads_by_release("Windows")
+
+
+# EXPENSIVE: ~18 GB scanned per call (only once: it's cached).
+def downloads_by_dimension(key):
+    """Aggregate one dimension (version, implementation,
+    installer_name, cpu, libc_name) out of a single combined query.
+    BigQuery bills by column, so one query costs less than five.
+    Counts are near-exact: combos below the row limit are lost.
+    """
+    cmd = f"{PYPINFO} 20000 {PKGNAME} version impl installer cpu libc"
+    totals = collections.Counter()
+    for row in query(cmd)['rows']:
+        totals[row[key]] += row['download_count']
+    return totals
+
+
+CPU_ALIASES = {
+    "": "unknown",
+    "amd64": "x86_64",
+    "arm64": "aarch64",
+    "armv8l": "armv7l",
+    "i386": "i686",
+    "i86pc": "x86_64",
+    "none": "unknown",
+    "sun4v": "sparc64",
+    "x86": "i686",
+}
+
+CPU_NAMES = {
+    "aarch64",
+    "armv6l",
+    "armv7l",
+    "e2k",
+    "i686",
+    "loongarch64",
+    "mips",
+    "mips64",
+    "ppc",
+    "ppc64",
+    "ppc64le",
+    "riscv64",
+    "s390x",
+    "sparc64",
+    "sw_64",
+    "unknown",
+    "wasm32",
+    "x86_64",
+}
+
+
+def normalize_cpu(name):
+    name = str(name).lower()
+    name = CPU_ALIASES.get(name, name)
+    return name if name in CPU_NAMES else "other"
+
+
+def downloads_by_cpu():
+    totals = collections.Counter()
+    for name, num in downloads_by_dimension('cpu').items():
+        totals[normalize_cpu(name)] += num
+    return totals
+
+
+# platform.release() on macOS returns the Darwin kernel version
+DARWIN_TO_MACOS = {
+    "19": "10.15 Catalina",
+    "20": "11 Big Sur",
+    "21": "12 Monterey",
+    "22": "13 Ventura",
+    "23": "14 Sonoma",
+    "24": "15 Sequoia",
+    "25": "26 Tahoe",
+}
+
+
+def downloads_by_macos_release():
+    totals = collections.Counter()
+    for release, num in downloads_by_release("Darwin").items():
+        major = release.split(".")[0]
+        name = DARWIN_TO_MACOS.get(major, f"Darwin {release}")
+        totals[name] += num
+    return totals
+
+
+def downloads_by_other_systems():
+    """BSD, AIX, SunOS, etc. Excludes Linux, whose system-release is
+    the kernel version (too many, not interesting).
+    """
+    skip = {"Windows", "Darwin", "Linux", "None", None}
+    totals = collections.Counter()
+    for row in downloads_by_system_release():
+        if row['system_name'] not in skip:
+            name = f"{row['system_name']} {row['system_release']}"
+            totals[name] += row['download_count']
+    return totals
+
+
+@file_cache
+def bq_monthly_usage_cached(month):
+    return bq_monthly_usage()
+
+
+def monthly_usage():
+    if bytes_billed:
+        return bq_monthly_usage()
+    return bq_monthly_usage_cached(datetime.date.today().strftime("%Y-%m"))
+
+
+def bq_monthly_usage():
+    """Bytes billed to the BigQuery project since the start of the
+    month. The free tier is 1 TiB. This query itself bills the 20 MiB
+    minimum.
+    """
+    from google.cloud import bigquery
+
+    os.environ.setdefault('GOOGLE_APPLICATION_CREDENTIALS', AUTH_FILE)
+    client = bigquery.Client()
+    sql = """
+        SELECT COALESCE(SUM(total_bytes_billed), 0) AS billed
+        FROM `region-us`.INFORMATION_SCHEMA.JOBS_BY_USER
+        WHERE creation_time >= TIMESTAMP(DATE_TRUNC(CURRENT_DATE(), MONTH))
+    """
+    return next(iter(client.query(sql).result())).billed
+
+
+def downloads_by_wheel():
+    """Group downloads by the kind of file fetched. This is the only
+    way to count free-threaded (no-GIL) usage: those interpreters
+    report the same version as regular ones, so pyversion can't tell
+    them apart. Also break sdists down by platform and architecture:
+    those are the users who would benefit from a new wheel.
+    """
+    # EXPENSIVE: ~45 GB scanned per call, the priciest query here.
+    # A file gets one row per (system, cpu) combo, hence the big limit:
+    # cutting the tail undercounts sdist and free-threaded.
+    cmd = f"{PYPINFO} 20000 {PKGNAME} file system cpu"
+    totals = collections.Counter()
+    subs = {SDIST: collections.Counter(), FREETHREADED: collections.Counter()}
+    for row in query(cmd)['rows']:
+        name = row['file']
+        if name.endswith(".metadata"):
+            continue  # PEP 658 sidecar, not an actual download
+        num = row['download_count']
+        freethreaded = re.search(r"-(cp\d+t)-", name)
+        if name.endswith((".tar.gz", ".zip")):
+            totals[SDIST] += num
+            system = row['system_name']
+            if not system or system == "None":
+                system = "unknown"
+            subs[SDIST][f"{system} / {normalize_cpu(row['cpu'])}"] += num
+        elif freethreaded:
+            totals[FREETHREADED] += num
+            if normalize_cpu(row['cpu']) == "unknown":
+                key = "no platform reported by the client"
+            else:
+                plat = name.rsplit("-", 1)[-1][: -len(".whl")].split(".")[0]
+                key = f"{freethreaded.group(1)} / {plat}"
+            subs[FREETHREADED][key] += num
+        elif "-abi3-" in name:
+            totals["wheel (abi3)"] += num
+        else:
+            totals["wheel (version specific)"] += num
+    return totals, subs
+
+
+# --- print
+
+
+def fold(rows, key, limit=MAX_ROWS):
+    if not limit or len(rows) <= limit:
+        return rows
+    tail = rows[limit:]
+    return rows[:limit] + [{
+        key: f"+ {len(tail)} more",
+        'download_count': sum(x['download_count'] for x in tail),
+    }]
+
+
+def print_table(title, left, rows, percent=True, total=None, limit=MAX_ROWS):
+    if total is None:
+        total = sum(x['download_count'] for x in rows)
+    rows = fold(rows, left, limit)
+    if percent:
+        header = f"{title:<{LABEL_WIDTH}}  {'Downloads':>15}  {'%':>7}"
+    else:
+        header = f"{title:<{LABEL_WIDTH}}  {'Downloads':>15}"
+    print(hilite(header, color="brown", bold=True))
+    print(hilite("-" * len(header), color="grey"))
+    for row in rows:
+        num = row['download_count']
+        lval = str(row[left] or "null")
+        line = f"{lval:<{LABEL_WIDTH}}  {num:>15,}"
+        if percent:
+            line += f"  {100 * num / total:>7.2f}"
+        print(line)
+    print()
+
+
+def to_rows(totals, key):
+    """Turn a Counter into the row dicts print_table wants."""
+    return [
+        {key: name, 'download_count': num}
+        for name, num in totals.most_common()
+    ]
+
+
+def print_cheap():
+    downs = downloads()
+
+    title = f"psutil downloads in the last {DAYS} days"
+    print(hilite(title, color="violet", bold=True))
+    print(hilite(f"updated at {LAST_UPDATE}", color="grey"))
+    overall = pypistats("overall")
+    mirrors = overall["with_mirrors"] - overall["without_mirrors"]
+    pct = 100 * mirrors / overall["with_mirrors"]
+    s = f"mirror traffic (excluded from all tables): {pct:.1f}%"
+    print(hilite(s, color="grey"))
+    print()
+
+    data = [
+        {'what': 'Per month', 'download_count': downs},
+        {'what': 'Per day', 'download_count': int(downs / DAYS)},
+        {'what': 'PYPI ranking', 'download_count': ranking()},
+    ]
+    print_table('Overview', 'what', data, percent=False)
+    print_table(
+        'Operating systems',
+        'system_name',
+        to_rows(downloads_by_system(), 'system_name'),
+    )
+    print_table(
+        'Python versions',
+        'python_version',
+        to_rows(downloads_pyver(), 'python_version'),
+    )
+    eol = sum(
+        num for ver, num in downloads_pyver().items() if ver in EOL_PYTHONS
+    )
+    s = f"downloads from EOL Pythons: {eol:,} ({100 * eol / downs:.1f}%)"
+    print(hilite(s, color="grey"))
+
+
+def print_expensive():
+    print_table(
+        'psutil versions',
+        'version',
+        to_rows(downloads_by_dimension('version'), 'version'),
+    )
+    wheels, subs = downloads_by_wheel()
+    rows = []
+    for row in to_rows(wheels, 'wheel_type'):
+        rows.append(row)
+        if row['wheel_type'] == SDIST:
+            rows.extend(
+                {
+                    'wheel_type': "    " + r['wheel_type'],
+                    'download_count': r['download_count'],
+                }
+                for r in fold(to_rows(subs[SDIST], 'wheel_type'), 'wheel_type')
+            )
+    print_table(
+        'Wheel types',
+        'wheel_type',
+        rows,
+        total=sum(wheels.values()),
+        limit=None,
+    )
+    print_table(
+        'Free-threaded wheels',
+        'wheel',
+        to_rows(subs[FREETHREADED], 'wheel'),
+    )
+    print_table(
+        'Implementations',
+        'implementation',
+        to_rows(downloads_by_dimension('implementation'), 'implementation'),
+    )
+    print_table(
+        'Installers',
+        'installer_name',
+        to_rows(downloads_by_dimension('installer_name'), 'installer_name'),
+    )
+    print_table('CPUs', 'cpu', to_rows(downloads_by_cpu(), 'cpu'))
+    print_table(
+        'libc',
+        'libc_name',
+        to_rows(downloads_by_dimension('libc_name'), 'libc_name'),
+    )
+    print_table(
+        'Windows versions',
+        'windows_release',
+        to_rows(downloads_by_windows_release(), 'windows_release'),
+    )
+    print_table(
+        'macOS versions',
+        'macos_release',
+        to_rows(downloads_by_macos_release(), 'macos_release'),
+    )
+    print_table(
+        'Other systems',
+        'system_release',
+        to_rows(downloads_by_other_systems(), 'system_release'),
+    )
+    print_table('Distros', 'distro_name', downloads_by_distro()['rows'])
+
+    billed = monthly_usage()
+    pct = 100 * billed / 1024**4
+    s = (
+        f"BigQuery free tier used this month: {bytes2human(billed)} of 1"
+        f" TiB ({pct:.0f}%)"
+    )
+    print(hilite(s, color="grey"))
+
+
+def main():
+    parse_cli()
+    print_cheap()
+    if ALL:
+        print_expensive()
+
+
+if __name__ == '__main__':
+    try:
+        main()
+    finally:
+        if bytes_billed:
+            print(f"bytes billed: {bytes_billed}", file=sys.stderr)
diff --git a/scripts/internal/print_hashes.py b/scripts/internal/print_hashes.py
new file mode 100755
index 0000000000..1161268d46
--- /dev/null
+++ b/scripts/internal/print_hashes.py
@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009 Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Prints files hashes, see:
+https://pip.pypa.io/en/stable/reference/pip_install/#hash-checking-mode.
+"""
+
+import argparse
+import hashlib
+import os
+
+
+def csum(file, kind):
+    h = hashlib.new(kind)
+    with open(file, "rb") as f:
+        h.update(f.read())
+        return h.hexdigest()
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "dir",
+        type=str,
+        nargs="?",
+        help="directory containing tar.gz or wheel files",
+        default="dist/",
+    )
+    args = parser.parse_args()
+    for name in sorted(os.listdir(args.dir)):
+        file = os.path.join(args.dir, name)
+        if os.path.isfile(file):
+            md5 = csum(file, "md5")
+            sha256 = csum(file, "sha256")
+            print(f"{os.path.basename(file)}\nmd5: {md5}\nsha256: {sha256}\n")
+        else:
+            print(f"skipping {file!r} (not a file)")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/internal/print_sysinfo.py b/scripts/internal/print_sysinfo.py
new file mode 100755
index 0000000000..1f872f73a4
--- /dev/null
+++ b/scripts/internal/print_sysinfo.py
@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Print system information. Run before CI test run."""
+
+import datetime
+import getpass
+import locale
+import os
+import pathlib
+import platform
+import shlex
+import shutil
+import subprocess
+import sys
+
+import psutil
+from psutil import bytes2human
+
+try:
+    import pip
+except ImportError:
+    pip = None
+try:
+    import wheel
+except ImportError:
+    wheel = None
+
+
+ROOT_DIR = pathlib.Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(ROOT_DIR))
+from _bootstrap import load_module  # noqa: E402
+
+
+def sh(cmd):
+    if isinstance(cmd, str):
+        cmd = shlex.split(cmd)
+    return subprocess.check_output(cmd, universal_newlines=True).strip()
+
+
+tests_init = ROOT_DIR / "tests" / "__init__.py"
+
+tests_init_mod = load_module(tests_init)
+
+
+def main():
+    info = {}
+
+    # python
+    info['python'] = ', '.join([
+        platform.python_implementation(),
+        platform.python_version(),
+        platform.python_compiler(),
+    ])
+
+    # OS
+    if psutil.LINUX and shutil.which("lsb_release"):
+        info['OS'] = sh('lsb_release -d -s')
+    elif psutil.OSX:
+        info['OS'] = f"Darwin {platform.mac_ver()[0]}"
+    elif psutil.WINDOWS:
+        info['OS'] = "Windows " + ' '.join(map(str, platform.win32_ver()))
+        if hasattr(platform, 'win32_edition'):
+            info['OS'] += ", " + platform.win32_edition()
+    else:
+        info['OS'] = f"{platform.system()} {platform.version()}"
+    info['arch'] = ', '.join(
+        list(platform.architecture()) + [platform.machine()]
+    )
+    if psutil.POSIX:
+        info['kernel'] = platform.uname()[2]
+
+    # pip
+    info['pip'] = getattr(pip, '__version__', 'not installed')
+    if wheel is not None:
+        info['pip'] += f" (wheel={wheel.__version__})"
+
+    # UNIX
+    if psutil.POSIX:
+        if shutil.which("gcc"):
+            out = sh(['gcc', '--version'])
+            info['gcc'] = str(out).split('\n')[0]
+        else:
+            info['gcc'] = 'not installed'
+        s = platform.libc_ver()[1]
+        if s:
+            info['glibc'] = s
+
+    # system
+    info['fs-encoding'] = sys.getfilesystemencoding()
+    lang = locale.getlocale()
+    info['lang'] = f"{lang[0]}, {lang[1]}"
+    info['boot-time'] = datetime.datetime.fromtimestamp(
+        psutil.boot_time()
+    ).strftime("%Y-%m-%d %H:%M:%S")
+    info['time'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    info['user'] = getpass.getuser()
+    info['home'] = os.path.expanduser("~")
+    info['cwd'] = os.getcwd()
+    info['pyexe'] = tests_init_mod.PYTHON_EXE
+    info['hostname'] = platform.node()
+    info['PID'] = os.getpid()
+
+    # metrics
+    info['cpus'] = psutil.cpu_count()
+    loadavg = tuple(x / psutil.cpu_count() * 100 for x in psutil.getloadavg())
+    info['loadavg'] = (
+        f"{loadavg[0]:.1f}%, {loadavg[1]:.1f}%, {loadavg[2]:.1f}%"
+    )
+    mem = psutil.virtual_memory()
+    info['memory'] = "{}%%, used={}, total={}".format(
+        int(mem.percent),
+        bytes2human(mem.used),
+        bytes2human(mem.total),
+    )
+    swap = psutil.swap_memory()
+    info['swap'] = "{}%%, used={}, total={}".format(
+        int(swap.percent),
+        bytes2human(swap.used),
+        bytes2human(swap.total),
+    )
+
+    # constants
+    constants = sorted([
+        x
+        for x in dir(tests_init_mod)
+        if x.isupper() and getattr(tests_init_mod, x) is True
+    ])
+    info['constants'] = "\n                  ".join(constants)
+
+    # processes
+    # info['pids'] = len(psutil.pids())
+    # pinfo = psutil.Process().as_dict()
+    # pinfo.pop('memory_maps', None)
+    # pinfo["environ"] = {k: os.environ[k] for k in sorted(os.environ)}
+    # info['proc'] = pprint.pformat(pinfo)
+
+    # print
+    print("=" * 70)
+    for k, v in info.items():
+        print("{:<17} {}".format(k + ":", v))
+    print("=" * 70)
+    sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/internal/purge_installation.py b/scripts/internal/purge_installation.py
new file mode 100755
index 0000000000..94c5f287d6
--- /dev/null
+++ b/scripts/internal/purge_installation.py
@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009 Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Purge psutil installation by removing psutil-related files and
+directories found in site-packages directories. This is needed mainly
+because sometimes "import psutil" imports a leftover installation
+from site-packages directory instead of the main working directory.
+"""
+
+import os
+import shutil
+import site
+
+PKGNAME = "psutil"
+
+locations = [site.getusersitepackages()] + site.getsitepackages()
+
+
+def rmpath(path):
+    if os.path.isdir(path):
+        print("rmdir " + path)
+        shutil.rmtree(path)
+    else:
+        print("rm " + path)
+        os.remove(path)
+
+
+def purge():
+    for root in locations:
+        if os.path.isdir(root):
+            for name in os.listdir(root):
+                if PKGNAME in name:
+                    abspath = os.path.join(root, name)
+                    rmpath(abspath)
+
+
+def purge_windows():
+    r"""Uninstalling psutil on Windows is more tricky. On "import
+    psutil" tests may import a psutil version living in
+    C:\PythonXY\Lib\site-packages which is not what we want, so other
+    than "pip uninstall psutil" we also manually remove stuff from
+    site-packages dirs.
+    """
+    for dir in locations:
+        for name in os.listdir(dir):
+            path = os.path.join(dir, name)
+            if name.startswith(PKGNAME):
+                rmpath(path)
+            elif name == 'easy-install.pth':
+                # easy_install can add a line (installation path) into
+                # easy-install.pth; that line alters sys.path.
+                path = os.path.join(dir, name)
+                with open(path) as f:
+                    lines = f.readlines()
+                    hasit = False
+                    for line in lines:
+                        if PKGNAME in line:
+                            hasit = True
+                            break
+                if hasit:
+                    with open(path, "w") as f:
+                        for line in lines:
+                            if PKGNAME not in line:
+                                f.write(line)
+                            else:
+                                print(f"removed line {line!r} from {path!r}")
+
+
+def main():
+    purge()
+    if os.name == "nt":
+        purge_windows()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/iotop.py b/scripts/iotop.py
index 200926ed85..a0ed73a952 100755
--- a/scripts/iotop.py
+++ b/scripts/iotop.py
@@ -1,20 +1,19 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-A clone of iotop (http://guichaz.free.fr/iotop/) showing real time
+"""A clone of iotop (http://guichaz.free.fr/iotop/) showing real time
 disk I/O statistics.
 
-It works on Linux only (FreeBSD and OSX are missing support for IO
+It works on Linux only (FreeBSD and macOS are missing support for IO
 counters).
 It doesn't work on Windows as curses module is required.
 
 Example output:
 
-$ python scripts/iotop.py
+$ python3 scripts/iotop.py
 Total DISK READ: 0.00 B/s | Total DISK WRITE: 472.00 K/s
 PID   USER      DISK READ  DISK WRITE  COMMAND
 13155 giampao    0.00 B/s  428.00 K/s  /usr/bin/google-chrome-beta
@@ -30,31 +29,22 @@
 Author: Giampaolo Rodola' <g.rodola@gmail.com>
 """
 
-import atexit
-import time
 import sys
+import time
+
 try:
     import curses
 except ImportError:
     sys.exit('platform not supported')
 
 import psutil
-
-
-# --- curses stuff
-def tear_down():
-    win.keypad(0)
-    curses.nocbreak()
-    curses.echo()
-    curses.endwin()
+from psutil import bytes2human
 
 win = curses.initscr()
-atexit.register(tear_down)
-curses.endwin()
 lineno = 0
 
 
-def print_line(line, highlight=False):
+def printl(line, highlight=False):
     """A thin wrapper around curses's addstr()."""
     global lineno
     try:
@@ -69,36 +59,17 @@ def print_line(line, highlight=False):
         raise
     else:
         lineno += 1
-# --- /curses stuff
-
-
-def bytes2human(n):
-    """
-    >>> bytes2human(10000)
-    '9.8 K/s'
-    >>> bytes2human(100001221)
-    '95.4 M/s'
-    """
-    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
-    prefix = {}
-    for i, s in enumerate(symbols):
-        prefix[s] = 1 << (i + 1) * 10
-    for s in reversed(symbols):
-        if n >= prefix[s]:
-            value = float(n) / prefix[s]
-            return '%.2f %s/s' % (value, s)
-    return '%.2f B/s' % (n)
 
 
 def poll(interval):
-    """Calculate IO usage by comparing IO statics before and
+    """Calculate IO usage by comparing IO statistics before and
     after the interval.
     Return a tuple including all currently running processes
     sorted by IO activity and total disks I/O activity.
     """
     # first get a list of all processes and disk io counters
-    procs = [p for p in psutil.process_iter()]
-    for p in procs[:]:
+    procs = list(psutil.process_iter())
+    for p in procs.copy():
         try:
             p._before = p.io_counters()
         except psutil.Error:
@@ -110,15 +81,16 @@ def poll(interval):
     time.sleep(interval)
 
     # then retrieve the same info again
-    for p in procs[:]:
-        try:
-            p._after = p.io_counters()
-            p._cmdline = ' '.join(p.cmdline())
-            if not p._cmdline:
-                p._cmdline = p.name()
-            p._username = p.username()
-        except (psutil.NoSuchProcess, psutil.ZombieProcess):
-            procs.remove(p)
+    for p in procs.copy():
+        with p.oneshot():
+            try:
+                p._after = p.io_counters()
+                p._cmdline = ' '.join(p.cmdline())
+                if not p._cmdline:
+                    p._cmdline = p.name()
+                p._username = p.username()
+            except (psutil.NoSuchProcess, psutil.ZombieProcess):
+                procs.remove(p)
     disks_after = psutil.disk_io_counters()
 
     # finally calculate results by comparing data before and
@@ -141,39 +113,67 @@ def poll(interval):
 def refresh_window(procs, disks_read, disks_write):
     """Print results on screen by using curses."""
     curses.endwin()
-    templ = "%-5s %-7s %11s %11s  %s"
+    templ = "{:<5} {:<7} {:>11} {:>11}  {}"
     win.erase()
 
-    disks_tot = "Total DISK READ: %s | Total DISK WRITE: %s" \
-                % (bytes2human(disks_read), bytes2human(disks_write))
-    print_line(disks_tot)
+    disks_tot = "Total DISK READ: {} | Total DISK WRITE: {}".format(
+        bytes2human(disks_read),
+        bytes2human(disks_write),
+    )
+    printl(disks_tot)
 
-    header = templ % ("PID", "USER", "DISK READ", "DISK WRITE", "COMMAND")
-    print_line(header, highlight=True)
+    header = templ.format("PID", "USER", "DISK READ", "DISK WRITE", "COMMAND")
+    printl(header, highlight=True)
 
     for p in procs:
-        line = templ % (
+        line = templ.format(
             p.pid,
             p._username[:7],
             bytes2human(p._read_per_sec),
             bytes2human(p._write_per_sec),
-            p._cmdline)
+            p._cmdline,
+        )
         try:
-            print_line(line)
+            printl(line)
         except curses.error:
             break
     win.refresh()
 
 
+def setup():
+    curses.start_color()
+    curses.use_default_colors()
+    for i in range(curses.COLORS):
+        curses.init_pair(i + 1, i, -1)
+    curses.endwin()
+    win.nodelay(1)
+
+
+def tear_down():
+    win.keypad(0)
+    curses.nocbreak()
+    curses.echo()
+    curses.endwin()
+
+
 def main():
+    global lineno
+    setup()
     try:
         interval = 0
         while True:
+            if win.getch() == ord('q'):
+                break
             args = poll(interval)
             refresh_window(*args)
-            interval = 1
+            lineno = 0
+            interval = 0.5
+            time.sleep(interval)
     except (KeyboardInterrupt, SystemExit):
         pass
+    finally:
+        tear_down()
+
 
 if __name__ == '__main__':
     main()
diff --git a/scripts/killall.py b/scripts/killall.py
index b548e7bc57..532e8b15ce 100755
--- a/scripts/killall.py
+++ b/scripts/killall.py
@@ -1,32 +1,33 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-Kill a process by name.
-"""
+"""Kill a process by name."""
 
 import os
 import sys
+
 import psutil
 
 
 def main():
     if len(sys.argv) != 2:
-        sys.exit('usage: %s name' % __file__)
+        sys.exit(f"usage: {__file__} name")
     else:
-        NAME = sys.argv[1]
+        name = sys.argv[1]
 
     killed = []
     for proc in psutil.process_iter():
-        if proc.name() == NAME and proc.pid != os.getpid():
+        if proc.name() == name and proc.pid != os.getpid():
             proc.kill()
             killed.append(proc.pid)
     if not killed:
-        sys.exit('%s: no process found' % NAME)
+        sys.exit(f"{name}: no process found")
     else:
         sys.exit(0)
 
-sys.exit(main())
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/meminfo.py b/scripts/meminfo.py
index 3546960b2a..9a26aed5a4 100755
--- a/scripts/meminfo.py
+++ b/scripts/meminfo.py
@@ -1,13 +1,12 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-Print system memory information.
+"""Print system memory information.
 
-$ python scripts/meminfo.py
+$ python3 scripts/meminfo.py
 MEMORY
 ------
 Total      :    9.7G
@@ -31,23 +30,7 @@
 """
 
 import psutil
-
-
-def bytes2human(n):
-    # http://code.activestate.com/recipes/578019
-    # >>> bytes2human(10000)
-    # '9.8K'
-    # >>> bytes2human(100001221)
-    # '95.4M'
-    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
-    prefix = {}
-    for i, s in enumerate(symbols):
-        prefix[s] = 1 << (i + 1) * 10
-    for s in reversed(symbols):
-        if n >= prefix[s]:
-            value = float(n) / prefix[s]
-            return '%.1f%s' % (value, s)
-    return "%sB" % n
+from psutil import bytes2human
 
 
 def pprint_ntuple(nt):
@@ -55,7 +38,7 @@ def pprint_ntuple(nt):
         value = getattr(nt, name)
         if name != 'percent':
             value = bytes2human(value)
-        print('%-10s : %7s' % (name.capitalize(), value))
+        print('{:<10} : {:>7}'.format(name.capitalize(), value))
 
 
 def main():
@@ -64,5 +47,6 @@ def main():
     print('\nSWAP\n----')
     pprint_ntuple(psutil.swap_memory())
 
+
 if __name__ == '__main__':
     main()
diff --git a/scripts/netstat.py b/scripts/netstat.py
index a5e171bc49..9f26ee0790 100755
--- a/scripts/netstat.py
+++ b/scripts/netstat.py
@@ -1,13 +1,12 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-A clone of 'netstat -antp' on Linux.
+"""A clone of 'netstat -antp' on Linux.
 
-$ python scripts/netstat.py
+$ python3 scripts/netstat.py
 Proto Local address      Remote address   Status        PID    Program name
 tcp   127.0.0.1:48256    127.0.0.1:45884  ESTABLISHED   13646  chrome
 tcp   127.0.0.1:47073    127.0.0.1:45884  ESTABLISHED   13646  chrome
@@ -20,11 +19,12 @@
 """
 
 import socket
-from socket import AF_INET, SOCK_STREAM, SOCK_DGRAM
+from socket import AF_INET
+from socket import SOCK_DGRAM
+from socket import SOCK_STREAM
 
 import psutil
 
-
 AD = "-"
 AF_INET6 = getattr(socket, 'AF_INET6', object())
 proto_map = {
@@ -36,29 +36,35 @@
 
 
 def main():
-    templ = "%-5s %-30s %-30s %-13s %-6s %s"
-    print(templ % (
-        "Proto", "Local address", "Remote address", "Status", "PID",
-        "Program name"))
+    templ = "{:<5} {:<30} {:<30} {:<13} {:<6} {}"
+    header = templ.format(
+        "Proto",
+        "Local address",
+        "Remote address",
+        "Status",
+        "PID",
+        "Program name",
+    )
+    print(header)
     proc_names = {}
-    for p in psutil.process_iter():
-        try:
-            proc_names[p.pid] = p.name()
-        except psutil.Error:
-            pass
+    for p in psutil.process_iter(['pid', 'name']):
+        proc_names[p.pid] = p.name()
     for c in psutil.net_connections(kind='inet'):
-        laddr = "%s:%s" % (c.laddr)
+        laddr = f"{c.laddr[0]}:{c.laddr[1]}"
         raddr = ""
         if c.raddr:
-            raddr = "%s:%s" % (c.raddr)
-        print(templ % (
+            raddr = f"{c.raddr[0]}:{c.raddr[1]}"
+        name = proc_names.get(c.pid, '?') or ''
+        line = templ.format(
             proto_map[(c.family, c.type)],
             laddr,
             raddr or AD,
             c.status,
             c.pid or AD,
-            proc_names.get(c.pid, '?')[:15],
-        ))
+            name[:15],
+        )
+        print(line)
+
 
 if __name__ == '__main__':
     main()
diff --git a/scripts/nettop.py b/scripts/nettop.py
index acfa650066..98732b5ff2 100755
--- a/scripts/nettop.py
+++ b/scripts/nettop.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 #
 # $Id: iotop.py 1160 2011-10-14 18:50:36Z g.rodola@gmail.com $
 #
@@ -6,12 +6,11 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-Shows real-time network statistics.
+"""Shows real-time network statistics.
 
 Author: Giampaolo Rodola' <g.rodola@gmail.com>
 
-$ python scripts/nettop.py
+$ python3 scripts/nettop.py
 -----------------------------------------------------------
 total bytes:           sent: 1.49 G       received: 4.82 G
 total packets:         sent: 7338724      received: 8082712
@@ -31,31 +30,22 @@
 pkts-recv               1214470               0
 """
 
-import atexit
-import time
 import sys
+import time
+
 try:
     import curses
 except ImportError:
     sys.exit('platform not supported')
 
 import psutil
+from psutil import bytes2human
 
-
-# --- curses stuff
-def tear_down():
-    win.keypad(0)
-    curses.nocbreak()
-    curses.echo()
-    curses.endwin()
-
-win = curses.initscr()
-atexit.register(tear_down)
-curses.endwin()
 lineno = 0
+win = curses.initscr()
 
 
-def print_line(line, highlight=False):
+def printl(line, highlight=False):
     """A thin wrapper around curses's addstr()."""
     global lineno
     try:
@@ -70,25 +60,6 @@ def print_line(line, highlight=False):
         raise
     else:
         lineno += 1
-# --- curses stuff
-
-
-def bytes2human(n):
-    """
-    >>> bytes2human(10000)
-    '9.8 K'
-    >>> bytes2human(100001221)
-    '95.4 M'
-    """
-    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
-    prefix = {}
-    for i, s in enumerate(symbols):
-        prefix[s] = 1 << (i + 1) * 10
-    for s in reversed(symbols):
-        if n >= prefix[s]:
-            value = float(n) / prefix[s]
-            return '%.2f %s' % (value, s)
-    return '%.2f B' % (n)
 
 
 def poll(interval):
@@ -107,59 +78,83 @@ def refresh_window(tot_before, tot_after, pnic_before, pnic_after):
     global lineno
 
     # totals
-    print_line("total bytes:           sent: %-10s   received: %s" % (
-        bytes2human(tot_after.bytes_sent),
-        bytes2human(tot_after.bytes_recv))
+    printl(
+        "total bytes:           sent: {:<10}   received: {}".format(
+            bytes2human(tot_after.bytes_sent),
+            bytes2human(tot_after.bytes_recv),
+        )
     )
-    print_line("total packets:         sent: %-10s   received: %s" % (
-        tot_after.packets_sent, tot_after.packets_recv))
 
     # per-network interface details: let's sort network interfaces so
     # that the ones which generated more traffic are shown first
-    print_line("")
+    printl("")
     nic_names = list(pnic_after.keys())
     nic_names.sort(key=lambda x: sum(pnic_after[x]), reverse=True)
     for name in nic_names:
         stats_before = pnic_before[name]
         stats_after = pnic_after[name]
-        templ = "%-15s %15s %15s"
-        print_line(templ % (name, "TOTAL", "PER-SEC"), highlight=True)
-        print_line(templ % (
+        templ = "{:<15s} {:>15} {:>15}"
+        # fmt: off
+        printl(templ.format(name, "TOTAL", "PER-SEC"), highlight=True)
+        printl(templ.format(
             "bytes-sent",
             bytes2human(stats_after.bytes_sent),
             bytes2human(
                 stats_after.bytes_sent - stats_before.bytes_sent) + '/s',
         ))
-        print_line(templ % (
+        printl(templ.format(
             "bytes-recv",
             bytes2human(stats_after.bytes_recv),
             bytes2human(
                 stats_after.bytes_recv - stats_before.bytes_recv) + '/s',
         ))
-        print_line(templ % (
+        printl(templ.format(
             "pkts-sent",
             stats_after.packets_sent,
             stats_after.packets_sent - stats_before.packets_sent,
         ))
-        print_line(templ % (
+        printl(templ.format(
             "pkts-recv",
             stats_after.packets_recv,
             stats_after.packets_recv - stats_before.packets_recv,
         ))
-        print_line("")
+        printl("")
+        # fmt: on
     win.refresh()
     lineno = 0
 
 
+def setup():
+    curses.start_color()
+    curses.use_default_colors()
+    for i in range(curses.COLORS):
+        curses.init_pair(i + 1, i, -1)
+    curses.endwin()
+    win.nodelay(1)
+
+
+def tear_down():
+    win.keypad(0)
+    curses.nocbreak()
+    curses.echo()
+    curses.endwin()
+
+
 def main():
+    setup()
     try:
         interval = 0
         while True:
+            if win.getch() == ord('q'):
+                break
             args = poll(interval)
             refresh_window(*args)
-            interval = 1
+            interval = 0.5
     except (KeyboardInterrupt, SystemExit):
         pass
+    finally:
+        tear_down()
+
 
 if __name__ == '__main__':
     main()
diff --git a/scripts/pidof.py b/scripts/pidof.py
index 8692a3152b..2353126621 100755
--- a/scripts/pidof.py
+++ b/scripts/pidof.py
@@ -1,53 +1,40 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola', karthikrev. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 
-"""
-A clone of 'pidof' cmdline utility.
+"""A clone of 'pidof' cmdline utility.
+
 $ pidof python
 1140 1138 1136 1134 1133 1129 1127 1125 1121 1120 1119
 """
 
-from __future__ import print_function
-import psutil
 import sys
 
+import psutil
+
 
 def pidof(pgname):
-    pids = []
-    for proc in psutil.process_iter():
-        # search for matches in the process name and cmdline
-        try:
-            name = proc.name()
-        except psutil.Error:
-            pass
-        else:
-            if name == pgname:
-                pids.append(str(proc.pid))
-                continue
-
-        try:
-            cmdline = proc.cmdline()
-        except psutil.Error:
-            pass
-        else:
-            if cmdline and cmdline[0] == pgname:
-                pids.append(str(proc.pid))
-
-    return pids
+    # search for matches in the process name and cmdline
+    return [
+        str(proc.pid)
+        for proc in psutil.process_iter(['name', 'cmdline'])
+        if proc.name() == pgname
+        or (proc.cmdline() and proc.cmdline()[0] == pgname)
+    ]
 
 
 def main():
     if len(sys.argv) != 2:
-        sys.exit('usage: %s pgname' % __file__)
+        sys.exit(f"usage: {__file__} pgname")
     else:
         pgname = sys.argv[1]
     pids = pidof(pgname)
     if pids:
         print(" ".join(pids))
 
+
 if __name__ == '__main__':
     main()
diff --git a/scripts/pmap.py b/scripts/pmap.py
index f0d53355fe..96ed73a9f5 100755
--- a/scripts/pmap.py
+++ b/scripts/pmap.py
@@ -1,19 +1,17 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-A clone of 'pmap' utility on Linux, 'vmmap' on OSX and 'procstat -v' on BSD.
-Report memory map of a process.
+"""A clone of 'pmap' utility on Linux, 'vmmap' on macOS and 'procstat
+-v' on BSD. Report memory map of a process.
 
-$ python scripts/pmap.py 32402
-pid=32402, name=hg
+$ python3 scripts/pmap.py 32402
 Address                 RSS  Mode    Mapping
-0000000000400000      1200K  r-xp    /usr/bin/python2.7
-0000000000838000         4K  r--p    /usr/bin/python2.7
-0000000000839000       304K  rw-p    /usr/bin/python2.7
+0000000000400000      1200K  r-xp    /usr/bin/python3.7
+0000000000838000         4K  r--p    /usr/bin/python3.7
+0000000000839000       304K  rw-p    /usr/bin/python3.7
 00000000008ae000        68K  rw-p    [anon]
 000000000275e000      5396K  rw-p    [heap]
 00002b29bb1e0000       124K  r-xp    /lib/x86_64-linux-gnu/ld-2.17.so
@@ -30,28 +28,41 @@
 ...
 """
 
+import shutil
 import sys
 
 import psutil
+from psutil import bytes2human
+
+
+def safe_print(s):
+    s = s[: shutil.get_terminal_size()[0]]
+    try:
+        print(s)
+    except UnicodeEncodeError:
+        print(s.encode('ascii', 'ignore').decode())
 
 
 def main():
     if len(sys.argv) != 2:
         sys.exit('usage: pmap <pid>')
     p = psutil.Process(int(sys.argv[1]))
-    print("pid=%s, name=%s" % (p.pid, p.name()))
-    templ = "%-16s %10s  %-7s %s"
-    print(templ % ("Address", "RSS", "Mode", "Mapping"))
+    templ = "{:<20} {:>10}  {:<7} {}"
+    print(templ.format("Address", "RSS", "Mode", "Mapping"))
     total_rss = 0
     for m in p.memory_maps(grouped=False):
         total_rss += m.rss
-        print(templ % (
+        line = templ.format(
             m.addr.split('-')[0].zfill(16),
-            str(m.rss / 1024) + 'K',
+            bytes2human(m.rss),
             m.perms,
-            m.path))
-    print("-" * 33)
-    print(templ % ("Total", str(total_rss / 1024) + 'K', '', ''))
+            m.path,
+        )
+        safe_print(line)
+    print("-" * 31)
+    print(templ.format("Total", bytes2human(total_rss), "", ""))
+    safe_print(f"PID = {p.pid}, name = {p.name()}")
+
 
 if __name__ == '__main__':
     main()
diff --git a/scripts/procinfo.py b/scripts/procinfo.py
index 9990086f10..0a4125417f 100755
--- a/scripts/procinfo.py
+++ b/scripts/procinfo.py
@@ -1,141 +1,252 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-Print detailed information about a process.
+"""Print detailed information about a process.
+
 Author: Giampaolo Rodola' <g.rodola@gmail.com>
 
-$ python scripts/process_detail.py
-pid               820
-name              python
-exe               /usr/bin/python2.7
-parent            29613 (bash)
-cmdline           python scripts/process_detail.py
-started           2014-41-27 03:41
-user              giampaolo
-uids              real=1000, effective=1000, saved=1000
-gids              real=1000, effective=1000, saved=1000
-terminal          /dev/pts/17
-cwd               /ssd/svn/psutil
-memory            0.1% (resident=10.6M, virtual=58.5M)
-cpu               0.0% (user=0.09, system=0.0)
-status            running
-niceness          0
-num threads       1
-I/O               bytes-read=0B, bytes-written=0B
-open files
-running threads   id=820, user-time=0.09, sys-time=0.0
+$ python3 scripts/procinfo.py
+pid           4600
+name          chrome
+parent        4554 (bash)
+exe           /opt/google/chrome/chrome
+cwd           /home/giampaolo
+cmdline       /opt/google/chrome/chrome
+started       2016-09-19 11:12
+cpu-tspent    27:27.68
+cpu-times     user=8914.32, system=3530.59,
+              children_user=1.46, children_system=1.31
+cpu-affinity  [0, 1, 2, 3, 4, 5, 6, 7]
+memory        rss=520.5M, vms=1.9G, shared=132.6M, text=95.0M, lib=0B,
+              data=816.5M, dirty=0B
+memory %      3.26
+user          giampaolo
+uids          real=1000, effective=1000, saved=1000
+uids          real=1000, effective=1000, saved=1000
+terminal      /dev/pts/2
+status        sleeping
+nice          0
+ionice        class=IOPriority.IOPRIO_CLASS_NONE, value=0
+num-threads   47
+num-fds       379
+I/O           read_count=96.6M, write_count=80.7M,
+              read_bytes=293.2M, write_bytes=24.5G
+ctx-switches  voluntary=30426463, involuntary=460108
+children      PID    NAME
+              4605   cat
+              4606   cat
+              4609   chrome
+              4669   chrome
+open-files    PATH
+              /opt/google/chrome/icudtl.dat
+              /opt/google/chrome/snapshot_blob.bin
+              /opt/google/chrome/natives_blob.bin
+              /opt/google/chrome/chrome_100_percent.pak
+              [...]
+connections   PROTO LOCAL ADDR            REMOTE ADDR               STATUS
+              UDP   10.0.0.3:3693         *:*                       NONE
+              TCP   10.0.0.3:55102        172.217.22.14:443         ESTABLISHED
+              UDP   10.0.0.3:35172        *:*                       NONE
+              TCP   10.0.0.3:32922        172.217.16.163:443        ESTABLISHED
+              UDP   :::5353               *:*                       NONE
+              UDP   10.0.0.3:59925        *:*                       NONE
+threads       TID              USER          SYSTEM
+              11795             0.7            1.35
+              11796            0.68            1.37
+              15887            0.74            0.03
+              19055            0.77            0.01
+              [...]
+              total=47
+res-limits    RLIMIT                     SOFT       HARD
+              virtualmem             infinity   infinity
+              coredumpsize                  0   infinity
+              cputime                infinity   infinity
+              datasize               infinity   infinity
+              filesize               infinity   infinity
+              locks                  infinity   infinity
+              memlock                   65536      65536
+              msgqueue                 819200     819200
+              nice                          0          0
+              openfiles                  8192      65536
+              maxprocesses              63304      63304
+              rss                    infinity   infinity
+              realtimeprio                  0          0
+              rtimesched             infinity   infinity
+              sigspending               63304      63304
+              stack                   8388608   infinity
+mem-maps      RSS      PATH
+              381.4M   [anon]
+              62.8M    /opt/google/chrome/chrome
+              15.8M    /home/giampaolo/.config/google-chrome/Default/History
+              6.6M     /home/giampaolo/.config/google-chrome/Default/Favicons
+              [...]
 """
 
+import argparse
 import datetime
-import os
 import socket
 import sys
 
 import psutil
+from psutil import bytes2human
 
-
-POSIX = os.name == 'posix'
-
-
-def convert_bytes(n):
-    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
-    prefix = {}
-    for i, s in enumerate(symbols):
-        prefix[s] = 1 << (i + 1) * 10
-    for s in reversed(symbols):
-        if n >= prefix[s]:
-            value = float(n) / prefix[s]
-            return '%.1f%s' % (value, s)
-    return "%sB" % n
+ACCESS_DENIED = ''
+NON_VERBOSE_ITERATIONS = 4
+RLIMITS_MAP = {
+    "RLIMIT_AS": "virtualmem",
+    "RLIMIT_CORE": "coredumpsize",
+    "RLIMIT_CPU": "cputime",
+    "RLIMIT_DATA": "datasize",
+    "RLIMIT_FSIZE": "filesize",
+    "RLIMIT_MEMLOCK": "memlock",
+    "RLIMIT_MSGQUEUE": "msgqueue",
+    "RLIMIT_NICE": "nice",
+    "RLIMIT_NOFILE": "openfiles",
+    "RLIMIT_NPROC": "maxprocesses",
+    "RLIMIT_NPTS": "pseudoterms",
+    "RLIMIT_RSS": "rss",
+    "RLIMIT_RTPRIO": "realtimeprio",
+    "RLIMIT_RTTIME": "rtimesched",
+    "RLIMIT_SBSIZE": "sockbufsize",
+    "RLIMIT_SIGPENDING": "sigspending",
+    "RLIMIT_STACK": "stack",
+    "RLIMIT_SWAP": "swapuse",
+}
 
 
 def print_(a, b):
-    if sys.stdout.isatty() and POSIX:
-        fmt = '\x1b[1;32m%-17s\x1b[0m %s' % (a, b)
+    if sys.stdout.isatty() and psutil.POSIX:
+        fmt = "\x1b[1;32m{:<13}\x1b[0m {}".format(a, b)
     else:
-        fmt = '%-15s %s' % (a, b)
+        fmt = "{:<11} {}".format(a, b)
     print(fmt)
 
 
-def run(pid):
-    ACCESS_DENIED = ''
+def str_ntuple(nt, convert_bytes=False):
+    if nt == ACCESS_DENIED:
+        return ""
+    if not convert_bytes:
+        return ", ".join([f"{x}={getattr(nt, x)}" for x in nt._fields])
+    else:
+        return ", ".join(
+            [f"{x}={bytes2human(getattr(nt, x))}" for x in nt._fields]
+        )
+
+
+def run(pid, verbose=False):
     try:
-        p = psutil.Process(pid)
-        pinfo = p.as_dict(ad_value=ACCESS_DENIED)
+        proc = psutil.Process(pid)
+        pinfo = proc.as_dict(ad_value=ACCESS_DENIED)
     except psutil.NoSuchProcess as err:
         sys.exit(str(err))
 
-    try:
-        parent = p.parent()
-        if parent:
-            parent = '(%s)' % parent.name()
-        else:
+    # collect other proc info
+    with proc.oneshot():
+        try:
+            parent = proc.parent()
+            parent = f"({parent.name()})" if parent else ""
+        except psutil.Error:
             parent = ''
-    except psutil.Error:
-        parent = ''
-    if pinfo['create_time'] != ACCESS_DENIED:
-        started = datetime.datetime.fromtimestamp(
-            pinfo['create_time']).strftime('%Y-%m-%d %H:%M')
-    else:
-        started = ACCESS_DENIED
-    io = pinfo.get('io_counters', ACCESS_DENIED)
-    if pinfo['memory_info'] != ACCESS_DENIED:
-        mem = '%s%% (resident=%s, virtual=%s) ' % (
-            round(pinfo['memory_percent'], 1),
-            convert_bytes(pinfo['memory_info'].rss),
-            convert_bytes(pinfo['memory_info'].vms))
-    else:
-        mem = ACCESS_DENIED
-    children = p.children()
+        try:
+            pinfo['children'] = proc.children()
+        except psutil.Error:
+            pinfo['children'] = []
+        if pinfo['create_time']:
+            started = datetime.datetime.fromtimestamp(
+                pinfo['create_time']
+            ).strftime('%Y-%m-%d %H:%M')
+        else:
+            started = ACCESS_DENIED
 
+    # here we go
     print_('pid', pinfo['pid'])
     print_('name', pinfo['name'])
+    print_('parent', f"{pinfo['ppid']} {parent}")
     print_('exe', pinfo['exe'])
-    print_('parent', '%s %s' % (pinfo['ppid'], parent))
+    print_('cwd', pinfo['cwd'])
     print_('cmdline', ' '.join(pinfo['cmdline']))
     print_('started', started)
+
+    cpu_tot_time = datetime.timedelta(seconds=sum(pinfo['cpu_times']))
+    cpu_tot_time = "{}:{}.{}".format(
+        cpu_tot_time.seconds // 60 % 60,
+        str(cpu_tot_time.seconds % 60).zfill(2),
+        str(cpu_tot_time.microseconds)[:2],
+    )
+    print_('cpu-tspent', cpu_tot_time)
+    print_('cpu-times', str_ntuple(pinfo['cpu_times']))
+    if hasattr(proc, "cpu_affinity"):
+        print_("cpu-affinity", pinfo["cpu_affinity"])
+    if hasattr(proc, "cpu_num"):
+        print_("cpu-num", pinfo["cpu_num"])
+
+    print_('memory', str_ntuple(pinfo['memory_info'], convert_bytes=True))
+    print_('memory %', round(pinfo['memory_percent'], 2))
     print_('user', pinfo['username'])
-    if POSIX and pinfo['uids'] and pinfo['gids']:
-        print_('uids', 'real=%s, effective=%s, saved=%s' % pinfo['uids'])
-    if POSIX and pinfo['gids']:
-        print_('gids', 'real=%s, effective=%s, saved=%s' % pinfo['gids'])
-    if POSIX:
+    if psutil.POSIX:
+        print_('uids', str_ntuple(pinfo['uids']))
+    if psutil.POSIX:
+        print_('uids', str_ntuple(pinfo['uids']))
+    if psutil.POSIX:
         print_('terminal', pinfo['terminal'] or '')
-    print_('cwd', pinfo['cwd'])
-    print_('memory', mem)
-    print_('cpu', '%s%% (user=%s, system=%s)' % (
-        pinfo['cpu_percent'],
-        getattr(pinfo['cpu_times'], 'user', '?'),
-        getattr(pinfo['cpu_times'], 'system', '?')))
+
     print_('status', pinfo['status'])
-    print_('niceness', pinfo['nice'])
-    print_('num threads', pinfo['num_threads'])
-    if io != ACCESS_DENIED:
-        print_('I/O', 'bytes-read=%s, bytes-written=%s' % (
-            convert_bytes(io.read_bytes),
-            convert_bytes(io.write_bytes)))
-    if children:
-        print_('children', '')
-        for child in children:
-            print_('', 'pid=%s name=%s' % (child.pid, child.name()))
-
-    if pinfo['open_files'] != ACCESS_DENIED and pinfo['open_files']:
-        print_('open files', '')
-        for file in pinfo['open_files']:
-            print_('', 'fd=%s %s ' % (file.fd, file.path))
+    print_('nice', pinfo['nice'])
+    if hasattr(proc, "ionice"):
+        try:
+            ionice = proc.ionice()
+        except psutil.Error:
+            pass
+        else:
+            if psutil.WINDOWS:
+                print_("ionice", ionice)
+            else:
+                print_(
+                    "ionice",
+                    f"class={ionice.ioclass}, value={ionice.value}",
+                )
 
-    if pinfo['threads'] and len(pinfo['threads']) > 1:
-        print_('running threads', '')
-        for thread in pinfo['threads']:
-            print_('', 'id=%s, user-time=%s, sys-time=%s' % (
-                thread.id, thread.user_time, thread.system_time))
-    if pinfo['connections'] not in (ACCESS_DENIED, []):
-        print_('open connections', '')
-        for conn in pinfo['connections']:
+    print_('num-threads', pinfo['num_threads'])
+    if psutil.POSIX:
+        print_('num-fds', pinfo['num_fds'])
+    if psutil.WINDOWS:
+        print_('num-handles', pinfo['num_handles'])
+
+    if 'io_counters' in pinfo:
+        print_('I/O', str_ntuple(pinfo['io_counters'], convert_bytes=True))
+    if 'num_ctx_switches' in pinfo:
+        print_("ctx-switches", str_ntuple(pinfo['num_ctx_switches']))
+    if pinfo['children']:
+        template = "{:<6} {}"
+        print_("children", template.format("PID", "NAME"))
+        for child in pinfo['children']:
+            try:
+                print_("", template.format(child.pid, child.name()))
+            except psutil.AccessDenied:
+                print_("", template.format(child.pid, ""))
+            except psutil.NoSuchProcess:
+                pass
+
+    if pinfo['open_files']:
+        print_('open-files', 'PATH')
+        for i, file in enumerate(pinfo['open_files']):
+            if not verbose and i >= NON_VERBOSE_ITERATIONS:
+                print_("", "[...]")
+                break
+            print_('', file.path)
+    else:
+        print_('open-files', '')
+
+    if pinfo['net_connections']:
+        template = "{:<5} {:<25} {:<25} {}"
+        print_(
+            'connections',
+            template.format("PROTO", "LOCAL ADDR", "REMOTE ADDR", "STATUS"),
+        )
+        for conn in pinfo['net_connections']:
             if conn.type == socket.SOCK_STREAM:
                 type = 'TCP'
             elif conn.type == socket.SOCK_DGRAM:
@@ -147,19 +258,84 @@ def run(pid):
                 rip, rport = '*', '*'
             else:
                 rip, rport = conn.raddr
-            print_('', '%s:%s -> %s:%s type=%s status=%s' % (
-                lip, lport, rip, rport, type, conn.status))
-
+            line = template.format(
+                type,
+                f"{lip}:{lport}",
+                f"{rip}:{rport}",
+                conn.status,
+            )
+            print_('', line)
+    else:
+        print_('connections', '')
 
-def main(argv=None):
-    if argv is None:
-        argv = sys.argv
-    if len(argv) == 1:
-        sys.exit(run(os.getpid()))
-    elif len(argv) == 2:
-        sys.exit(run(int(argv[1])))
+    if pinfo['threads'] and len(pinfo['threads']) > 1:
+        template = "{:<5} {:>12} {:>12}"
+        print_("threads", template.format("TID", "USER", "SYSTEM"))
+        for i, thread in enumerate(pinfo['threads']):
+            if not verbose and i >= NON_VERBOSE_ITERATIONS:
+                print_("", "[...]")
+                break
+            print_("", template.format(*thread))
+        print_('', f"total={len(pinfo['threads'])}")
     else:
-        sys.exit('usage: %s [pid]' % __file__)
+        print_('threads', '')
+
+    if hasattr(proc, "rlimit"):
+        res_names = [x for x in dir(psutil) if x.startswith("RLIMIT")]
+        resources = []
+        for res_name in res_names:
+            try:
+                soft, hard = proc.rlimit(getattr(psutil, res_name))
+            except psutil.AccessDenied:
+                pass
+            else:
+                resources.append((res_name, soft, hard))
+        if resources:
+            template = "{:<12} {:>15} {:>15}"
+            print_("res-limits", template.format("RLIMIT", "SOFT", "HARD"))
+            for res_name, soft, hard in resources:
+                if soft == psutil.RLIM_INFINITY:
+                    soft = "infinity"
+                if hard == psutil.RLIM_INFINITY:
+                    hard = "infinity"
+                print_(
+                    '',
+                    template.format(
+                        RLIMITS_MAP.get(res_name, res_name), soft, hard
+                    ),
+                )
+
+    if hasattr(proc, "environ") and pinfo['environ']:
+        template = "{:<25} {}"
+        print_("environ", template.format("NAME", "VALUE"))
+        for i, k in enumerate(sorted(pinfo['environ'])):
+            if not verbose and i >= NON_VERBOSE_ITERATIONS:
+                print_("", "[...]")
+                break
+            print_("", template.format(k, pinfo["environ"][k]))
+
+    if pinfo.get('memory_maps', None):
+        template = "{:<8} {}"
+        print_("mem-maps", template.format("RSS", "PATH"))
+        maps = sorted(pinfo['memory_maps'], key=lambda x: x.rss, reverse=True)
+        for i, region in enumerate(maps):
+            if not verbose and i >= NON_VERBOSE_ITERATIONS:
+                print_("", "[...]")
+                break
+            print_("", template.format(bytes2human(region.rss), region.path))
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="print information about a process"
+    )
+    parser.add_argument("pid", type=int, help="process pid", nargs='?')
+    parser.add_argument(
+        '--verbose', '-v', action='store_true', help="print more info"
+    )
+    args = parser.parse_args()
+    run(args.pid, args.verbose)
+
 
 if __name__ == '__main__':
     sys.exit(main())
diff --git a/scripts/procsmem.py b/scripts/procsmem.py
index 494fd6aba5..6ccb08b593 100755
--- a/scripts/procsmem.py
+++ b/scripts/procsmem.py
@@ -1,11 +1,10 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-Show detailed memory usage about all (querable) processes.
+"""Show detailed memory usage about all (querable) processes.
 
 Processes are sorted by their "USS" (Unique Set Size) memory, which is
 probably the most representative metric for determining how much memory
@@ -33,16 +32,15 @@
 20513   giampao /opt/sublime_text/sublime_text   65.8M   73.0M      0B   87.9M
 3976    giampao compiz                          115.0M  117.0M      0B  130.9M
 32486   giampao skype                           145.1M  147.5M      0B  149.6M
+
 """
 
-from __future__ import print_function
 import sys
 
 import psutil
 
-
-if not (psutil.LINUX or psutil.OSX or psutil.WINDOWS):
-    sys.exit("platform not supported")
+if not hasattr(psutil.Process, "memory_footprint"):
+    sys.exit("can't retrieve USS memory on this platform")
 
 
 def convert_bytes(n):
@@ -53,49 +51,56 @@ def convert_bytes(n):
     for s in reversed(symbols):
         if n >= prefix[s]:
             value = float(n) / prefix[s]
-            return '%.1f%s' % (value, s)
-    return "%sB" % n
+            return f"{value:.1f}{s}"
+    return f"{n}B"
 
 
 def main():
     ad_pids = []
     procs = []
     for p in psutil.process_iter():
-        try:
-            mem = p.memory_full_info()
-            info = p.as_dict(attrs=["cmdline", "username"])
-        except psutil.AccessDenied:
-            ad_pids.append(p.pid)
-        except psutil.NoSuchProcess:
-            pass
-        else:
-            p._uss = mem.uss
-            p._rss = mem.rss
-            if not p._uss:
-                continue
-            p._pss = getattr(mem, "pss", "")
-            p._swap = getattr(mem, "swap", "")
-            p._info = info
-            procs.append(p)
+        with p.oneshot():
+            try:
+                mem = p.memory_footprint()
+                info = p.as_dict(["cmdline", "username", "memory_info"])
+            except psutil.AccessDenied:
+                ad_pids.append(p.pid)
+            except psutil.NoSuchProcess:
+                pass
+            else:
+                p._uss = mem.uss
+                p._rss = info["memory_info"].rss
+                p._vms = info["memory_info"].vms
+                if not p._uss:
+                    continue
+                p._pss = getattr(mem, "pss", "")
+                p._swap = getattr(mem, "swap", "")
+                p._info = info
+                procs.append(p)
 
     procs.sort(key=lambda p: p._uss)
-    templ = "%-7s %-7s %-30s %7s %7s %7s %7s"
-    print(templ % ("PID", "User", "Cmdline", "USS", "PSS", "Swap", "RSS"))
-    print("=" * 78)
-    for p in procs:
-        line = templ % (
+    templ = "{:<7} {:<7} {:>7} {:>7} {:>7} {:>7} {:>7} {}"
+    header = templ.format(
+        "PID", "User", "USS", "PSS", "Swap", "RSS", "VMS", "Cmdline"
+    )
+    print(header)
+    print("=" * len(header))
+    for p in procs[:86]:
+        cmd = " ".join(p._info["cmdline"])[:50] if p._info["cmdline"] else ""
+        line = templ.format(
             p.pid,
-            p._info["username"][:7],
-            " ".join(p._info["cmdline"])[:30],
+            p._info["username"][:7] if p._info["username"] else "",
             convert_bytes(p._uss),
-            convert_bytes(p._pss) if p._pss != "" else "",
-            convert_bytes(p._swap) if p._swap != "" else "",
+            convert_bytes(p._pss) if p._pss else "",
+            convert_bytes(p._swap) if p._swap else "",
             convert_bytes(p._rss),
+            convert_bytes(p._vms),
+            cmd,
         )
         print(line)
     if ad_pids:
-        print("warning: access denied for %s pids" % (len(ad_pids)),
-              file=sys.stderr)
+        print(f"warning: access denied for {len(ad_pids)} pids")
+
 
 if __name__ == '__main__':
     sys.exit(main())
diff --git a/scripts/ps.py b/scripts/ps.py
index 8aa3d3f495..fe4a7ac770 100755
--- a/scripts/ps.py
+++ b/scripts/ps.py
@@ -1,102 +1,115 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-A clone of 'ps -aux' on UNIX.
+"""A clone of 'ps aux'.
 
-$ python scripts/ps.py
-...
+$ python3 scripts/ps.py
+USER         PID  %MEM     VSZ     RSS  NICE STATUS  START   TIME  CMDLINE
+root           1   0.0  220.9M    6.5M        sleep  Mar27  09:10  /lib/systemd
+root           2   0.0    0.0B    0.0B        sleep  Mar27  00:00  kthreadd
+root           4   0.0    0.0B    0.0B   -20   idle  Mar27  00:00  kworker/0:0H
+root           6   0.0    0.0B    0.0B   -20   idle  Mar27  00:00  mm_percpu_wq
+root           7   0.0    0.0B    0.0B        sleep  Mar27  00:06  ksoftirqd/0
+root           8   0.0    0.0B    0.0B         idle  Mar27  03:32  rcu_sched
+root           9   0.0    0.0B    0.0B         idle  Mar27  00:00  rcu_bh
+root          10   0.0    0.0B    0.0B        sleep  Mar27  00:00  migration/0
+root          11   0.0    0.0B    0.0B        sleep  Mar27  00:00  watchdog/0
+root          12   0.0    0.0B    0.0B        sleep  Mar27  00:00  cpuhp/0
+root          13   0.0    0.0B    0.0B        sleep  Mar27  00:00  cpuhp/1
+root          14   0.0    0.0B    0.0B        sleep  Mar27  00:01  watchdog/1
+root          15   0.0    0.0B    0.0B        sleep  Mar27  00:00  migration/1
+[...]
+giampaolo  19704   1.5    1.9G  235.6M        sleep  17:39  01:11  firefox
+root       20414   0.0    0.0B    0.0B         idle  Apr04  00:00  kworker/4:2
+giampaolo  20952   0.0   10.7M  100.0K        sleep  Mar28  00:00  sh -c /usr
+giampaolo  20953   0.0  269.0M  528.0K        sleep  Mar28  00:00  /usr/lib/
+giampaolo  22150   3.3    2.4G  525.5M        sleep  Apr02  49:09  /usr/lib/
+root       22338   0.0    0.0B    0.0B         idle  02:04  00:00  kworker/1:2
+giampaolo  24123   0.0   35.0M    7.0M        sleep  02:12  00:02  bash
 """
 
 import datetime
-import os
+import shutil
 import time
 
 import psutil
-
-PROC_STATUSES_RAW = {
-    psutil.STATUS_RUNNING: "R",
-    psutil.STATUS_SLEEPING: "S",
-    psutil.STATUS_DISK_SLEEP: "D",
-    psutil.STATUS_STOPPED: "T",
-    psutil.STATUS_TRACING_STOP: "t",
-    psutil.STATUS_ZOMBIE: "Z",
-    psutil.STATUS_DEAD: "X",
-    psutil.STATUS_WAKING: "WA",
-    psutil.STATUS_IDLE: "I",
-    psutil.STATUS_LOCKED: "L",
-    psutil.STATUS_WAITING: "W",
-}
-
-if hasattr(psutil, 'STATUS_WAKE_KILL'):
-    PROC_STATUSES_RAW[psutil.STATUS_WAKE_KILL] = "WK"
-
-if hasattr(psutil, 'STATUS_SUSPENDED'):
-    PROC_STATUSES_RAW[psutil.STATUS_SUSPENDED] = "V"
+from psutil import bytes2human
 
 
 def main():
     today_day = datetime.date.today()
-    templ = "%-10s %5s %4s %4s %7s %7s %-13s %-5s %5s %7s  %s"
-    attrs = ['pid', 'cpu_percent', 'memory_percent', 'name', 'cpu_times',
-             'create_time', 'memory_info', 'status']
-    if os.name == 'posix':
-        attrs.append('uids')
-        attrs.append('terminal')
-    print(templ % ("USER", "PID", "%CPU", "%MEM", "VSZ", "RSS", "TTY",
-                   "STAT", "START", "TIME", "COMMAND"))
-    for p in psutil.process_iter():
-        try:
-            pinfo = p.as_dict(attrs, ad_value='')
-        except psutil.NoSuchProcess:
-            pass
-        else:
-            if pinfo['create_time']:
-                ctime = datetime.datetime.fromtimestamp(pinfo['create_time'])
-                if ctime.date() == today_day:
-                    ctime = ctime.strftime("%H:%M")
-                else:
-                    ctime = ctime.strftime("%b%d")
+    # fmt: off
+    templ = "{:<10} {:>5} {:>5} {:>7} {:>7} {:>5} {:>6} {:>6} {:>6}  {}"
+    attrs = ['pid', 'memory_percent', 'name', 'cmdline', 'cpu_times',
+             'create_time', 'memory_info', 'status', 'nice', 'username']
+    print(templ.format("USER", "PID", "%MEM", "VSZ", "RSS", "NICE",
+                       "STATUS", "START", "TIME", "CMDLINE"))
+    # fmt: on
+    for p in psutil.process_iter(attrs, ad_value=None):
+        if p.create_time():
+            ctime = datetime.datetime.fromtimestamp(p.create_time())
+            if ctime.date() == today_day:
+                ctime = ctime.strftime("%H:%M")
             else:
-                ctime = ''
-            cputime = time.strftime("%M:%S",
-                                    time.localtime(sum(pinfo['cpu_times'])))
+                ctime = ctime.strftime("%b%d")
+        else:
+            ctime = ''
+        if p.cpu_times():
+            cputime = time.strftime(
+                "%M:%S", time.localtime(sum(p.cpu_times()))
+            )
+        else:
+            cputime = ''
+
+        user = p.username()
+        if not user and psutil.POSIX:
             try:
-                user = p.username()
-            except KeyError:
-                if os.name == 'posix':
-                    if pinfo['uids']:
-                        user = str(pinfo['uids'].real)
-                    else:
-                        user = ''
-                else:
-                    raise
+                user = p.uids()[0]
             except psutil.Error:
-                user = ''
-            if os.name == 'nt' and '\\' in user:
-                user = user.split('\\')[1]
-            vms = pinfo['memory_info'] and \
-                int(pinfo['memory_info'].vms / 1024) or '?'
-            rss = pinfo['memory_info'] and \
-                int(pinfo['memory_info'].rss / 1024) or '?'
-            memp = pinfo['memory_percent'] and \
-                round(pinfo['memory_percent'], 1) or '?'
-            status = PROC_STATUSES_RAW.get(pinfo['status'], pinfo['status'])
-            print(templ % (
-                user[:10],
-                pinfo['pid'],
-                pinfo['cpu_percent'],
-                memp,
-                vms,
-                rss,
-                pinfo.get('terminal', '') or '?',
-                status,
-                ctime,
-                cputime,
-                pinfo['name'].strip() or '?'))
+                pass
+        if user and psutil.WINDOWS and '\\' in user:
+            user = user.split('\\')[1]
+        if not user:
+            user = ''
+        user = user[:9]
+        vms = (
+            bytes2human(p.memory_info().vms)
+            if p.memory_info() is not None
+            else ''
+        )
+        rss = (
+            bytes2human(p.memory_info().rss)
+            if p.memory_info() is not None
+            else ''
+        )
+        memp = (
+            round(p.memory_percent(), 1)
+            if p.memory_percent() is not None
+            else ''
+        )
+        nice = int(p.nice()) if p.nice() else ''
+        if p.cmdline():  # noqa: SIM108
+            cmdline = ' '.join(p.cmdline())
+        else:
+            cmdline = p.name()
+        status = p.status()[:5] if p.status() else ''
+
+        line = templ.format(
+            user,
+            p.pid,
+            memp,
+            vms,
+            rss,
+            nice,
+            status,
+            ctime,
+            cputime,
+            cmdline,
+        )
+        print(line[: shutil.get_terminal_size()[0]])
 
 
 if __name__ == '__main__':
diff --git a/scripts/pstree.py b/scripts/pstree.py
index 8e4c9f9572..694c815e72 100755
--- a/scripts/pstree.py
+++ b/scripts/pstree.py
@@ -1,14 +1,13 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-Similar to 'ps aux --forest' on Linux, prints the process list
+"""Similar to 'ps aux --forest' on Linux, prints the process list
 as a tree structure.
 
-$ python scripts/pstree.py
+$ python3 scripts/pstree.py
 0 ?
 |- 1 init
 | |- 289 cgmanager
@@ -28,7 +27,6 @@
 ...
 """
 
-from __future__ import print_function
 import collections
 import sys
 
diff --git a/scripts/sensors.py b/scripts/sensors.py
new file mode 100755
index 0000000000..726b53d52c
--- /dev/null
+++ b/scripts/sensors.py
@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""A clone of 'sensors' utility on Linux printing hardware temperatures,
+fans speed and battery info.
+
+$ python3 scripts/sensors.py
+asus
+    Temperatures:
+        asus                 57.0°C (high=None°C, critical=None°C)
+    Fans:
+        cpu_fan              3500 RPM
+acpitz
+    Temperatures:
+        acpitz               57.0°C (high=108.0°C, critical=108.0°C)
+coretemp
+    Temperatures:
+        Physical id 0        61.0°C (high=87.0°C, critical=105.0°C)
+        Core 0               61.0°C (high=87.0°C, critical=105.0°C)
+        Core 1               59.0°C (high=87.0°C, critical=105.0°C)
+Battery:
+    charge:     84.95%
+    status:     charging
+    plugged in: yes
+"""
+
+import psutil
+
+
+def secs2hours(secs):
+    mm, ss = divmod(secs, 60)
+    hh, mm = divmod(mm, 60)
+    return f"{int(hh)}:{int(mm):02}:{int(ss):02}"
+
+
+def main():
+    if hasattr(psutil, "sensors_temperatures"):
+        temps = psutil.sensors_temperatures()
+    else:
+        temps = {}
+    fans = psutil.sensors_fans() if hasattr(psutil, "sensors_fans") else {}
+    if hasattr(psutil, "sensors_battery"):
+        battery = psutil.sensors_battery()
+    else:
+        battery = None
+
+    if not any((temps, fans, battery)):
+        print("can't read any temperature, fans or battery info")
+        return
+
+    names = set(list(temps.keys()) + list(fans.keys()))
+    for name in names:
+        print(name)
+        # Temperatures.
+        if name in temps:
+            print("    Temperatures:")
+            for entry in temps[name]:
+                s = "        {:<20} {}°C (high={}°C, critical={}°C)".format(
+                    entry.label or name,
+                    entry.current,
+                    entry.high,
+                    entry.critical,
+                )
+                print(s)
+        # Fans.
+        if name in fans:
+            print("    Fans:")
+            for entry in fans[name]:
+                print(
+                    "        {:<20} {} RPM".format(
+                        entry.label or name, entry.current
+                    )
+                )
+
+    # Battery.
+    if battery:
+        print("Battery:")
+        print(f"    charge:     {round(battery.percent, 2)}%")
+        if battery.power_plugged:
+            print(
+                "    status:     {}".format(
+                    "charging" if battery.percent < 100 else "fully charged"
+                )
+            )
+            print("    plugged in: yes")
+        else:
+            print(f"    left:       {secs2hours(battery.secsleft)}")
+            print("    status:     discharging")
+            print("    plugged in: no")
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/temperatures.py b/scripts/temperatures.py
new file mode 100755
index 0000000000..f3486b8817
--- /dev/null
+++ b/scripts/temperatures.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""A clone of 'sensors' utility on Linux printing hardware temperatures.
+
+$ python3 scripts/sensors.py
+asus
+    asus                 47.0 °C (high = None °C, critical = None °C)
+
+acpitz
+    acpitz               47.0 °C (high = 103.0 °C, critical = 103.0 °C)
+
+coretemp
+    Physical id 0        54.0 °C (high = 100.0 °C, critical = 100.0 °C)
+    Core 0               47.0 °C (high = 100.0 °C, critical = 100.0 °C)
+    Core 1               48.0 °C (high = 100.0 °C, critical = 100.0 °C)
+    Core 2               47.0 °C (high = 100.0 °C, critical = 100.0 °C)
+    Core 3               54.0 °C (high = 100.0 °C, critical = 100.0 °C)
+"""
+
+import sys
+
+import psutil
+
+
+def main():
+    if not hasattr(psutil, "sensors_temperatures"):
+        sys.exit("platform not supported")
+    temps = psutil.sensors_temperatures()
+    if not temps:
+        sys.exit("can't read any temperature")
+    for name, entries in temps.items():
+        print(name)
+        for entry in entries:
+            line = "    {:<20} {} °C (high = {} °C, critical = %{} °C)".format(
+                entry.label or name,
+                entry.current,
+                entry.high,
+                entry.critical,
+            )
+            print(line)
+        print()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/scripts/top.py b/scripts/top.py
index 1caa8136d8..031b1faaad 100755
--- a/scripts/top.py
+++ b/scripts/top.py
@@ -1,99 +1,76 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-A clone of top / htop.
+"""A clone of top / htop.
 
 Author: Giampaolo Rodola' <g.rodola@gmail.com>
 
-$ python scripts/top.py
- CPU0  [|                                       ]   4.9%
- CPU1  [|||                                     ]   7.8%
- CPU2  [                                        ]   2.0%
- CPU3  [|||||                                   ]  13.9%
- Mem   [|||||||||||||||||||                     ]  49.8%  4920M/9888M
- Swap  [                                        ]   0.0%     0M/0M
- Processes: 287 (running=1, sleeping=286, zombie=1)
- Load average: 0.34 0.54 0.46  Uptime: 3 days, 10:16:37
-
-PID    USER       NI  VIRT   RES   CPU% MEM%     TIME+  NAME
-------------------------------------------------------------
-989    giampaol    0   66M   12M    7.4  0.1   0:00.61  python
-2083   root        0  506M  159M    6.5  1.6   0:29.26  Xorg
-4503   giampaol    0  599M   25M    6.5  0.3   3:32.60  gnome-terminal
-3868   giampaol    0  358M    8M    2.8  0.1  23:12.60  pulseaudio
-3936   giampaol    0    1G  111M    2.8  1.1  33:41.67  compiz
-4401   giampaol    0  536M  141M    2.8  1.4  35:42.73  skype
-4047   giampaol    0  743M   76M    1.8  0.8  42:03.33  unity-panel-service
-13155  giampaol    0    1G  280M    1.8  2.8  41:57.34  chrome
-10     root        0    0B    0B    0.9  0.0   4:01.81  rcu_sched
-339    giampaol    0    1G  113M    0.9  1.1   8:15.73  chrome
+$ python3 scripts/top.py
+ CPU0  [||||                                    ]  10.9%
+ CPU1  [|||||                                   ]  13.1%
+ CPU2  [|||||                                   ]  12.8%
+ CPU3  [||||                                    ]  11.5%
+ Mem   [|||||||||||||||||||||||||||||           ]  73.0% 11017M / 15936M
+ Swap  [                                        ]   1.3%   276M / 20467M
+ Processes: 347 (sleeping=273, running=1, idle=73)
+ Load average: 1.10 1.28 1.34  Uptime: 8 days, 21:15:40
+
+PID    USER       NI   VIRT    RES  CPU%  MEM%     TIME+  NAME
+5368   giampaol    0   7.2G   4.3G  41.8  27.7  56:34.18  VirtualBox
+24976  giampaol    0   2.1G 487.2M  18.7   3.1  22:05.16  Web Content
+22731  giampaol    0   3.2G 596.2M  11.6   3.7  35:04.90  firefox
+1202   root        0 807.4M 288.5M  10.6   1.8  12:22.12  Xorg
+22811  giampaol    0   2.8G 741.8M   9.0   4.7   2:26.61  Web Content
+2590   giampaol    0   2.3G 579.4M   5.5   3.6  28:02.70  compiz
+22990  giampaol    0   3.0G   1.2G   4.2   7.6   4:30.32  Web Content
+18412  giampaol    0  90.1M  14.5M   3.5   0.1   0:00.26  python3
+26971  netdata     0  20.8M   3.9M   2.9   0.0   3:17.14  apps.plugin
+2421   giampaol    0   3.3G  36.9M   2.3   0.2  57:14.21  pulseaudio
 ...
 """
 
-import atexit
 import datetime
-import os
 import sys
 import time
+
 try:
     import curses
 except ImportError:
     sys.exit('platform not supported')
 
 import psutil
-
-
-# --- curses stuff
-def tear_down():
-    win.keypad(0)
-    curses.nocbreak()
-    curses.echo()
-    curses.endwin()
+from psutil import bytes2human
 
 win = curses.initscr()
-atexit.register(tear_down)
-curses.endwin()
 lineno = 0
+colors_map = dict(green=3, red=10, yellow=4)
 
 
-def print_line(line, highlight=False):
+def printl(line, color=None, bold=False, highlight=False):
     """A thin wrapper around curses's addstr()."""
     global lineno
     try:
+        flags = 0
+        if color:
+            flags |= curses.color_pair(colors_map[color])
+        if bold:
+            flags |= curses.A_BOLD
         if highlight:
             line += " " * (win.getmaxyx()[1] - len(line))
-            win.addstr(lineno, 0, line, curses.A_REVERSE)
-        else:
-            win.addstr(lineno, 0, line, 0)
+            flags |= curses.A_STANDOUT
+        win.addstr(lineno, 0, line, flags)
     except curses.error:
         lineno = 0
         win.refresh()
         raise
     else:
         lineno += 1
-# --- /curses stuff
 
 
-def bytes2human(n):
-    """
-    >>> bytes2human(10000)
-    '9K'
-    >>> bytes2human(100001221)
-    '95M'
-    """
-    symbols = ('K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y')
-    prefix = {}
-    for i, s in enumerate(symbols):
-        prefix[s] = 1 << (i + 1) * 10
-    for s in reversed(symbols):
-        if n >= prefix[s]:
-            value = int(float(n) / prefix[s])
-            return '%s%s' % (value, s)
-    return "%sB" % n
+# --- /curses stuff
 
 
 def poll(interval):
@@ -103,9 +80,16 @@ def poll(interval):
     procs_status = {}
     for p in psutil.process_iter():
         try:
-            p.dict = p.as_dict(['username', 'nice', 'memory_info',
-                                'memory_percent', 'cpu_percent',
-                                'cpu_times', 'name', 'status'])
+            p.dict = p.as_dict([
+                'username',
+                'nice',
+                'memory_info',
+                'memory_percent',
+                'cpu_percent',
+                'cpu_times',
+                'name',
+                'status',
+            ])
             try:
                 procs_status[p.dict['status']] += 1
             except KeyError:
@@ -116,16 +100,26 @@ def poll(interval):
             procs.append(p)
 
     # return processes sorted by CPU percent usage
-    processes = sorted(procs, key=lambda p: p.dict['cpu_percent'],
-                       reverse=True)
+    processes = sorted(
+        procs, key=lambda p: p.dict['cpu_percent'], reverse=True
+    )
     return (processes, procs_status)
 
 
+def get_color(perc):
+    if perc <= 30:
+        return "green"
+    elif perc <= 80:
+        return "yellow"
+    else:
+        return "red"
+
+
 def print_header(procs_status, num_procs):
     """Print system-related info, above the process list."""
 
     def get_dashes(perc):
-        dashes = "|" * int((float(perc) / 10 * 4))
+        dashes = "|" * int(float(perc) / 10 * 4)
         empty_dashes = " " * (40 - len(dashes))
         return dashes, empty_dashes
 
@@ -133,64 +127,85 @@ def get_dashes(perc):
     percs = psutil.cpu_percent(interval=0, percpu=True)
     for cpu_num, perc in enumerate(percs):
         dashes, empty_dashes = get_dashes(perc)
-        print_line(" CPU%-2s [%s%s] %5s%%" % (cpu_num, dashes, empty_dashes,
-                                              perc))
+        line = " CPU{:<2} [{}{}] {:>5}%".format(
+            cpu_num, dashes, empty_dashes, perc
+        )
+        printl(line, color=get_color(perc))
+
+    # memory usage
     mem = psutil.virtual_memory()
     dashes, empty_dashes = get_dashes(mem.percent)
-    used = mem.total - mem.available
-    line = " Mem   [%s%s] %5s%% %6s/%s" % (
-        dashes, empty_dashes,
+    line = " Mem   [{}{}] {:>5}% {:>6} / {}".format(
+        dashes,
+        empty_dashes,
         mem.percent,
-        str(int(used / 1024 / 1024)) + "M",
-        str(int(mem.total / 1024 / 1024)) + "M"
+        bytes2human(mem.used),
+        bytes2human(mem.total),
     )
-    print_line(line)
+    printl(line, color=get_color(mem.percent))
 
     # swap usage
     swap = psutil.swap_memory()
     dashes, empty_dashes = get_dashes(swap.percent)
-    line = " Swap  [%s%s] %5s%% %6s/%s" % (
-        dashes, empty_dashes,
+    line = " Swap  [{}{}] {:>5}% {:>6} / {}".format(
+        dashes,
+        empty_dashes,
         swap.percent,
-        str(int(swap.used / 1024 / 1024)) + "M",
-        str(int(swap.total / 1024 / 1024)) + "M"
+        bytes2human(swap.used),
+        bytes2human(swap.total),
     )
-    print_line(line)
+    printl(line, color=get_color(swap.percent))
 
     # processes number and status
     st = []
     for x, y in procs_status.items():
         if y:
-            st.append("%s=%s" % (x, y))
-    st.sort(key=lambda x: x[:3] in ('run', 'sle'), reverse=1)
-    print_line(" Processes: %s (%s)" % (num_procs, ', '.join(st)))
+            st.append(f"{x}={y}")
+    st.sort(key=lambda x: x[:3] in {'run', 'sle'}, reverse=1)
+    printl(f" Processes: {num_procs} ({', '.join(st)})")
     # load average, uptime
-    uptime = datetime.datetime.now() - \
-        datetime.datetime.fromtimestamp(psutil.boot_time())
-    av1, av2, av3 = os.getloadavg()
-    line = " Load average: %.2f %.2f %.2f  Uptime: %s" \
-        % (av1, av2, av3, str(uptime).split('.')[0])
-    print_line(line)
+    uptime = datetime.datetime.now() - datetime.datetime.fromtimestamp(
+        psutil.boot_time()
+    )
+    av1, av2, av3 = psutil.getloadavg()
+    line = " Load average: {:.2f} {:.2f} {:.2f}  Uptime: {}".format(
+        av1,
+        av2,
+        av3,
+        str(uptime).split('.')[0],
+    )
+    printl(line)
 
 
 def refresh_window(procs, procs_status):
     """Print results on screen by using curses."""
     curses.endwin()
-    templ = "%-6s %-8s %4s %5s %5s %6s %4s %9s  %2s"
+    templ = "{:<6} {:<8} {:>4} {:>6} {:>6} {:>5} {:>5} {:>9}  {:>2}"
     win.erase()
-    header = templ % ("PID", "USER", "NI", "VIRT", "RES", "CPU%", "MEM%",
-                      "TIME+", "NAME")
+    header = templ.format(
+        "PID",
+        "USER",
+        "NI",
+        "VIRT",
+        "RES",
+        "CPU%",
+        "MEM%",
+        "TIME+",
+        "NAME",
+    )
     print_header(procs_status, len(procs))
-    print_line("")
-    print_line(header, highlight=True)
+    printl("")
+    printl(header, bold=True, highlight=True)
     for p in procs:
         # TIME+ column shows process CPU cumulative time and it
         # is expressed as: "mm:ss.ms"
         if p.dict['cpu_times'] is not None:
             ctime = datetime.timedelta(seconds=sum(p.dict['cpu_times']))
-            ctime = "%s:%s.%s" % (ctime.seconds // 60 % 60,
-                                  str((ctime.seconds % 60)).zfill(2),
-                                  str(ctime.microseconds)[:2])
+            ctime = "{}:{}.{}".format(
+                ctime.seconds // 60 % 60,
+                str(ctime.seconds % 60).zfill(2),
+                str(ctime.microseconds)[:2],
+            )
         else:
             ctime = ''
         if p.dict['memory_percent'] is not None:
@@ -199,36 +214,56 @@ def refresh_window(procs, procs_status):
             p.dict['memory_percent'] = ''
         if p.dict['cpu_percent'] is None:
             p.dict['cpu_percent'] = ''
-        if p.dict['username']:
-            username = p.dict['username'][:8]
-        else:
-            username = ""
-        line = templ % (p.pid,
-                        username,
-                        p.dict['nice'],
-                        bytes2human(getattr(p.dict['memory_info'], 'vms', 0)),
-                        bytes2human(getattr(p.dict['memory_info'], 'rss', 0)),
-                        p.dict['cpu_percent'],
-                        p.dict['memory_percent'],
-                        ctime,
-                        p.dict['name'] or '',
-                        )
+        username = p.dict['username'][:8] if p.dict['username'] else ''
+        line = templ.format(
+            p.pid,
+            username,
+            p.dict['nice'],
+            bytes2human(getattr(p.dict['memory_info'], 'vms', 0)),
+            bytes2human(getattr(p.dict['memory_info'], 'rss', 0)),
+            p.dict['cpu_percent'],
+            p.dict['memory_percent'],
+            ctime,
+            p.dict['name'] or '',
+        )
         try:
-            print_line(line)
+            printl(line)
         except curses.error:
             break
         win.refresh()
 
 
+def setup():
+    curses.start_color()
+    curses.use_default_colors()
+    for i in range(curses.COLORS):
+        curses.init_pair(i + 1, i, -1)
+    curses.endwin()
+    win.nodelay(1)
+
+
+def tear_down():
+    win.keypad(0)
+    curses.nocbreak()
+    curses.echo()
+    curses.endwin()
+
+
 def main():
+    setup()
     try:
         interval = 0
         while True:
+            if win.getch() == ord('q'):
+                break
             args = poll(interval)
             refresh_window(*args)
             interval = 1
     except (KeyboardInterrupt, SystemExit):
         pass
+    finally:
+        tear_down()
+
 
 if __name__ == '__main__':
     main()
diff --git a/scripts/who.py b/scripts/who.py
index f64c00931a..d459547234 100755
--- a/scripts/who.py
+++ b/scripts/who.py
@@ -1,18 +1,15 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-A clone of 'who' command; print information about users who are
+"""A clone of 'who' command; print information about users who are
 currently logged in.
 
-$ python scripts/who.py
-giampaolo       tty7            2014-02-23 17:25  (:0)
-giampaolo       pts/7           2014-02-24 18:25  (:192.168.1.56)
-giampaolo       pts/8           2014-02-24 18:25  (:0)
-giampaolo       pts/9           2014-02-27 01:32  (:0)
+$ python3 scripts/who.py
+giampaolo    console    2017-03-25 22:24                loginwindow
+giampaolo    ttys000    2017-03-25 23:28 (10.0.2.2)     sshd
 """
 
 from datetime import datetime
@@ -23,11 +20,16 @@
 def main():
     users = psutil.users()
     for user in users:
-        print("%-15s %-15s %s  (%s)" % (
+        proc_name = psutil.Process(user.pid).name() if user.pid else ""
+        line = "{:<12} {:<10} {:<10} {:<14} {}".format(
             user.name,
             user.terminal or '-',
             datetime.fromtimestamp(user.started).strftime("%Y-%m-%d %H:%M"),
-            user.host))
+            f"({user.host or ''})",
+            proc_name,
+        )
+        print(line)
+
 
 if __name__ == '__main__':
     main()
diff --git a/scripts/winservices.py b/scripts/winservices.py
index fed6a734ef..bb58287506 100755
--- a/scripts/winservices.py
+++ b/scripts/winservices.py
@@ -1,13 +1,12 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""
-List all Windows services installed.
+r"""List all Windows services installed.
 
-$ python scripts/winservices.py
+$ python3 scripts/winservices.py
 AeLookupSvc (Application Experience)
 status: stopped, start: manual, username: localSystem, pid: None
 binpath: C:\Windows\system32\svchost.exe -k netsvcs
@@ -27,29 +26,36 @@
 Appinfo (Application Information)
 status: stopped, start: manual, username: LocalSystem, pid: None
 binpath: C:\Windows\system32\svchost.exe -k netsvcs
-
 ...
 """
 
-
 import os
 import sys
 
 import psutil
 
-
 if os.name != 'nt':
     sys.exit("platform not supported (Windows only)")
 
 
 def main():
     for service in psutil.win_service_iter():
+        if service.name() == "WaaSMedicSvc":
+            # known issue in Windows 11 reading the description
+            # https://learn.microsoft.com/en-us/answers/questions/1320388/in-windows-11-version-22h2-there-it-shows-(failed
+            # https://github.com/giampaolo/psutil/issues/2383
+            continue
         info = service.as_dict()
-        print("%s (%s)" % (info['name'], info['display_name']))
-        print("status: %s, start: %s, username: %s, pid: %s" % (
-            info['status'], info['start_type'], info['username'], info['pid']))
-        print("binpath: %s" % info['binpath'])
-        print("")
+        print(f"{info['name']!r} ({info['display_name']!r})")
+        s = "status: {}, start: {}, username: {}, pid: {}".format(
+            info['status'],
+            info['start_type'],
+            info['username'],
+            info['pid'],
+        )
+        print(s)
+        print(f"binpath: {info['binpath']}")
+        print()
 
 
 if __name__ == '__main__':
diff --git a/setup.py b/setup.py
old mode 100644
new mode 100755
index a61b5ed2a0..c5426acb1d
--- a/setup.py
+++ b/setup.py
@@ -1,285 +1,488 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright (c) 2009 Giampaolo Rodola'. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-"""psutil is a cross-platform library for retrieving information on
-running processes and system utilization (CPU, memory, disks, network)
-in Python.
-"""
+"""Cross-platform lib for process and system monitoring in Python."""
 
-import atexit
-import contextlib
-import io
+import concurrent.futures
+import glob
 import os
+import pathlib
+import shlex
+import shutil
+import struct
+import subprocess
 import sys
+import sysconfig
 import tempfile
-import platform
-try:
-    from setuptools import setup, Extension
-except ImportError:
-    from distutils.core import setup, Extension
-
-HERE = os.path.abspath(os.path.dirname(__file__))
-sys.path.insert(0, os.path.join(HERE, "psutil"))
-import _common  # NOQA
-
-
-def get_version():
-    INIT = os.path.join(HERE, 'psutil/__init__.py')
-    with open(INIT, 'r') as f:
-        for line in f:
-            if line.startswith('__version__'):
-                ret = eval(line.strip().split(' = ')[1])
-                assert ret.count('.') == 2, ret
-                for num in ret.split('.'):
-                    assert num.isdigit(), ret
-                return ret
-        else:
-            raise ValueError("couldn't find version string")
 
+from setuptools import Extension
+from setuptools import setup
+from setuptools.command.build_ext import build_ext
 
-def get_description():
-    README = os.path.join(HERE, 'README.rst')
-    with open(README, 'r') as f:
-        return f.read()
+ROOT_DIR = pathlib.Path(__file__).resolve().parent
+sys.path.insert(0, str(ROOT_DIR))
 
+from _bootstrap import get_version  # noqa: E402
+from _bootstrap import load_module  # noqa: E402
 
-@contextlib.contextmanager
-def silenced_output(stream_name):
-    class DummyFile(io.BytesIO):
-        # see: https://github.com/giampaolo/psutil/issues/678
-        errors = "ignore"
+_common = load_module(ROOT_DIR / "psutil" / "_common.py")
 
-        def write(self, s):
-            pass
+AIX = _common.AIX
+BSD = _common.BSD
+FREEBSD = _common.FREEBSD
+LINUX = _common.LINUX
+MACOS = _common.MACOS
+NETBSD = _common.NETBSD
+OPENBSD = _common.OPENBSD
+POSIX = _common.POSIX
+SUNOS = _common.SUNOS
+WINDOWS = _common.WINDOWS
 
-    orig = getattr(sys, stream_name)
-    try:
-        setattr(sys, stream_name, DummyFile())
-        yield
-    finally:
-        setattr(sys, stream_name, orig)
+hilite = _common.hilite
+
+PYPY = '__pypy__' in sys.builtin_module_names
+CPYTHON = sys.implementation.name == "cpython"
+Py_GIL_DISABLED = sysconfig.get_config_var("Py_GIL_DISABLED")
+
+
+# The pre-processor macros that are passed to the C compiler when
+# building the extension.
+macros = []
+
+if POSIX:
+    macros.append(("PSUTIL_POSIX", 1))
+if BSD:
+    macros.append(("PSUTIL_BSD", 1))
+
+# Needed to determine _Py_PARSE_PID in case it's missing (PyPy).
+# Taken from Lib/test/test_fcntl.py.
+# XXX: not bullet proof as the (long long) case is missing.
+if struct.calcsize('l') <= 8:
+    macros.append(('PSUTIL_SIZEOF_PID_T', '4'))  # int
+else:
+    macros.append(('PSUTIL_SIZEOF_PID_T', '8'))  # long
+
+
+sources = glob.glob("psutil/arch/all/*.c")
+if POSIX:
+    sources.extend(glob.glob("psutil/arch/posix/*.c"))
 
 
 VERSION = get_version()
-VERSION_MACRO = ('PSUTIL_VERSION', int(VERSION.replace('.', '')))
-
-
-# POSIX
-if _common.POSIX:
-    posix_extension = Extension(
-        'psutil._psutil_posix',
-        sources=['psutil/_psutil_posix.c'])
-    if sys.platform.startswith("sunos") or sys.platform.startswith("solaris"):
-        posix_extension.libraries.append('socket')
-        if platform.release() == '5.10':
-            posix_extension.sources.append('psutil/arch/solaris/v10/ifaddrs.c')
-            posix_extension.define_macros.append(('PSUTIL_SUNOS10', 1))
-# Windows
-if _common.WINDOWS:
+macros.append(('PSUTIL_VERSION', int(VERSION.replace('.', ''))))
+
+# The oldest interpreter we support, and the one the wheel claims to
+# run on. Py_LIMITED_API lets us create a single wheel which works with
+# multiple python versions, including unreleased ones.
+MIN_PY_VERSION = (3, 8)
+
+abi3_platform = MACOS or LINUX or WINDOWS  # the ones we ship wheels for
+if CPYTHON and abi3_platform and not Py_GIL_DISABLED:
+    _abi3_tag = "cp{}{}".format(*MIN_PY_VERSION)
+    _hexversion = "0x{:02x}{:02x}0000".format(*MIN_PY_VERSION)
+    py_limited_api = {"py_limited_api": True}
+    options = {"bdist_wheel": {"py_limited_api": _abi3_tag}}
+    macros.append(('Py_LIMITED_API', _hexversion))
+else:
+    py_limited_api = {}
+    options = {}
+
+
+def get_long_description():
+    script = ROOT_DIR / "scripts" / "internal" / "convert_readme.py"
+    readme = ROOT_DIR / 'README.rst'
+    p = subprocess.Popen(
+        [sys.executable, script, readme],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        universal_newlines=True,
+    )
+    stdout, stderr = p.communicate()
+    if p.returncode != 0:
+        raise RuntimeError(stderr)
+    return stdout
+
+
+def num_cpus():
+    value = os.getenv("PSUTIL_BUILD_JOBS")
+    if value is not None:
+        return max(1, int(value))
+    fun = getattr(os, "process_cpu_count", os.cpu_count)
+    return fun() or 1
+
+
+def has_python_h():
+    """Whether a C file including Python.h really compiles."""
+    paths = sysconfig.get_paths()
+    incdirs = [paths["include"]]
+    if paths.get("platinclude") and paths["platinclude"] not in incdirs:
+        incdirs.append(paths["platinclude"])
+    args = []
+    for d in incdirs:
+        args.extend(["-I", d])
+    return unix_can_compile("#include <Python.h>", args)
+
+
+def get_cc():
+    """The compiler (plus flags) python uses to build C extensions."""
+    cc = os.getenv('CC') or sysconfig.get_config_var("CC") or "cc"
+    return shlex.split(cc)
+
+
+def has_compiler():
+    return unix_can_compile("int main(void) { return 0; }")
+
+
+def unix_can_compile(c_code, extra_args=()):
+    # https://github.com/giampaolo/psutil/pull/1568
+    with tempfile.TemporaryDirectory() as tempdir:
+        src = os.path.join(tempdir, "test.c")
+        with open(src, "w") as f:
+            f.write(c_code)
+        cmd = (
+            get_cc()
+            + list(extra_args)
+            + [
+                "-c",
+                src,
+                "-o",
+                os.path.join(tempdir, "test.o"),
+            ]
+        )
+        try:
+            ret = subprocess.call(
+                cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
+            )
+        except OSError:
+            return False  # compiler is not installed
+        return ret == 0
+
+
+if WINDOWS:
+
     def get_winver():
         maj, min = sys.getwindowsversion()[0:2]
-        return '0x0%s' % ((maj * 100) + min)
+        return "0x0{}".format((maj * 100) + min)
+
+    if sys.getwindowsversion()[0] < 10:
+        msg = "this Windows version is too old (< Windows 10); "
+        msg += "psutil 7.2.x is the latest version which supports Windows "
+        msg += "Vista, 7, 8, 8.1 and their server counterparts"
+        raise RuntimeError(msg)
+
+    macros.append(("PSUTIL_WINDOWS", 1))
+    macros.extend([
+        # be nice to mingw, see:
+        # http://www.mingw.org/wiki/Use_more_recent_defined_functions
+        ('_WIN32_WINNT', get_winver()),
+        ('_AVAIL_WINVER_', get_winver()),
+        ('_CRT_SECURE_NO_WARNINGS', None),
+    ])
+
+    if Py_GIL_DISABLED:
+        macros.append(('Py_GIL_DISABLED', 1))
 
     ext = Extension(
-        'psutil._psutil_windows',
-        sources=[
-            'psutil/_psutil_windows.c',
-            'psutil/_psutil_common.c',
-            'psutil/arch/windows/process_info.c',
-            'psutil/arch/windows/process_handles.c',
-            'psutil/arch/windows/security.c',
-            'psutil/arch/windows/inet_ntop.c',
-            'psutil/arch/windows/services.c',
-        ],
-        define_macros=[
-            VERSION_MACRO,
-            # be nice to mingw, see:
-            # http://www.mingw.org/wiki/Use_more_recent_defined_functions
-            ('_WIN32_WINNT', get_winver()),
-            ('_AVAIL_WINVER_', get_winver()),
-            ('_CRT_SECURE_NO_WARNINGS', None),
-            # see: https://github.com/giampaolo/psutil/issues/348
-            ('PSAPI_VERSION', 1),
-        ],
+        'psutil._psutil',
+        sources=(
+            sources
+            + ["psutil/_psutil_windows.c"]
+            + glob.glob("psutil/arch/windows/*.c")
+        ),
+        define_macros=macros,
         libraries=[
-            "psapi", "kernel32", "advapi32", "shell32", "netapi32",
-            "iphlpapi", "wtsapi32", "ws2_32",
+            "advapi32",
+            "iphlpapi",
+            "kernel32",
+            "netapi32",
+            "ntdll",
+            "pdh",
+            "PowrProf",
+            "shell32",
+            "ws2_32",
         ],
-        # extra_compile_args=["/Z7"],
-        # extra_link_args=["/DEBUG"]
+        # extra_compile_args=["/W 4"],
+        # extra_link_args=["/DEBUG"],
+        **py_limited_api,
     )
-    extensions = [ext]
-# OS X
-elif _common.OSX:
+
+elif MACOS:
+    macros.extend([("PSUTIL_OSX", 1), ("PSUTIL_MACOS", 1)])
     ext = Extension(
-        'psutil._psutil_osx',
-        sources=[
-            'psutil/_psutil_osx.c',
-            'psutil/_psutil_common.c',
-            'psutil/arch/osx/process_info.c',
-        ],
-        define_macros=[VERSION_MACRO],
+        'psutil._psutil',
+        sources=(
+            sources
+            + ["psutil/_psutil_osx.c"]
+            + glob.glob("psutil/arch/osx/*.c")
+        ),
+        define_macros=macros,
         extra_link_args=[
-            '-framework', 'CoreFoundation', '-framework', 'IOKit'
-        ])
-    extensions = [ext, posix_extension]
-# FreeBSD
-elif _common.FREEBSD:
-    ext = Extension(
-        'psutil._psutil_bsd',
-        sources=[
-            'psutil/_psutil_bsd.c',
-            'psutil/_psutil_common.c',
-            'psutil/arch/bsd/freebsd.c',
-            'psutil/arch/bsd/freebsd_socks.c',
+            '-framework',
+            'CoreFoundation',
+            '-framework',
+            'IOKit',
         ],
-        define_macros=[VERSION_MACRO],
-        libraries=["devstat"])
-    extensions = [ext, posix_extension]
-# OpenBSD
-elif _common.OPENBSD:
+        **py_limited_api,
+    )
+
+elif FREEBSD:
+    macros.append(("PSUTIL_FREEBSD", 1))
+
     ext = Extension(
-        'psutil._psutil_bsd',
-        sources=[
-            'psutil/_psutil_bsd.c',
-            'psutil/_psutil_common.c',
-            'psutil/arch/bsd/openbsd.c',
-        ],
-        define_macros=[VERSION_MACRO],
-        libraries=["kvm"])
-    extensions = [ext, posix_extension]
-# NetBSD
-elif _common.NETBSD:
+        'psutil._psutil',
+        sources=(
+            sources
+            + ["psutil/_psutil_bsd.c"]
+            + glob.glob("psutil/arch/bsd/*.c")
+            + glob.glob("psutil/arch/freebsd/*.c")
+        ),
+        define_macros=macros,
+        libraries=["devstat"],
+        **py_limited_api,
+    )
+
+elif OPENBSD:
+    macros.append(("PSUTIL_OPENBSD", 1))
+
     ext = Extension(
-        'psutil._psutil_bsd',
-        sources=[
-            'psutil/_psutil_bsd.c',
-            'psutil/_psutil_common.c',
-            'psutil/arch/bsd/netbsd.c',
-            'psutil/arch/bsd/netbsd_socks.c',
-        ],
-        define_macros=[VERSION_MACRO],
-        libraries=["kvm"])
-    extensions = [ext, posix_extension]
-# Linux
-elif _common.LINUX:
-    def get_ethtool_macro():
-        # see: https://github.com/giampaolo/psutil/issues/659
-        from distutils.unixccompiler import UnixCCompiler
-        from distutils.errors import CompileError
-
-        with tempfile.NamedTemporaryFile(
-                suffix='.c', delete=False, mode="wt") as f:
-            f.write("#include <linux/ethtool.h>")
-
-        @atexit.register
-        def on_exit():
-            try:
-                os.remove(f.name)
-            except OSError:
-                pass
-
-        compiler = UnixCCompiler()
-        try:
-            with silenced_output('stderr'):
-                with silenced_output('stdout'):
-                    compiler.compile([f.name])
-        except CompileError:
-            return ("PSUTIL_ETHTOOL_MISSING_TYPES", 1)
-        else:
-            return None
+        'psutil._psutil',
+        sources=(
+            sources
+            + ["psutil/_psutil_bsd.c"]
+            + glob.glob("psutil/arch/bsd/*.c")
+            + glob.glob("psutil/arch/openbsd/*.c")
+        ),
+        define_macros=macros,
+        libraries=["kvm"],
+        **py_limited_api,
+    )
+
+elif NETBSD:
+    macros.append(("PSUTIL_NETBSD", 1))
+
+    ext = Extension(
+        'psutil._psutil',
+        sources=(
+            sources
+            + ["psutil/_psutil_bsd.c"]
+            + glob.glob("psutil/arch/bsd/*.c")
+            + glob.glob("psutil/arch/netbsd/*.c")
+        ),
+        define_macros=macros,
+        libraries=["kvm", "jemalloc"],
+        **py_limited_api,
+    )
+
+elif LINUX:
+    # see: https://github.com/giampaolo/psutil/issues/659
+    if not unix_can_compile("#include <linux/ethtool.h>"):
+        macros.append(("PSUTIL_ETHTOOL_MISSING_TYPES", 1))
 
-    ETHTOOL_MACRO = get_ethtool_macro()
-    macros = [VERSION_MACRO]
-    if ETHTOOL_MACRO is not None:
-        macros.append(ETHTOOL_MACRO)
+    macros.append(("PSUTIL_LINUX", 1))
     ext = Extension(
-        'psutil._psutil_linux',
-        sources=['psutil/_psutil_linux.c'],
-        define_macros=macros)
-    extensions = [ext, posix_extension]
-# Solaris
-elif _common.SUNOS:
+        'psutil._psutil',
+        sources=(
+            sources
+            + ["psutil/_psutil_linux.c"]
+            + glob.glob("psutil/arch/linux/*.c")
+        ),
+        define_macros=macros,
+        **py_limited_api,
+    )
+
+elif SUNOS:
+    macros.append(("PSUTIL_SUNOS", 1))
+
     ext = Extension(
-        'psutil._psutil_sunos',
-        sources=['psutil/_psutil_sunos.c'],
-        define_macros=[VERSION_MACRO],
-        libraries=['kstat', 'nsl', 'socket'])
-    extensions = [ext, posix_extension]
+        'psutil._psutil',
+        sources=(
+            sources
+            + ["psutil/_psutil_sunos.c"]
+            + glob.glob("psutil/arch/sunos/*.c")
+        ),
+        define_macros=macros,
+        libraries=["kstat", "nsl", "socket"],
+        **py_limited_api,
+    )
+
+elif AIX:
+    macros.append(("PSUTIL_AIX", 1))
+
+    ext = Extension(
+        'psutil._psutil',
+        sources=(
+            sources
+            + ["psutil/_psutil_aix.c"]
+            + glob.glob("psutil/arch/aix/*.c")
+        ),
+        libraries=["perfstat"],
+        define_macros=macros,
+        **py_limited_api,
+    )
+
 else:
-    sys.exit('platform %s is not supported' % sys.platform)
+    sys.exit("platform {} is not supported".format(sys.platform))
+
+
+class BuildExt(build_ext):
+    """Compile the C sources in parallel."""
+
+    def build_extensions(self):  # override
+        compiler = self.compiler
+        real_spawn = compiler.spawn
+        real_compile = compiler.compile
+
+        def parallel_compile(*args, **kwargs):
+            # Run compile() as usual, but have every compiler
+            # invocation return right away, then wait for all of them.
+            # Hooking spawn() instead of the private per-file methods
+            # is what makes this work on Windows as well.
+            futures = []
+            with concurrent.futures.ThreadPoolExecutor(num_cpus()) as pool:
+                compiler.spawn = lambda cmd, **kw: futures.append(
+                    pool.submit(real_spawn, cmd, **kw)
+                )
+                try:
+                    objects = real_compile(*args, **kwargs)
+                finally:
+                    compiler.spawn = real_spawn
+                for fut in concurrent.futures.as_completed(futures):
+                    fut.result()  # let compiler errors surface
+            return objects
+
+        compiler.compile = parallel_compile
+        super().build_extensions()
+
+
+def print_install_instructions():
+
+    def install_sysdeps_cmd():
+        url = (
+            "https://raw.githubusercontent.com/giampaolo/psutil/"
+            "master/scripts/internal/install-sysdeps.sh"
+        )
+        if shutil.which("curl"):
+            return f"curl -fsSL {url} | sh"
+        if shutil.which("wget"):
+            return f"wget -qO- {url} | sh"
+        if shutil.which("fetch"):  # FreeBSD
+            return f"fetch -qo - {url} | sh"
+        if shutil.which("ftp"):  # OpenBSD / NetBSD
+            return f"ftp -o - {url} | sh"
+
+    if not has_compiler():
+        suggest = "A working C compiler is not installed."
+        if MACOS:
+            cmd = "xcode-select --install"
+        elif AIX or PYPY:
+            cmd = None
+        else:
+            cmd = install_sysdeps_cmd()
+    elif not has_python_h():
+        suggest = "Python header files are not installed."
+        if MACOS or AIX or PYPY:  # noqa: SIM108
+            cmd = None
+        else:
+            cmd = install_sysdeps_cmd()
+    else:
+        return
+
+    if cmd:
+        suggest += f" Try running:\n{cmd}"
+
+    print(hilite(suggest, color="red", bold=True), file=sys.stderr)
 
 
 def main():
-    setup_args = dict(
+    kwargs = dict(
         name='psutil',
         version=VERSION,
-        description=__doc__.replace('\n', '').strip(),
-        long_description=get_description(),
+        description="Cross-platform lib for process and system monitoring.",
+        long_description=get_long_description(),
+        long_description_content_type='text/x-rst',
+        # fmt: off
         keywords=[
-            'ps', 'top', 'kill', 'free', 'lsof', 'netstat', 'nice', 'tty',
-            'ionice', 'uptime', 'taskmgr', 'process', 'df', 'iotop', 'iostat',
-            'ifconfig', 'taskset', 'who', 'pidof', 'pmap', 'smem', 'pstree',
-            'monitoring', 'ulimit', 'prlimit', 'smem',
+            'ps', 'top', 'kill', 'free', 'lsof', 'netstat', 'df', 'uptime',
+            'taskmgr', 'process', 'monitoring', 'performance', 'metrics',
+            'observability',
         ],
+        # fmt: on
         author='Giampaolo Rodola',
-        author_email='g.rodola <at> gmail <dot> com',
+        author_email='g.rodola@gmail.com',
         url='https://github.com/giampaolo/psutil',
         platforms='Platform Independent',
-        license='BSD',
-        packages=['psutil', 'psutil.tests'],
-        # see: python setup.py register --list-classifiers
+        license='BSD-3-Clause',
+        packages=['psutil'],
+        ext_modules=[ext],
+        cmdclass={'build_ext': BuildExt if num_cpus() > 1 else build_ext},
+        options=options,
+        python_requires=">={}.{}".format(*MIN_PY_VERSION),
+        # https://docs.pypi.org/project_metadata/
+        project_urls={
+            'Homepage': 'https://github.com/giampaolo/psutil',
+            'Source': 'https://github.com/giampaolo/psutil',
+            'Issues': 'https://github.com/giampaolo/psutil/issues',
+            'Documentation': 'https://psutil.io/',
+            'Changelog': 'https://psutil.io/changelog/',
+            'Funding': 'https://github.com/sponsors/giampaolo',
+        },
+        # https://pypi.org/classifiers/
         classifiers=[
             'Development Status :: 5 - Production/Stable',
             'Environment :: Console',
-            'Environment :: Win32 (MS Windows)',
             'Intended Audience :: Developers',
             'Intended Audience :: Information Technology',
             'Intended Audience :: System Administrators',
             'License :: OSI Approved :: BSD License',
-            'Operating System :: MacOS :: MacOS X',
-            'Operating System :: Microsoft :: Windows :: Windows NT/2000',
-            'Operating System :: Microsoft',
             'Operating System :: OS Independent',
+            'Operating System :: MacOS :: MacOS X',
+            'Operating System :: Microsoft :: Windows',
+            'Operating System :: Microsoft :: Windows :: Windows 10',
+            'Operating System :: Microsoft :: Windows :: Windows 11',
+            'Operating System :: POSIX :: AIX',
+            'Operating System :: POSIX :: BSD',
             'Operating System :: POSIX :: BSD :: FreeBSD',
             'Operating System :: POSIX :: BSD :: NetBSD',
             'Operating System :: POSIX :: BSD :: OpenBSD',
-            'Operating System :: POSIX :: BSD',
             'Operating System :: POSIX :: Linux',
             'Operating System :: POSIX :: SunOS/Solaris',
             'Operating System :: POSIX',
             'Programming Language :: C',
-            'Programming Language :: Python :: 2',
-            'Programming Language :: Python :: 2.6',
-            'Programming Language :: Python :: 2.7',
+            'Programming Language :: Python',
             'Programming Language :: Python :: 3',
-            'Programming Language :: Python :: 3.0',
-            'Programming Language :: Python :: 3.1',
-            'Programming Language :: Python :: 3.2',
-            'Programming Language :: Python :: 3.3',
-            'Programming Language :: Python :: 3.4',
-            'Programming Language :: Python :: 3.5',
+            'Programming Language :: Python :: 3 :: Only',
             'Programming Language :: Python :: Implementation :: CPython',
             'Programming Language :: Python :: Implementation :: PyPy',
-            'Programming Language :: Python',
-            'Topic :: Software Development :: Libraries :: Python Modules',
+            'Programming Language :: Python :: Free Threading',
             'Topic :: Software Development :: Libraries',
+            'Topic :: Software Development :: Libraries :: Python Modules',
             'Topic :: System :: Benchmark',
             'Topic :: System :: Hardware',
             'Topic :: System :: Monitoring',
             'Topic :: System :: Networking :: Monitoring',
+            'Topic :: System :: Networking :: Monitoring :: Hardware Watchdog',
             'Topic :: System :: Networking',
             'Topic :: System :: Operating System',
             'Topic :: System :: Systems Administration',
             'Topic :: Utilities',
         ],
     )
-    if extensions is not None:
-        setup_args["ext_modules"] = extensions
-    setup(**setup_args)
+    success = False
+    try:
+        setup(**kwargs)
+        success = True
+    finally:
+        cmd = sys.argv[1] if len(sys.argv) >= 2 else ''
+        if (
+            not success
+            and POSIX
+            and cmd.startswith(("build", "install", "bdist", "develop"))
+        ):
+            print_install_instructions()
+
 
 if __name__ == '__main__':
     main()
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 0000000000..a1445853a4
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,38 @@
+# Instructions for running tests
+
+Install deps (e.g. pytest):
+
+```bash
+make install-pydeps-test
+```
+
+Some tests shell out to CLI tools (`ps`, `ifconfig`, ...). On UNIX install them
+with:
+
+```bash
+make install-sysdeps-test
+```
+
+Run tests:
+
+```bash
+make test
+```
+
+Run tests in parallel (faster):
+
+```bash
+make test-parallel
+```
+
+Run a specific test:
+
+```bash
+make test ARGS=tests/test_system.py::TestDiskAPIs
+```
+
+Test C extension memory leaks:
+
+```bash
+make test-memleaks
+```
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000000..e60f8d4c6d
--- /dev/null
+++ b/tests/__init__.py
@@ -0,0 +1,2063 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Test utilities."""
+
+import atexit
+import contextlib
+import ctypes
+import enum
+import errno
+import functools
+import importlib.util
+import ipaddress
+import os
+import pathlib
+import platform
+import random
+import re
+import select
+import shlex
+import shutil
+import signal
+import socket
+import stat
+import subprocess
+import sys
+import sysconfig
+import tempfile
+import textwrap
+import threading
+import time
+import traceback
+import types
+import typing
+import unittest
+import warnings
+from socket import AF_INET
+from socket import AF_INET6
+from socket import SOCK_STREAM
+
+import pytest
+
+import psutil
+import psutil._ntuples as ntuples
+from psutil import AIX
+from psutil import BSD
+from psutil import LINUX
+from psutil import MACOS
+from psutil import NETBSD
+from psutil import OPENBSD
+from psutil import POSIX
+from psutil import SUNOS
+from psutil import WINDOWS
+from psutil import _enums
+from psutil._common import ENCODING
+from psutil._common import ENCODING_ERRS
+from psutil._common import debug
+from psutil._common import supports_ipv6
+
+if POSIX:
+    from psutil._psposix import wait_pid
+
+
+# fmt: off
+__all__ = [
+    # constants
+    'DEVNULL', 'GLOBAL_TIMEOUT', 'TOLERANCE_SYS_MEM', 'NO_RETRIES',
+    'PYPY', 'PYTHON_EXE', 'PYTHON_EXE_ENV', 'ROOT_DIR',
+    'TESTFN_PREFIX', 'UNICODE_SUFFIX', 'INVALID_UNICODE_SUFFIX',
+    'CI_TESTING', 'VALID_PROC_STATUSES', 'TOLERANCE_DISK_USAGE',
+    "HAS_PROC_CPU_AFFINITY", "HAS_CPU_FREQ", "HAS_PROC_ENVIRON",
+    "HAS_PROC_IO_COUNTERS", "HAS_PROC_IONICE",
+    "HAS_PROC_MEMORY_EXTRAS", "HAS_PROC_MEMORY_FOOTPRINT",
+    "HAS_PROC_MEMORY_MAPS",
+    "HAS_PROC_CPU_NUM", "HAS_PROC_RLIMIT", "HAS_SENSORS_BATTERY",
+    "HAS_BATTERY", "HAS_SENSORS_FANS", "HAS_SENSORS_TEMPERATURES",
+    "HAS_NET_CONNECTIONS_UNIX", "HAS_PROC_OPEN_FILES_PATH",
+    "MACOS_11PLUS", "MACOS_12PLUS", "COVERAGE",
+    "AARCH64", "PYTEST_PARALLEL",
+    # subprocesses
+    'pyrun', 'terminate', 'reap_children', 'spawn_subproc', 'spawn_zombie',
+    'spawn_children_pair', 'filter_alien_children',
+    # threads
+    'ThreadTask',
+    # test utils
+    'unittest', 'skip_on_access_denied', 'skip_on_not_implemented',
+    'retry_on_failure', 'PsutilTestCase', 'process_namespace',
+    'system_namespace', 'is_win_secure_system_proc', 'serial', 'isolated',
+    'skipif', 'requires_cli',
+    # type hints
+    'check_ntuple_type_hints', 'check_fun_type_hints',
+    # fs utils
+    'chdir', 'safe_rmpath', 'create_py_exe', 'create_c_exe', 'get_testfn',
+    # os
+    'get_winver', 'kernel_version', 'is_busybox',
+    # sync primitives
+    'call_until', 'wait_for_pid', 'wait_for_file', 'wait_for_file_subproc',
+    # network
+    'check_net_address', 'filter_proc_net_connections',
+    'get_free_port', 'bind_socket', 'bind_unix_socket', 'tcp_socketpair',
+    'unix_socketpair', 'create_sockets',
+    # compat
+    'reload_module', 'import_module_by_path',
+    # others
+    'warn', 'copyload_shared_lib', 'is_namedtuple'
+]
+# fmt: on
+
+
+# ===================================================================
+# --- constants
+# ===================================================================
+
+# --- platforms
+
+PYPY = '__pypy__' in sys.builtin_module_names
+FREE_THREADED = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
+# whether we're running this test suite on a Continuous Integration service
+GITHUB_ACTIONS = 'GITHUB_ACTIONS' in os.environ or 'CIBUILDWHEEL' in os.environ
+CI_TESTING = GITHUB_ACTIONS
+COVERAGE = 'COVERAGE_RUN' in os.environ
+PYTEST_PARALLEL = "PYTEST_XDIST_WORKER" in os.environ  # `make test-parallel`
+# apparently they're the same
+AARCH64 = platform.machine().lower() in {"aarch64", "arm64"}
+RISCV64 = platform.machine() == "riscv64"
+
+
+@functools.lru_cache
+def macos_version():
+    version_str = platform.mac_ver()[0]
+    version = tuple(map(int, version_str.split(".")[:2]))
+    if version == (10, 16):
+        # When built against an older macOS SDK, Python will report
+        # macOS 10.16 instead of the real version.
+        version_str = subprocess.check_output(
+            [
+                sys.executable,
+                "-sS",
+                "-c",
+                "import platform; print(platform.mac_ver()[0])",
+            ],
+            env={"SYSTEM_VERSION_COMPAT": "0"},
+            universal_newlines=True,
+        )
+        version = tuple(map(int, version_str.split(".")[:2]))
+    return version
+
+
+if MACOS:
+    MACOS_11PLUS = macos_version() > (10, 15)
+    MACOS_12PLUS = macos_version() >= (12, 0)
+else:
+    MACOS_11PLUS = False
+    MACOS_12PLUS = False
+
+
+# --- configurable defaults
+
+# how many times retry_on_failure() decorator will retry
+NO_RETRIES = 10
+# bytes tolerance for system-wide related tests
+TOLERANCE_SYS_MEM = 5 * 1024 * 1024  # 5MB
+TOLERANCE_DISK_USAGE = 10 * 1024 * 1024  # 10MB
+# the timeout used in functions which have to wait
+GLOBAL_TIMEOUT = 5
+# be more tolerant if we're on CI in order to avoid false positives
+if CI_TESTING:
+    NO_RETRIES *= 3
+    GLOBAL_TIMEOUT *= 3
+    TOLERANCE_SYS_MEM *= 4
+    TOLERANCE_DISK_USAGE *= 3
+
+# --- file names
+
+# Disambiguate TESTFN with PID for parallel testing.
+TESTFN_PREFIX = f"@psutil-{os.getpid()}-"
+UNICODE_SUFFIX = "-Æ’Å‘Å‘"
+# An invalid unicode string.
+INVALID_UNICODE_SUFFIX = b"f\xc0\x80".decode('utf8', 'surrogateescape')
+ASCII_FS = sys.getfilesystemencoding().lower() in {"ascii", "us-ascii"}
+
+# --- paths
+
+ROOT_DIR = os.environ.get("PSUTIL_ROOT_DIR") or str(
+    pathlib.Path(__file__).resolve().parent.parent
+)
+
+# --- support
+
+HAS_HEAP_INFO = hasattr(psutil, "heap_info")
+HAS_NET_CONNECTIONS_UNIX = POSIX and not SUNOS
+HAS_NET_IO_COUNTERS = hasattr(psutil, "net_io_counters")
+HAS_SENSORS_BATTERY = hasattr(psutil, "sensors_battery")
+HAS_SENSORS_FANS = hasattr(psutil, "sensors_fans")
+HAS_SENSORS_TEMPERATURES = hasattr(psutil, "sensors_temperatures")
+
+HAS_PROC_CPU_AFFINITY = hasattr(psutil.Process, "cpu_affinity")
+HAS_PROC_CPU_NUM = hasattr(psutil.Process, "cpu_num")
+HAS_PROC_ENVIRON = hasattr(psutil.Process, "environ")
+HAS_PROC_IO_COUNTERS = hasattr(psutil.Process, "io_counters")
+HAS_PROC_IONICE = hasattr(psutil.Process, "ionice")
+HAS_PROC_MEMORY_EXTRAS = hasattr(psutil.Process, "memory_extras")
+HAS_PROC_MEMORY_FOOTPRINT = hasattr(psutil.Process, "memory_footprint")
+HAS_PROC_MEMORY_MAPS = hasattr(psutil.Process, "memory_maps")
+HAS_PROC_RLIMIT = hasattr(psutil.Process, "rlimit")
+HAS_PROC_THREADS = hasattr(psutil.Process, "threads")
+HAS_PROC_OPEN_FILES_PATH = not (NETBSD or OPENBSD)
+
+SKIP_SYSCONS = (MACOS or AIX) and os.getuid() != 0
+
+try:
+    HAS_BATTERY = HAS_SENSORS_BATTERY and bool(psutil.sensors_battery())
+except Exception:  # noqa: BLE001
+    atexit.register(functools.partial(print, traceback.format_exc()))
+    HAS_BATTERY = False
+try:
+    HAS_CPU_FREQ = hasattr(psutil, "cpu_freq") and bool(psutil.cpu_freq())
+except Exception:  # noqa: BLE001
+    atexit.register(functools.partial(print, traceback.format_exc()))
+    HAS_CPU_FREQ = False
+
+
+# --- misc
+
+
+def _get_py_exe():
+    def attempt(exe):
+        try:
+            subprocess.check_call(
+                [exe, "-V"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            )
+        except subprocess.CalledProcessError:
+            return None
+        else:
+            return exe
+
+    env = os.environ.copy()
+
+    # Subprocesses (scripts, pyrun(), ...) get sys.path[0] set to the
+    # script's directory, so by default they import whatever psutil is
+    # installed instead of the one we're testing. Point them at ours.
+    # Derived from psutil.__file__ and not from ROOT_DIR because when
+    # testing wheels the source tree next to us has no C extension.
+    psutil_path = str(pathlib.Path(psutil.__file__).resolve().parent.parent)
+    paths = [psutil_path]
+    # Handle venvs.
+    if sys.prefix != sys.base_prefix:
+        paths.append(sysconfig.get_paths()["purelib"])
+    env["PYTHONPATH"] = os.pathsep.join(
+        filter(None, [*paths, env.get("PYTHONPATH")])
+    )
+
+    if PYPY and POSIX:
+        libdir = os.path.dirname(os.path.realpath(sys.executable))
+        env["LD_LIBRARY_PATH"] = os.pathsep.join(
+            filter(None, [libdir, env.get("LD_LIBRARY_PATH")])
+        )
+
+    # On Windows virtual environments use a venv launcher startup
+    # process. This does not play well when counting spawned processes,
+    # or when relying on the PID of the spawned process to do some
+    # checks, e.g. connections check per PID. Let's use the base python
+    # in this case.
+    base = getattr(sys, "_base_executable", None)
+    if WINDOWS and base is not None:
+        # We need to set __PYVENV_LAUNCHER__ to sys.executable for the
+        # base python executable to know about the environment.
+        env["__PYVENV_LAUNCHER__"] = sys.executable
+        return base, env
+    elif GITHUB_ACTIONS:
+        return sys.executable, env
+    elif MACOS:
+        exe = (
+            attempt(sys.executable)
+            or attempt(os.path.realpath(sys.executable))
+            or attempt(
+                shutil.which("python{}.{}".format(*sys.version_info[:2]))
+            )
+            or attempt(psutil.Process().exe())
+        )
+        if not exe:
+            raise ValueError("can't find python exe real abspath")
+        return exe, env
+    else:
+        exe = os.path.realpath(sys.executable)
+        assert os.path.exists(exe), exe
+        return exe, env
+
+
+PYTHON_EXE, PYTHON_EXE_ENV = _get_py_exe()
+DEVNULL = open(os.devnull, 'r+')  # noqa: SIM115
+atexit.register(DEVNULL.close)
+
+VALID_PROC_STATUSES = [
+    getattr(psutil, x) for x in dir(psutil) if x.startswith('STATUS_')
+]
+AF_UNIX = getattr(socket, "AF_UNIX", object())
+
+_subprocesses_started = set()
+_pids_started = set()
+
+
+# ===================================================================
+# --- threads
+# ===================================================================
+
+
+class ThreadTask(threading.Thread):
+    """A thread task which does nothing expect staying alive."""
+
+    def __init__(self):
+        super().__init__()
+        self._running = False
+        self._interval = 0.001
+        self._flag = threading.Event()
+
+    def __repr__(self):
+        name = self.__class__.__name__
+        return f"<{name} running={self._running} at {id(self):#x}>"
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, *args, **kwargs):
+        self.stop()
+
+    def start(self):
+        """Start thread and keep it running until an explicit
+        stop() request. Polls for shutdown every 'timeout' seconds.
+        """
+        if self._running:
+            raise ValueError("already started")
+        threading.Thread.start(self)
+        self._flag.wait()
+
+    def run(self):
+        self._running = True
+        self._flag.set()
+        while self._running:
+            time.sleep(self._interval)
+
+    def stop(self):
+        """Stop thread execution and and waits until it is stopped."""
+        if not self._running:
+            raise ValueError("already stopped")
+        self._running = False
+        self.join()
+
+
+# ===================================================================
+# --- subprocesses
+# ===================================================================
+
+
+def _reap_children_on_err(fun):
+    @functools.wraps(fun)
+    def wrapper(*args, **kwargs):
+        try:
+            return fun(*args, **kwargs)
+        except Exception:
+            reap_children()
+            raise
+
+    return wrapper
+
+
+@_reap_children_on_err
+def spawn_subproc(cmd=None, **kwds):
+    """Create a python subprocess which does nothing for some secs and
+    return it as a subprocess.Popen instance.
+    If "cmd" is specified that is used instead of python.
+    By default stdin and stdout are redirected to /dev/null.
+    It also attempts to make sure the process is in a reasonably
+    initialized state.
+    The process is registered for cleanup on reap_children().
+    """
+    kwds.setdefault("stdin", DEVNULL)
+    kwds.setdefault("stdout", DEVNULL)
+    kwds.setdefault("cwd", os.getcwd())
+    kwds.setdefault("env", PYTHON_EXE_ENV)
+    if WINDOWS:
+        # Prevents the subprocess to open error dialogs. This will also
+        # cause stderr to be suppressed, which is suboptimal in order
+        # to debug broken tests.
+        # CREATE_NO_WINDOW = 0x8000000
+        # kwds.setdefault("creationflags", CREATE_NO_WINDOW)
+
+        # New: hopefully this should achieve the same and not suppress
+        # stderr.
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        startupinfo.wShowWindow = subprocess.SW_HIDE
+        kwds.setdefault("startupinfo", startupinfo)
+
+    if cmd is None:
+        testfn = get_testfn(dir=os.getcwd())
+        try:
+            safe_rmpath(testfn)
+            pyline = (
+                "import time;"
+                f"open(r'{testfn}', 'w').close();"
+                "[time.sleep(0.1) for x in range(100)];"  # 10 secs
+            )
+            cmd = [PYTHON_EXE, "-c", pyline]
+            kwds.setdefault("stderr", subprocess.PIPE)
+            sproc = subprocess.Popen(cmd, **kwds)
+            _subprocesses_started.add(sproc)
+            wait_for_file_subproc(testfn, sproc, delete=True, empty=True)
+        finally:
+            safe_rmpath(testfn)
+    else:
+        sproc = subprocess.Popen(cmd, **kwds)
+        _subprocesses_started.add(sproc)
+        wait_for_pid(sproc.pid)
+        _wait_for_cmdline(sproc.pid)
+    return sproc
+
+
+@_reap_children_on_err
+def spawn_children_pair():
+    """Create a subprocess which creates another one as in:
+    A (us) -> B (child) -> C (grandchild).
+    Return a (child, grandchild) tuple.
+    The 2 processes are fully initialized and will live for 60 secs
+    and are registered for cleanup on reap_children().
+    """
+    tfile = None
+    testfn = get_testfn(dir=os.getcwd())
+    try:
+        s = textwrap.dedent(f"""\
+            import subprocess, os, sys, time
+            s = "import os, time;"
+            s += "f = open('{os.path.basename(testfn)}', 'w');"
+            s += "f.write(str(os.getpid()));"
+            s += "f.close();"
+            s += "[time.sleep(0.1) for x in range(100 * 6)];"
+            p = subprocess.Popen([r'{PYTHON_EXE}', '-c', s])
+            p.wait()
+            """)
+        # On Windows if we create a subprocess with CREATE_NO_WINDOW flag
+        # set (which is the default) a "conhost.exe" extra process will be
+        # spawned as a child. We don't want that.
+        if WINDOWS:
+            subp, tfile = pyrun(s, creationflags=0, stderr=subprocess.PIPE)
+        else:
+            subp, tfile = pyrun(s, stderr=subprocess.PIPE)
+        child = psutil.Process(subp.pid)
+        grandchild_pid = int(
+            wait_for_file_subproc(testfn, subp, delete=True, empty=False)
+        )
+        _pids_started.add(grandchild_pid)
+        grandchild = psutil.Process(grandchild_pid)
+        return (child, grandchild)
+    finally:
+        safe_rmpath(testfn)
+        if tfile is not None:
+            safe_rmpath(tfile)
+
+
+def spawn_zombie():
+    """Create a zombie process and return a (parent, zombie) process tuple.
+    In order to kill the zombie parent must be terminate()d first, then
+    zombie must be wait()ed on.
+    """
+    assert psutil.POSIX
+    unix_file = get_testfn()
+    src = textwrap.dedent(f"""\
+        import os, socket, time
+        child_pid = os.fork()
+        if child_pid == 0:
+            os._exit(0)
+        else:
+            with socket.socket(socket.AF_UNIX) as s:
+                s.connect('{unix_file}')
+                s.sendall(bytes(str(child_pid), 'ascii'))
+            time.sleep(3000)
+        """)
+    tfile = None
+    sock = bind_unix_socket(unix_file)
+    try:
+        sock.settimeout(GLOBAL_TIMEOUT)
+        parent, tfile = pyrun(src)
+        conn, _ = sock.accept()
+        try:
+            select.select([conn.fileno()], [], [], GLOBAL_TIMEOUT)
+            zpid = int(conn.recv(1024))
+            _pids_started.add(zpid)
+            zombie = psutil.Process(zpid)
+            call_until(lambda: zombie.status() == psutil.STATUS_ZOMBIE)
+            return (parent, zombie)
+        finally:
+            conn.close()
+    finally:
+        sock.close()
+        safe_rmpath(unix_file)
+        if tfile is not None:
+            safe_rmpath(tfile)
+
+
+@_reap_children_on_err
+def pyrun(src, **kwds):
+    """Run python 'src' code string in a separate interpreter.
+    Returns a subprocess.Popen instance and the test file where the source
+    code was written.
+    """
+    kwds.setdefault("stdout", None)
+    kwds.setdefault("stderr", None)
+    srcfile = get_testfn()
+    try:
+        with open(srcfile, "w") as f:
+            f.write(src)
+        subp = spawn_subproc([PYTHON_EXE, f.name], **kwds)
+        wait_for_pid(subp.pid)
+        return (subp, srcfile)
+    except Exception:
+        safe_rmpath(srcfile)
+        raise
+
+
+@_reap_children_on_err
+def sh(cmd, **kwds):
+    """Run cmd in a subprocess and return its output.
+    raises RuntimeError on error.
+    """
+    # Prevents subprocess to open error dialogs in case of error.
+    flags = 0x8000000 if WINDOWS else 0
+    kwds.setdefault("stdout", subprocess.PIPE)
+    kwds.setdefault("stderr", subprocess.PIPE)
+    kwds.setdefault("universal_newlines", True)
+    kwds.setdefault("encoding", ENCODING)
+    kwds.setdefault("errors", ENCODING_ERRS)
+    kwds.setdefault("creationflags", flags)
+    if isinstance(cmd, str):
+        cmd = shlex.split(cmd)
+    p = subprocess.Popen(cmd, **kwds)
+    _subprocesses_started.add(p)
+    stdout, stderr = p.communicate(timeout=GLOBAL_TIMEOUT)
+    if p.returncode != 0:
+        raise RuntimeError(stdout + stderr)
+    if stderr:
+        warn(stderr)
+    if stdout.endswith('\n'):
+        stdout = stdout[:-1]
+    return stdout
+
+
+def terminate(proc_or_pid, sig=signal.SIGTERM, wait_timeout=GLOBAL_TIMEOUT):
+    """Terminate a process and wait() for it.
+    Process can be a PID or an instance of psutil.Process(),
+    subprocess.Popen() or psutil.Popen().
+    If it's a subprocess.Popen() or psutil.Popen() instance also closes
+    its stdin / stdout / stderr fds.
+    PID is wait()ed even if the process is already gone (kills zombies).
+    Does nothing if the process does not exist.
+    Return process exit status.
+    """
+
+    def wait(proc, timeout):
+        proc.wait(timeout)
+        if WINDOWS and isinstance(proc, subprocess.Popen):
+            # Otherwise PID may still hang around.
+            try:
+                return psutil.Process(proc.pid).wait(timeout)
+            except psutil.NoSuchProcess:
+                pass
+
+    def sendsig(proc, sig):
+        # XXX: otherwise the build hangs for some reason.
+        if MACOS and GITHUB_ACTIONS:
+            sig = signal.SIGKILL
+        # If the process received SIGSTOP, SIGCONT is necessary first,
+        # otherwise SIGTERM won't work.
+        if POSIX and sig != signal.SIGKILL:
+            proc.send_signal(signal.SIGCONT)
+        proc.send_signal(sig)
+
+    def term_subprocess_proc(proc, timeout):
+        try:
+            sendsig(proc, sig)
+        except ProcessLookupError:
+            pass
+        except OSError as err:
+            if WINDOWS and err.winerror == 6:  # "invalid handle"
+                pass
+            raise
+        return wait(proc, timeout)
+
+    def term_psutil_proc(proc, timeout):
+        try:
+            sendsig(proc, sig)
+        except psutil.NoSuchProcess:
+            pass
+        return wait(proc, timeout)
+
+    def term_pid(pid, timeout):
+        try:
+            proc = psutil.Process(pid)
+        except psutil.NoSuchProcess:
+            # Needed to kill zombies.
+            if POSIX:
+                return wait_pid(pid, timeout)
+        else:
+            return term_psutil_proc(proc, timeout)
+
+    def flush_popen(proc):
+        if proc.stdout:
+            proc.stdout.close()
+        if proc.stderr:
+            proc.stderr.close()
+        # Flushing a BufferedWriter may raise an error.
+        if proc.stdin:
+            proc.stdin.close()
+
+    p = proc_or_pid
+    try:
+        if isinstance(p, int):
+            return term_pid(p, wait_timeout)
+        elif isinstance(p, (psutil.Process, psutil.Popen)):
+            return term_psutil_proc(p, wait_timeout)
+        elif isinstance(p, subprocess.Popen):
+            return term_subprocess_proc(p, wait_timeout)
+        else:
+            raise TypeError(f"wrong type {p!r}")
+    finally:
+        if isinstance(p, (subprocess.Popen, psutil.Popen)):
+            flush_popen(p)
+        pid = p if isinstance(p, int) else p.pid
+        assert not psutil.pid_exists(pid), pid
+
+
+def filter_alien_children(procs):
+    """On Windows CI the runner agent (provjobd.exe) sporadically
+    spawns wsl.exe, conhost.exe, etc. When their parent dies the PPID
+    is left dangling (Windows never clears it), and if that PID gets
+    reused by us they show up as our children.
+    """
+    if not (WINDOWS and CI_TESTING):
+        return procs
+    names = {"wsl.exe", "conhost.exe"}
+    aliens = {
+        x.pid
+        for x in psutil.process_iter(["name"])
+        if (x.name() or "").lower() in names
+    }
+    return [x for x in procs if x.pid not in aliens]
+
+
+def reap_children(recursive=False):
+    """Terminate and wait() any subprocess started by this test suite
+    and any children currently running, ensuring that no processes stick
+    around to hog resources.
+    If recursive is True it also tries to terminate and wait()
+    all grandchildren started by this process.
+    """
+    # Get the children here before terminating them, as in case of
+    # recursive=True we don't want to lose the intermediate reference
+    # pointing to the grandchildren.
+    children = psutil.Process().children(recursive=recursive)
+    # children() lists them top-down; reverse so descendants die before
+    # their parents (avoids orphaning grandchildren).
+    children.reverse()
+
+    # Terminate subprocess.Popen.
+    while _subprocesses_started:
+        subp = _subprocesses_started.pop()
+        terminate(subp)
+
+    # Collect started pids.
+    while _pids_started:
+        pid = _pids_started.pop()
+        terminate(pid)
+
+    # Terminate children.
+    if children:
+        timeout = 3
+        for p in children:
+            try:
+                terminate(p, wait_timeout=timeout)
+            except psutil.TimeoutExpired:
+                warn(f"{p!r} didn't terminate within {timeout} secs")
+        _, alive = psutil.wait_procs(children, timeout=GLOBAL_TIMEOUT)
+        for p in alive:
+            warn(f"couldn't terminate process {p!r}; attempting kill()")
+            terminate(p, sig=signal.SIGKILL)
+
+
+# ===================================================================
+# --- OS
+# ===================================================================
+
+
+def kernel_version():
+    """Return a tuple such as (2, 6, 36)."""
+    if not POSIX:
+        raise NotImplementedError("not POSIX")
+    s = ""
+    uname = os.uname()[2]
+    for c in uname:
+        if c.isdigit() or c == '.':
+            s += c
+        else:
+            break
+    if not s:
+        raise ValueError(f"can't parse {uname!r}")
+    minor = 0
+    micro = 0
+    nums = s.split('.')
+    major = int(nums[0])
+    if len(nums) >= 2:
+        minor = int(nums[1])
+    if len(nums) >= 3:
+        micro = int(nums[2])
+    return (major, minor, micro)
+
+
+def get_winver():
+    if not WINDOWS:
+        raise NotImplementedError("not WINDOWS")
+    wv = sys.getwindowsversion()
+    sp = wv.service_pack_major or 0
+    return (wv[0], wv[1], sp)
+
+
+@functools.lru_cache
+def is_busybox(cmd):
+    """Whether cmd is provided by busybox / Alpine Linux."""
+    path = shutil.which(cmd)
+    if path is None:
+        return False
+    return os.path.basename(os.path.realpath(path)) == "busybox"
+
+
+# ===================================================================
+# --- sync primitives
+# ===================================================================
+
+
+class retry:
+    """A retry decorator."""
+
+    def __init__(
+        self,
+        exception=Exception,
+        timeout=None,
+        retries=None,
+        interval=0.001,
+        logfun=None,
+    ):
+        if timeout and retries:
+            raise ValueError("timeout and retries args are mutually exclusive")
+        self.exception = exception
+        self.timeout = timeout
+        self.retries = retries
+        self.interval = interval
+        self.logfun = logfun
+
+    def __iter__(self):
+        if self.timeout:
+            # time.monotonic(): the BSD CI VMs step the system clock
+            # (NTP), which would expire a time.time() deadline early.
+            stop_at = time.monotonic() + self.timeout
+            while time.monotonic() < stop_at:
+                yield
+        elif self.retries:
+            for _ in range(self.retries):
+                yield
+        else:
+            while True:
+                yield
+
+    def sleep(self):
+        if self.interval is not None:
+            time.sleep(self.interval)
+
+    def __call__(self, fun):
+        @functools.wraps(fun)
+        def wrapper(*args, **kwargs):
+            exc = None
+            for _ in self:
+                try:
+                    return fun(*args, **kwargs)
+                except self.exception as _:
+                    exc = _
+                    if self.logfun is not None:
+                        self.logfun(exc)
+                    self.sleep()
+                    continue
+
+            raise exc
+
+        # This way the user of the decorated function can change config
+        # parameters.
+        wrapper.decorator = self
+        return wrapper
+
+
+@retry(
+    exception=psutil.NoSuchProcess,
+    logfun=None,
+    timeout=GLOBAL_TIMEOUT,
+    interval=0.001,
+)
+def wait_for_pid(pid):
+    """Wait for pid to show up in the process list then return.
+    Used in the test suite to give time the sub process to initialize.
+    """
+    if pid not in psutil.pids():
+        raise psutil.NoSuchProcess(pid)
+    psutil.Process(pid)
+
+
+@retry(
+    exception=(FileNotFoundError, AssertionError),
+    logfun=None,
+    timeout=GLOBAL_TIMEOUT,
+    interval=0.001,
+)
+def wait_for_file(fname, delete=True, empty=False):
+    """Wait for a file to be written on disk with some content."""
+    with open(fname, "rb") as f:
+        data = f.read()
+    if not empty:
+        assert data
+    if delete:
+        safe_rmpath(fname)
+    return data
+
+
+def wait_for_file_subproc(fname, sproc, delete=True, empty=False):
+    """Wait for a file to be written on disk, which is supposed to be
+    written by a subprocess.
+    """
+    try:
+        return wait_for_file(fname, delete=delete, empty=empty)
+    except FileNotFoundError as err:
+        ret = sproc.poll()
+        if ret is None:
+            raise
+        stderr = sproc.stderr.read() if sproc.stderr else b""
+        if isinstance(stderr, bytes):
+            stderr = stderr.decode(errors="replace")
+        msg = f"subprocess died (exit {ret}):\n{stderr}"
+        raise RuntimeError(msg) from err
+
+
+@retry(
+    exception=(AssertionError, psutil.AccessDenied),
+    logfun=None,
+    timeout=GLOBAL_TIMEOUT,
+    interval=0.001,
+)
+def _wait_for_cmdline(pid):
+    # Popen() returns before the kernel publishes argv, so for a moment
+    # cmdline reads back empty on Linux, and raises AccessDenied on
+    # macOS, where sysctl(KERN_PROCARGS2) fails with EINVAL.
+    try:
+        assert psutil.Process(pid).cmdline()
+    except (psutil.NoSuchProcess, psutil.ZombieProcess):
+        return
+
+
+@retry(
+    exception=(AssertionError, pytest.fail.Exception),
+    logfun=None,
+    timeout=GLOBAL_TIMEOUT,
+    interval=0.001,
+)
+def call_until(fun):
+    """Keep calling function until it evaluates to True."""
+    ret = fun()
+    assert ret
+    return ret
+
+
+# ===================================================================
+# --- fs
+# ===================================================================
+
+
+def safe_rmpath(path):
+    """Convenience function for removing temporary test files or dirs."""
+
+    def retry_fun(fun):
+        # On Windows it could happen that the file or directory has
+        # open handles or references preventing the delete operation
+        # to succeed immediately, so we retry for a while. See:
+        # https://bugs.python.org/issue33240
+        stop_at = time.monotonic() + GLOBAL_TIMEOUT
+        while time.monotonic() < stop_at:
+            try:
+                return fun()
+            except FileNotFoundError:
+                pass
+            except OSError as _:
+                err = _
+                warn(f"ignoring {err}")
+            time.sleep(0.01)
+        raise err
+
+    try:
+        st = os.stat(path)
+        if stat.S_ISDIR(st.st_mode):
+            fun = functools.partial(shutil.rmtree, path)
+        else:
+            fun = functools.partial(os.remove, path)
+        if POSIX:
+            fun()
+        else:
+            retry_fun(fun)
+    except FileNotFoundError:
+        pass
+
+
+def safe_mkdir(dir):
+    """Convenience function for creating a directory."""
+    try:
+        os.mkdir(dir)
+    except FileExistsError:
+        pass
+
+
+@contextlib.contextmanager
+def chdir(dirname):
+    """Context manager which temporarily changes the current directory."""
+    curdir = os.getcwd()
+    try:
+        os.chdir(dirname)
+        yield
+    finally:
+        os.chdir(curdir)
+
+
+def create_py_exe(path):
+    """Create a Python executable file in the given location."""
+    assert not os.path.exists(path), path
+    atexit.register(safe_rmpath, path)
+    shutil.copyfile(PYTHON_EXE, path)
+    if POSIX:
+        st = os.stat(path)
+        os.chmod(path, st.st_mode | stat.S_IEXEC)
+    return path
+
+
+def create_c_exe(path, c_code=None):
+    """Create a compiled C executable in the given location."""
+    assert not os.path.exists(path), path
+    if not shutil.which("gcc"):
+        return pytest.skip("gcc is not installed")
+    if c_code is None:
+        c_code = textwrap.dedent("""
+            #include <unistd.h>
+            int main() {
+                pause();
+                return 1;
+            }
+            """)
+    else:
+        assert isinstance(c_code, str), c_code
+
+    atexit.register(safe_rmpath, path)
+    with open(get_testfn(suffix='.c'), "w") as f:
+        f.write(c_code)
+    try:
+        subprocess.check_call(["gcc", f.name, "-o", path])
+    finally:
+        safe_rmpath(f.name)
+    return path
+
+
+def get_testfn(suffix="", dir=None):
+    """Return an absolute pathname of a file or dir that did not
+    exist at the time this call is made. Also schedule it for safe
+    deletion at interpreter exit. It's technically racy but probably
+    not really due to the time variant.
+    """
+    name = tempfile.mktemp(prefix=TESTFN_PREFIX, suffix=suffix, dir=dir)
+    path = os.path.realpath(name)  # needed for OSX
+    atexit.register(safe_rmpath, path)
+    return path
+
+
+# ===================================================================
+# --- testing
+# ===================================================================
+
+# `@serial` decorator: put all marked tests on the same xdist worker,
+# so they don't run concurrently in the same process. Needed by tests
+# that share the same system-wide resource (e.g. a socket) and must not
+# overlap.
+# - net_connections() / Process.net_connections() that compare vs
+#   `ss`, `netstat`, etc.
+# - the socket-opening helpers: create_sockets(), bind_socket(),
+#   tcp_socketpair(), unix_socketpair(), bind_unix_socket()
+serial = pytest.mark.xdist_group(name="serial")
+
+# `@isolated` decorator: these tests are skipped under xdist and run in
+# a second, separate pytest run (`-m isolated`) that uses a single
+# process. They need a quiet, non-xdist environment, because
+# they measure noisy per-process or system counters.
+# - CPU counters compared vs getrusage / vmstat / WMI: cpu_stats(),
+#   Process.num_ctx_switches(), Process.page_faults()
+# - per-process counts other tests can move: Process.num_threads(),
+#   Process.num_fds(), Process.threads(), heap_info()
+isolated = pytest.mark.isolated
+
+skipif = pytest.mark.skipif
+
+
+def requires_cli(cmd):
+    """Skip test if CLI command is not available."""
+
+    def outer(fun):
+        @functools.wraps(fun)
+        def inner(*args, **kwargs):
+            if not shutil.which(cmd):
+                pytest.skip(f"{cmd} cmd not available")
+            return fun(*args, **kwargs)
+
+        return inner
+
+    return outer
+
+
+class PsutilTestCase(unittest.TestCase):
+    """Test class providing auto-cleanup wrappers on top of process
+    test utilities. All test classes should derive from this one, even
+    if we use pytest.
+    """
+
+    # Print a full path representation of the single unit test being
+    # run, similar to pytest output. Used only when running tests with
+    # the unittest runner.
+    def __str__(self):
+        fqmod = self.__class__.__module__
+        if not fqmod.startswith('psutil.'):
+            fqmod = 'tests.' + fqmod
+        return "{}.{}.{}".format(
+            fqmod,
+            self.__class__.__name__,
+            self._testMethodName,
+        )
+
+    def get_testfn(self, suffix="", dir=None):
+        fname = get_testfn(suffix=suffix, dir=dir)
+        self.addCleanup(safe_rmpath, fname)
+        return fname
+
+    def spawn_subproc(self, *args, **kwds):
+        sproc = spawn_subproc(*args, **kwds)
+        self.addCleanup(terminate, sproc)
+        return sproc
+
+    def spawn_psproc(self, *args, **kwargs):
+        sproc = self.spawn_subproc(*args, **kwargs)
+        try:
+            return psutil.Process(sproc.pid)
+        except psutil.NoSuchProcess:
+            self.assert_pid_gone(sproc.pid)
+            raise
+
+    def spawn_children_pair(self):
+        child1, child2 = spawn_children_pair()
+        self.addCleanup(terminate, child2)
+        self.addCleanup(terminate, child1)  # executed first
+        return (child1, child2)
+
+    def spawn_zombie(self):
+        parent, zombie = spawn_zombie()
+        self.addCleanup(terminate, zombie)
+        self.addCleanup(terminate, parent)  # executed first
+        return (parent, zombie)
+
+    def pyrun(self, *args, **kwds):
+        sproc, srcfile = pyrun(*args, **kwds)
+        self.addCleanup(safe_rmpath, srcfile)
+        self.addCleanup(terminate, sproc)  # executed first
+        return sproc
+
+    def _check_proc_exc(self, proc, exc):
+        assert isinstance(exc, psutil.Error)
+        assert exc.pid == proc.pid
+        assert exc.name == proc._name
+        if exc.name:
+            assert exc.name
+        if isinstance(exc, psutil.ZombieProcess):
+            assert exc.ppid == proc._ppid
+            if exc.ppid is not None:
+                assert exc.ppid >= 0
+        str(exc)
+        repr(exc)
+
+    def assert_pid_gone(self, pid):
+        try:
+            proc = psutil.Process(pid)
+        except psutil.ZombieProcess:
+            raise AssertionError("wasn't supposed to raise ZombieProcess")
+        except psutil.NoSuchProcess as exc:
+            assert exc.pid == pid  # noqa: PT017
+            assert exc.name is None  # noqa: PT017
+        else:
+            raise AssertionError(f"did not raise NoSuchProcess ({proc})")
+
+        assert not psutil.pid_exists(pid), pid
+        assert pid not in psutil.pids()
+        assert pid not in [x.pid for x in psutil.process_iter()]
+
+    def assert_proc_gone(self, proc):
+        self.assert_pid_gone(proc.pid)
+        ns = process_namespace(proc)
+        for fun, name in ns.iter(ns.all, clear_cache=True):
+            with self.subTest(proc=str(proc), name=name):
+                try:
+                    ret = fun()
+                except psutil.ZombieProcess:
+                    raise
+                except psutil.NoSuchProcess as exc:
+                    self._check_proc_exc(proc, exc)
+                else:
+                    msg = (
+                        f"Process.{name}() didn't raise NSP and returned"
+                        f" {ret!r}"
+                    )
+                    raise AssertionError(msg)
+        proc.wait(timeout=0)  # assert not raise TimeoutExpired
+
+    def assert_proc_zombie(self, proc):
+        def assert_in_pids(proc):
+            if MACOS:
+                # Even ps does not show zombie PIDs for some reason. Weird...
+                return
+            assert proc.pid in psutil.pids()
+            assert proc.pid in [x.pid for x in psutil.process_iter()]
+            psutil._pmap = {}
+            assert proc.pid in [x.pid for x in psutil.process_iter()]
+
+        # A zombie process should always be instantiable.
+        clone = psutil.Process(proc.pid)
+        # Cloned zombie on Open/NetBSD/illumos/Solaris has null creation
+        # time, see:
+        # https://github.com/giampaolo/psutil/issues/2287
+        # https://github.com/giampaolo/psutil/issues/2593
+        assert proc == clone
+        if not (OPENBSD or NETBSD or SUNOS):
+            assert hash(proc) == hash(clone)
+        # Its status always be querable.
+        assert proc.status() == psutil.STATUS_ZOMBIE
+        # It should be considered 'running'.
+        assert proc.is_running()
+        assert psutil.pid_exists(proc.pid)
+        # as_dict() shouldn't crash.
+        proc.as_dict()
+        # It should show up in pids() and process_iter().
+        assert_in_pids(proc)
+        # Call all methods.
+        ns = process_namespace(proc)
+        for fun, name in ns.iter(ns.all, clear_cache=True):
+            with self.subTest(proc=str(proc), name=name):
+                try:
+                    fun()
+                except (psutil.ZombieProcess, psutil.AccessDenied) as exc:
+                    self._check_proc_exc(proc, exc)
+        if LINUX:
+            # https://github.com/giampaolo/psutil/pull/2288
+            with pytest.raises(psutil.ZombieProcess) as cm:
+                proc.cmdline()
+            self._check_proc_exc(proc, cm.value)
+            with pytest.raises(psutil.ZombieProcess) as cm:
+                proc.exe()
+            self._check_proc_exc(proc, cm.value)
+            with pytest.raises(psutil.ZombieProcess) as cm:
+                proc.memory_maps()
+            self._check_proc_exc(proc, cm.value)
+        # Zombie cannot be signaled or terminated. Another user's zombie
+        # can't be signaled at all, so only try on our own.
+        if not POSIX or proc.uids().real == os.getuid():
+            proc.suspend()
+            proc.resume()
+            proc.terminate()
+            proc.kill()
+        assert proc.is_running()
+        assert psutil.pid_exists(proc.pid)
+        assert_in_pids(proc)
+
+        # Its parent should 'see' it (edit: not true on BSD and MACOS).
+        # descendants = [x.pid for x in psutil.Process().children(
+        #                recursive=True)]
+        # assert proc.pid in descendants
+
+        # __eq__ can't be relied upon because creation time may not be
+        # querable.
+        # assert proc ==  psutil.Process(proc.pid)
+
+        # XXX should we also assume ppid() to be usable? Note: this
+        # would be an important use case as the only way to get
+        # rid of a zombie is to kill its parent.
+        # assert proc == ppid(), os.getpid()
+
+    def check_proc_memory(self, nt):
+        # Check the ntuple returned by Process.memory_*() methods.
+        check_ntuple_type_hints(nt)
+        for value in nt:
+            assert isinstance(value, int)
+            assert value >= 0
+        if hasattr(nt, "peak_rss") and hasattr(nt, "rss"):
+            if BSD and nt.peak_rss == 0:
+                pass  # kernel threads don't have rusage tracking
+            else:
+                # VmHWM (from /proc/pid/status) and ru_maxrss both
+                # track peak RSS but are synced independently. Allow 5%
+                # tolerance.
+                diff = nt.rss - nt.peak_rss
+                assert diff <= nt.rss * 0.05
+
+
+def is_win_secure_system_proc(pid):
+    # see: https://github.com/giampaolo/psutil/issues/2338
+    @functools.lru_cache
+    def get_procs():
+        ret = {}
+        out = sh("tasklist.exe /NH /FO csv")
+        for line in out.splitlines()[1:]:
+            bits = [x.replace('"', "") for x in line.split(",")]
+            name, pid = bits[0], int(bits[1])
+            ret[pid] = name
+        return ret
+
+    try:
+        return get_procs()[pid] == "Secure System"
+    except KeyError:
+        return False
+
+
+def _get_eligible_cpu():
+    p = psutil.Process()
+    if hasattr(p, "cpu_num"):
+        return p.cpu_num()
+    elif hasattr(p, "cpu_affinity"):
+        return random.choice(p.cpu_affinity())
+    return 0
+
+
+class process_namespace:
+    """A container that lists all Process class method names + some
+    reasonable parameters to be called with. Utility methods (parent(),
+    children(), ...) are excluded.
+
+    >>> ns = process_namespace(psutil.Process())
+    >>> for fun, name in ns.iter(ns.getters):
+    ...    fun()
+    """
+
+    utils = [('cpu_percent', (), {}), ('memory_percent', (), {})]
+
+    ignored = [
+        ('as_dict', (), {}),
+        ('attrs', (), {}),
+        ('children', (), {'recursive': True}),
+        ('connections', (), {}),  # deprecated
+        ('info', (), {}),
+        ('is_running', (), {}),
+        ('memory_full_info', (), {}),  # deprecated
+        ('oneshot', (), {}),
+        ('parent', (), {}),
+        ('parents', (), {}),
+        ('pid', (), {}),
+        ('wait', (0,), {}),
+    ]
+
+    getters = [
+        ('cmdline', (), {}),
+        ('cpu_times', (), {}),
+        ('create_time', (), {}),
+        ('cwd', (), {}),
+        ('exe', (), {}),
+        ('memory_info', (), {}),
+        ('name', (), {}),
+        ('net_connections', (), {'kind': 'all'}),
+        ('nice', (), {}),
+        ('num_ctx_switches', (), {}),
+        ('num_threads', (), {}),
+        ('open_files', (), {}),
+        ('page_faults', (), {}),
+        ('ppid', (), {}),
+        ('status', (), {}),
+        ('threads', (), {}),
+        ('username', (), {}),
+    ]
+    if POSIX:
+        getters += [('uids', (), {})]
+        getters += [('gids', (), {})]
+        getters += [('terminal', (), {})]
+        getters += [('num_fds', (), {})]
+    if HAS_PROC_IO_COUNTERS:
+        getters += [('io_counters', (), {})]
+    if HAS_PROC_IONICE:
+        getters += [('ionice', (), {})]
+    if HAS_PROC_RLIMIT:
+        getters += [('rlimit', (psutil.RLIMIT_NOFILE,), {})]
+    if HAS_PROC_CPU_AFFINITY:
+        getters += [('cpu_affinity', (), {})]
+    if HAS_PROC_CPU_NUM:
+        getters += [('cpu_num', (), {})]
+    if HAS_PROC_ENVIRON:
+        getters += [('environ', (), {})]
+    if WINDOWS:
+        getters += [('num_handles', (), {})]
+    if HAS_PROC_MEMORY_EXTRAS:
+        getters += [('memory_extras', (), {})]
+    if HAS_PROC_MEMORY_FOOTPRINT:
+        getters += [('memory_footprint', (), {})]
+    if HAS_PROC_MEMORY_MAPS:
+        getters += [('memory_maps', (), {'grouped': True})]
+        getters += [('memory_maps', (), {'grouped': False})]
+
+    setters = []
+    if POSIX:
+        setters += [('nice', (0,), {})]
+    else:
+        setters += [('nice', (psutil.NORMAL_PRIORITY_CLASS,), {})]
+    if HAS_PROC_RLIMIT:
+        setters += [('rlimit', (psutil.RLIMIT_NOFILE, (1024, 4096)), {})]
+    if HAS_PROC_IONICE:
+        if LINUX:
+            setters += [('ionice', (psutil.IOPRIO_CLASS_NONE, 0), {})]
+        else:
+            setters += [('ionice', (psutil.IOPRIO_NORMAL,), {})]
+    if HAS_PROC_CPU_AFFINITY:
+        setters += [('cpu_affinity', ([_get_eligible_cpu()],), {})]
+
+    killers = [
+        ('send_signal', (signal.SIGTERM,), {}),
+        ('suspend', (), {}),
+        ('resume', (), {}),
+        ('terminate', (), {}),
+        ('kill', (), {}),
+    ]
+    if WINDOWS:
+        killers += [('send_signal', (signal.CTRL_C_EVENT,), {})]
+        killers += [('send_signal', (signal.CTRL_BREAK_EVENT,), {})]
+
+    all = utils + getters + setters + killers
+
+    def __init__(self, proc):
+        self._proc = proc
+
+    def iter(self, ls, clear_cache=True):
+        """Given a list of tuples yields a set of (fun, fun_name) tuples
+        in random order.
+        """
+        ls = list(ls)
+        random.shuffle(ls)
+        for fun_name, args, kwds in ls:
+            if clear_cache:
+                self.clear_cache()
+            fun = getattr(self._proc, fun_name)
+            fun = functools.partial(fun, *args, **kwds)
+            yield (fun, fun_name)
+
+    def clear_cache(self):
+        """Clear the cache of a Process instance."""
+        self._proc._init(self._proc.pid, _ignore_nsp=True)
+
+    @classmethod
+    def test_class_coverage(cls, test_class, ls):
+        """Given a TestCase instance and a list of tuples checks that
+        the class defines the required test method names.
+        """
+        for fun_name, _, _ in ls:
+            meth_name = 'test_' + fun_name
+            if not hasattr(test_class, meth_name):
+                msg = (
+                    f"{test_class.__class__.__name__!r} class should define a"
+                    f" {meth_name!r} method"
+                )
+                raise AttributeError(msg)
+
+    @classmethod
+    def test(cls):
+        this = {x[0] for x in cls.all}
+        ignored = {x[0] for x in cls.ignored}
+        klass = {x for x in dir(psutil.Process) if x[0] != '_'}
+        leftout = (this | ignored) ^ klass
+        if leftout:
+            raise ValueError(f"uncovered Process class names: {leftout!r}")
+
+
+class system_namespace:
+    """A container that lists all the module-level, system-related APIs.
+    Utilities such as cpu_percent() are excluded. Usage:
+
+    >>> ns = system_namespace
+    >>> for fun, name in ns.iter(ns.getters):
+    ...    fun()
+    """
+
+    getters = [
+        ('boot_time', (), {}),
+        ('cpu_count', (), {'logical': False}),
+        ('cpu_count', (), {'logical': True}),
+        ('cpu_stats', (), {}),
+        ('cpu_times', (), {'percpu': False}),
+        ('cpu_times', (), {'percpu': True}),
+        ('disk_io_counters', (), {'perdisk': False}),
+        ('disk_io_counters', (), {'perdisk': True}),
+        ('disk_partitions', (), {'all': False}),
+        ('disk_partitions', (), {'all': True}),
+        ('disk_usage', (os.getcwd(),), {}),
+        ('getloadavg', (), {}),
+        ('net_connections', (), {'kind': 'all'}),
+        ('net_if_addrs', (), {}),
+        ('net_if_stats', (), {}),
+        ('net_io_counters', (), {'pernic': False}),
+        ('net_io_counters', (), {'pernic': True}),
+        ('pid_exists', (os.getpid(),), {}),
+        ('pids', (), {}),
+        ('swap_memory', (), {}),
+        ('users', (), {}),
+        ('virtual_memory', (), {}),
+    ]
+
+    if HAS_CPU_FREQ:
+        getters += [('cpu_freq', (), {'percpu': False})]
+        getters += [('cpu_freq', (), {'percpu': True})]
+    if HAS_SENSORS_TEMPERATURES:
+        getters += [('sensors_temperatures', (), {})]
+    if HAS_SENSORS_FANS:
+        getters += [('sensors_fans', (), {})]
+    if HAS_SENSORS_BATTERY:
+        getters += [('sensors_battery', (), {})]
+    if HAS_HEAP_INFO:
+        getters += [('heap_info', (), {})]
+        getters += [('heap_trim', (), {})]
+
+    if WINDOWS:
+        getters += [('win_service_iter', (), {})]
+        getters += [('win_service_get', ('alg',), {})]
+
+    ignored = [
+        ('process_iter', (), {}),
+        ('wait_procs', ([psutil.Process()],), {}),
+        ('cpu_percent', (), {}),
+        ('cpu_times_percent', (), {}),
+    ]
+
+    all = getters
+
+    @staticmethod
+    def iter(ls):
+        """Given a list of tuples yields a set of (fun, fun_name) tuples
+        in random order.
+        """
+        ls = list(ls)
+        random.shuffle(ls)
+        for fun_name, args, kwds in ls:
+            fun = getattr(psutil, fun_name)
+            fun = functools.partial(fun, *args, **kwds)
+            yield (fun, fun_name)
+
+    test_class_coverage = process_namespace.test_class_coverage
+
+
+def retry_on_failure(retries: "int | typing.Callable" = NO_RETRIES):
+    """Decorator which runs a test function and retries N times before
+    giving up and failing.
+    """
+
+    def decorator(test_method):
+        @functools.wraps(test_method)
+        def wrapper(self, *args, **kwargs):
+            err = None
+            for attempt in range(retries):
+                try:
+                    return test_method(self, *args, **kwargs)
+                except (AssertionError, pytest.fail.Exception) as _:
+                    err = _
+                    prefix = "\n" if attempt == 0 else ""
+                    short_err = str(err).split("\n")[0]
+                    print(  # noqa: T201
+                        f"{prefix}{short_err}, retrying"
+                        f" {attempt + 1}/{retries} ...",
+                        file=sys.stderr,
+                    )
+                    if hasattr(self, "tearDown"):
+                        self.tearDown()
+                    if hasattr(self, "teardown_method"):
+                        self.teardown_method()
+                    if hasattr(self, "setUp"):
+                        self.setUp()
+                    if hasattr(self, "setup_method"):
+                        self.setup_method()
+
+            raise err
+
+        return wrapper
+
+    # allow bare `@retry_on_failure`
+    if callable(retries):
+        return retry_on_failure()(retries)
+    assert retries > 1, retries
+    return decorator
+
+
+def skip_on_access_denied(only_if: "bool | typing.Callable | None" = None):
+    """Decorator to Ignore AccessDenied exceptions."""
+
+    def decorator(fun):
+        @functools.wraps(fun)
+        def wrapper(*args, **kwargs):
+            try:
+                return fun(*args, **kwargs)
+            except psutil.AccessDenied:
+                if only_if is not None:
+                    if not only_if:
+                        raise
+                return pytest.skip("raises AccessDenied")
+
+        return wrapper
+
+    if callable(only_if):
+        return skip_on_access_denied()(only_if)
+    return decorator
+
+
+def skip_on_not_implemented(only_if: "bool | typing.Callable | None" = None):
+    """Decorator to Ignore NotImplementedError exceptions."""
+
+    def decorator(fun):
+        @functools.wraps(fun)
+        def wrapper(*args, **kwargs):
+            try:
+                return fun(*args, **kwargs)
+            except NotImplementedError:
+                if only_if is not None:
+                    if not only_if:
+                        raise
+                msg = (
+                    f"{fun.__name__!r} was skipped because it raised"
+                    " NotImplementedError"
+                )
+                return pytest.skip(msg)
+
+        return wrapper
+
+    if callable(only_if):
+        return skip_on_not_implemented()(only_if)
+    return decorator
+
+
+# ===================================================================
+# --- network
+# ===================================================================
+
+
+# XXX: no longer used
+def get_free_port(host='127.0.0.1'):
+    """Return an unused TCP port. Subject to race conditions."""
+    with socket.socket() as sock:
+        sock.bind((host, 0))
+        return sock.getsockname()[1]
+
+
+def bind_socket(family=AF_INET, type=SOCK_STREAM, addr=None):
+    """Binds a generic socket."""
+    if addr is None and family in {AF_INET, AF_INET6}:
+        addr = ("", 0)
+    sock = socket.socket(family, type)
+    try:
+        if os.name not in {'nt', 'cygwin'}:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind(addr)
+        if type == socket.SOCK_STREAM:
+            sock.listen(5)
+        return sock
+    except Exception:
+        sock.close()
+        raise
+
+
+def bind_unix_socket(name, type=socket.SOCK_STREAM):
+    """Bind a UNIX socket."""
+    assert psutil.POSIX
+    assert not os.path.exists(name), name
+    sock = socket.socket(socket.AF_UNIX, type)
+    try:
+        sock.bind(name)
+        if type == socket.SOCK_STREAM:
+            sock.listen(5)
+    except Exception:
+        sock.close()
+        raise
+    return sock
+
+
+def tcp_socketpair(family, addr=("", 0)):
+    """Build a pair of TCP sockets connected to each other.
+    Return a (server, client) tuple.
+    """
+    with socket.create_server(addr, family=family, backlog=5) as ll:
+        ll.settimeout(GLOBAL_TIMEOUT)
+        addr = ll.getsockname()
+        c = socket.socket(family, SOCK_STREAM)
+        try:
+            c.connect(addr)
+            caddr = c.getsockname()
+            while True:
+                a, addr = ll.accept()
+                # check that we've got the correct client
+                if addr == caddr:
+                    return (a, c)
+                a.close()
+        except OSError:
+            c.close()
+            raise
+
+
+def unix_socketpair(name):
+    """Build a pair of UNIX sockets connected to each other through
+    the same UNIX file name.
+    Return a (server, client) tuple.
+    """
+    assert psutil.POSIX
+    server = client = None
+    try:
+        server = bind_unix_socket(name, type=socket.SOCK_STREAM)
+        server.setblocking(0)
+        client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        client.setblocking(0)
+        client.connect(name)
+        # new = server.accept()
+    except Exception:
+        if server is not None:
+            server.close()
+        if client is not None:
+            client.close()
+        raise
+    return (server, client)
+
+
+@contextlib.contextmanager
+def create_sockets():
+    """Open as many socket families / types as possible."""
+    socks = []
+    fname1 = fname2 = None
+    try:
+        socks.extend((
+            bind_socket(socket.AF_INET, socket.SOCK_STREAM),
+            bind_socket(socket.AF_INET, socket.SOCK_DGRAM),
+        ))
+        if supports_ipv6():
+            socks.extend((
+                bind_socket(socket.AF_INET6, socket.SOCK_STREAM),
+                bind_socket(socket.AF_INET6, socket.SOCK_DGRAM),
+            ))
+        if POSIX and HAS_NET_CONNECTIONS_UNIX:
+            fname1 = get_testfn()
+            fname2 = get_testfn()
+            s1, s2 = unix_socketpair(fname1)
+            s3 = bind_unix_socket(fname2, type=socket.SOCK_DGRAM)
+            for s in (s1, s2, s3):
+                socks.append(s)
+        yield socks
+    finally:
+        for s in socks:
+            s.close()
+        for fname in (fname1, fname2):
+            if fname is not None:
+                safe_rmpath(fname)
+
+
+def check_net_address(addr, family):
+    """Check a net address validity. Supported families are IPv4,
+    IPv6 and MAC addresses.
+    """
+    assert isinstance(family, enum.IntEnum), family
+    if family == socket.AF_INET:
+        octs = [int(x) for x in addr.split('.')]
+        assert len(octs) == 4, addr
+        for num in octs:
+            assert 0 <= num <= 255, addr
+        ipaddress.IPv4Address(addr)
+    elif family == socket.AF_INET6:
+        assert isinstance(addr, str), addr
+        ipaddress.IPv6Address(addr)
+    elif family == psutil.AF_LINK:
+        assert re.match(r'([a-fA-F0-9]{2}[:|\-]?){6}', addr) is not None, addr
+    else:
+        raise ValueError(f"unknown family {family!r}")
+
+
+def check_connection_ntuple(conn):
+    """Check validity of a connection named tuple."""
+
+    def check_ntuple(conn):
+        has_pid = len(conn) == 7
+        assert len(conn) in {6, 7}, len(conn)
+        assert conn[0] == conn.fd, conn.fd
+        assert conn[1] == conn.family, conn.family
+        assert conn[2] == conn.type, conn.type
+        assert conn[3] == conn.laddr, conn.laddr
+        assert conn[4] == conn.raddr, conn.raddr
+        assert conn[5] == conn.status, conn.status
+        if has_pid:
+            assert conn[6] == conn.pid, conn.pid
+
+    def check_family(conn):
+        assert conn.family in {AF_INET, AF_INET6, AF_UNIX}, conn.family
+        assert isinstance(conn.family, enum.IntEnum), conn
+        if conn.family == AF_INET:
+            # actually try to bind the local socket; ignore IPv6
+            # sockets as their address might be represented as
+            # an IPv4-mapped-address (e.g. "::127.0.0.1")
+            # and that's rejected by bind()
+            with socket.socket(conn.family, conn.type) as s:
+                try:
+                    s.bind((conn.laddr[0], 0))
+                except OSError as err:
+                    if err.errno != errno.EADDRNOTAVAIL:
+                        raise
+        elif conn.family == AF_UNIX:
+            assert conn.status == psutil.CONN_NONE, conn.status
+
+    def check_type(conn):
+        # SOCK_SEQPACKET may happen in case of AF_UNIX socks
+        SOCK_SEQPACKET = getattr(socket, "SOCK_SEQPACKET", object())
+        assert conn.type in {
+            socket.SOCK_STREAM,
+            socket.SOCK_DGRAM,
+            SOCK_SEQPACKET,
+        }, conn.type
+        assert isinstance(conn.type, enum.IntEnum), conn
+        if conn.type == socket.SOCK_DGRAM:
+            assert conn.status == psutil.CONN_NONE, conn.status
+
+    def check_addrs(conn):
+        # check IP address and port sanity
+        for addr in (conn.laddr, conn.raddr):
+            if conn.family in {AF_INET, AF_INET6}:
+                assert isinstance(addr, tuple), type(addr)
+                if not addr:
+                    continue
+                assert isinstance(addr.port, int), type(addr.port)
+                assert 0 <= addr.port <= 65535, addr.port
+                check_net_address(addr.ip, conn.family)
+            elif conn.family == AF_UNIX:
+                assert isinstance(addr, str), type(addr)
+
+    def check_status(conn):
+        assert isinstance(conn.status, str), conn.status
+        valids = [
+            getattr(psutil, x) for x in dir(psutil) if x.startswith('CONN_')
+        ]
+        assert conn.status in valids, conn.status
+        if conn.family in {AF_INET, AF_INET6} and conn.type == SOCK_STREAM:
+            assert conn.status != psutil.CONN_NONE, conn.status
+        else:
+            assert conn.status == psutil.CONN_NONE, conn.status
+
+    check_ntuple_type_hints(conn)
+    check_ntuple(conn)
+    check_family(conn)
+    check_type(conn)
+    check_addrs(conn)
+    check_status(conn)
+
+
+def filter_proc_net_connections(cons):
+    """Our process may start with some open UNIX sockets which are not
+    initialized by us, invalidating unit tests.
+    """
+    new = []
+    for conn in cons:
+        if POSIX and conn.family == socket.AF_UNIX:
+            if MACOS and "/syslog" in conn.raddr:
+                debug(f"skipping {conn}")
+                continue
+        new.append(conn)
+    return new
+
+
+# =====================================================================
+# --- type hints
+# =====================================================================
+
+
+class TypeHintsChecker:
+    try:
+        UNION_TYPES = (typing.Union, types.UnionType)
+    except AttributeError:  # Python < 3.10
+        UNION_TYPES = (typing.Union,)
+
+    @staticmethod
+    @functools.lru_cache(maxsize=None)
+    def _get_ntuple_hints(nt):
+        cls = type(nt)
+        try:
+            localns = {
+                name: obj
+                for name, obj in vars(_enums).items()
+                if isinstance(obj, type) and issubclass(obj, enum.Enum)
+            }
+            localns['socket'] = socket
+            return typing.get_type_hints(
+                cls,
+                globalns=vars(ntuples),
+                localns=localns,
+            )
+        except TypeError:
+            # Python < 3.10 can't evaluate "X | Y" union syntax.
+            return {}
+
+    @staticmethod
+    def _hint_to_types(hint):
+        """Flatten a type hint into a tuple of concrete types suitable
+        for isinstance(). Returns None if the hint cannot be checked.
+        """
+        origin = typing.get_origin(hint)
+        if origin in TypeHintsChecker.UNION_TYPES:
+            result = []
+            for arg in typing.get_args(hint):
+                inner = typing.get_origin(arg)
+                if inner is not None:
+                    result.append(inner)
+                elif isinstance(arg, type):
+                    result.append(arg)
+            return tuple(result) if result else None
+        if origin is not None:
+            return (origin,)
+        if isinstance(hint, type):
+            return (hint,)
+        return None
+
+    @staticmethod
+    def check_ntuple_type_hints(nt):
+        """Uses type hints from _ntuples.py to verify field types. `nt`
+        is a named tuple returned by one of psutil APIs.
+        """
+        assert is_namedtuple(nt)
+        hints = TypeHintsChecker._get_ntuple_hints(nt)
+        if not hints:
+            return
+        for field in nt._fields:
+            if field not in hints:
+                # field is not annotated
+                continue
+            value = getattr(nt, field)
+            types_ = TypeHintsChecker._hint_to_types(hints[field])
+            if types_ is None:
+                continue
+            # For IntEnum hints (e.g. socket.AddressFamily), psutil may
+            # return a platform-specific IntEnum subclass rather than
+            # the annotated one, so we broaden the check to int.
+            types_ = tuple(
+                (
+                    int
+                    if isinstance(t, type) and issubclass(t, enum.IntEnum)
+                    else t
+                )
+                for t in types_
+            )
+            assert isinstance(value, types_), (field, value, types_)
+
+    @staticmethod
+    @functools.lru_cache(maxsize=None)
+    def _get_return_hint(fun):
+        """Get the 'return' type hint for a psutil API function or
+        method. Resolves annotation strings using a combined namespace
+        of psutil globals (Any, Generator, Process, ...) and ntuple
+        types (scputimes, svmem, pmem, ...). Returns None if hints
+        cannot be resolved or there is no return annotation.
+        """
+        while hasattr(fun, 'func'):
+            fun = fun.func
+        # Build a namespace that can resolve all annotations.
+        psp = vars(psutil).get('_psplatform')
+        psp_ns = vars(psp) if psp is not None else {}
+        ns = {
+            **psp_ns,
+            **vars(psutil),
+            **vars(ntuples),
+            **vars(typing),
+        }
+        underlying = getattr(fun, '__func__', fun)
+        try:
+            hints = typing.get_type_hints(underlying, globalns=ns)
+        except TypeError:
+            # X | Y union syntax in annotations requires Python 3.10+
+            # to evaluate. On older versions skip the check entirely.
+            if sys.version_info < (3, 10):
+                msg = f"skip X|Y type check on old python for {fun.__name__!r}"
+                warn(msg)
+                return None
+            else:
+                raise
+        return hints.get('return')
+
+    @staticmethod
+    def _check_container_items(hint, value):
+        """For list[T] and dict[K, V] hints, verify element types."""
+        origin = typing.get_origin(hint)
+        args = typing.get_args(hint)
+        if origin is list and args:
+            elem_types = TypeHintsChecker._hint_to_types(args[0])
+            if elem_types:
+                for item in value:
+                    assert isinstance(item, elem_types), (item, elem_types)
+        elif origin is dict and len(args) == 2:
+            key_types = TypeHintsChecker._hint_to_types(args[0])
+            val_types = TypeHintsChecker._hint_to_types(args[1])
+            for k, v in value.items():
+                if key_types:
+                    assert isinstance(k, key_types), (k, key_types)
+                if val_types:
+                    assert isinstance(v, val_types), (v, val_types)
+
+    @staticmethod
+    def check_fun_type_hints(fun, retval):
+        """Use the 'return' type hint of *fun* from psutil/__init__.py
+        to verify that *retval* is an instance of the annotated type.
+        """
+        hint = TypeHintsChecker._get_return_hint(fun)
+        if hint is None:
+            if not hasattr(types, "UnionType"):
+                # added in python 3.10
+                return
+            raise ValueError(f"no type hints defined for {fun}")
+        types_ = TypeHintsChecker._hint_to_types(hint)
+        assert types_, hint
+        assert isinstance(retval, types_), (fun, retval, types_)
+        TypeHintsChecker._check_container_items(hint, retval)
+
+
+check_ntuple_type_hints = TypeHintsChecker.check_ntuple_type_hints
+check_fun_type_hints = TypeHintsChecker.check_fun_type_hints
+
+
+# ===================================================================
+# --- import utils
+# ===================================================================
+
+
+def reload_module(module):
+    return importlib.reload(module)
+
+
+def import_module_by_path(path):
+    name = os.path.splitext(os.path.basename(path))[0]
+    spec = importlib.util.spec_from_file_location(name, path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+# ===================================================================
+# --- others
+# ===================================================================
+
+
+def warn(msg):
+    """Raise a warning msg."""
+    warnings.warn(msg, UserWarning, stacklevel=2)
+
+
+def is_namedtuple(x):
+    """Check if object is an instance of named tuple."""
+    t = type(x)
+    if tuple not in t.__mro__:
+        return False
+    f = getattr(t, '_fields', None)
+    if not isinstance(f, tuple):
+        return False
+    return all(isinstance(n, str) for n in f)
+
+
+if POSIX:
+
+    @contextlib.contextmanager
+    def copyload_shared_lib(suffix=""):
+        """Ctx manager which picks up a random shared CO lib used
+        by this process, copies it in another location and loads it
+        in memory via ctypes. Return the new absolutized path.
+        """
+        exe = 'pypy' if PYPY else 'python'
+        ext = ".so"
+        dst = get_testfn(suffix=suffix + ext)
+        libs = [
+            x.path
+            for x in psutil.Process().memory_maps()
+            if os.path.splitext(x.path)[1] == ext and exe in x.path.lower()
+        ]
+        src = random.choice(libs)
+        shutil.copyfile(src, dst)
+        try:
+            ctypes.CDLL(dst)
+            yield dst
+        finally:
+            safe_rmpath(dst)
+
+else:
+
+    @contextlib.contextmanager
+    def copyload_shared_lib(suffix=""):
+        """Ctx manager which picks up a random shared DLL lib used
+        by this process, copies it in another location and loads it
+        in memory via ctypes.
+        Return the new absolutized, normcased path.
+        """
+        from ctypes import WinError
+        from ctypes import wintypes
+
+        ext = ".dll"
+        dst = get_testfn(suffix=suffix + ext)
+        libs = [
+            x.path
+            for x in psutil.Process().memory_maps()
+            if x.path.lower().endswith(ext)
+            and 'python' in os.path.basename(x.path).lower()
+        ]
+        if PYPY and not libs:
+            libs = [
+                x.path
+                for x in psutil.Process().memory_maps()
+                if 'pypy' in os.path.basename(x.path).lower()
+            ]
+        src = random.choice(libs)
+        shutil.copyfile(src, dst)
+        cfile = None
+        try:
+            cfile = ctypes.WinDLL(dst)
+            yield dst
+        finally:
+            # Work around OverflowError:
+            # - https://ci.appveyor.com/project/giampaolo/psutil/build/1207/
+            #       job/o53330pbnri9bcw7
+            # - http://bugs.python.org/issue30286
+            # - http://stackoverflow.com/questions/23522055
+            if cfile is not None:
+                FreeLibrary = ctypes.windll.kernel32.FreeLibrary
+                FreeLibrary.argtypes = [wintypes.HMODULE]
+                ret = FreeLibrary(cfile._handle)
+                if ret == 0:
+                    raise WinError()
+            safe_rmpath(dst)
+
+
+# ===================================================================
+# --- Exit funs (first is executed last)
+# ===================================================================
+
+
+# this is executed first
+@atexit.register
+def cleanup_test_procs():
+    reap_children(recursive=True)
+
+
+# atexit module does not execute exit functions in case of SIGTERM, which
+# gets sent to test subprocesses, which is a problem if they import this
+# module. With this it will. See:
+# https://gmpy.dev/blog/2016/how-to-always-execute-exit-functions-in-python
+if POSIX:
+    signal.signal(signal.SIGTERM, lambda sig, _: sys.exit(sig))
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000000..e19aaa7303
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,65 @@
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Pytest hooks."""
+
+import warnings
+
+import pytest
+
+# Activate pytest hooks defined in test_process_all.py.
+from .test_process_all import pytest_runtest_makereport  # noqa: F401
+from .test_process_all import pytest_terminal_summary  # noqa: F401
+
+
+def _escape_surrogates(text):
+    try:
+        text.encode("utf-8")
+    except UnicodeEncodeError:
+        return text.encode("utf-8", "backslashreplace").decode("utf-8")
+    else:
+        return text
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_runtest_logreport(report):
+    """Escape the non-UTF8 paths used by test_unicode.py when a test
+    fails. If one of them ends up in a report, xdist can't send it to
+    the master process, and the whole run dies.
+    """
+    if isinstance(report.longrepr, tuple):
+        path, lineno, reason = report.longrepr
+        report.longrepr = (path, lineno, _escape_surrogates(reason))
+    elif report.longrepr is not None:
+        text = str(report.longrepr)
+        escaped = _escape_surrogates(text)
+        if escaped != text:
+            report.longrepr = escaped
+    report.sections = [
+        (name, _escape_surrogates(content))
+        for name, content in report.sections
+    ]
+
+
+# Monkey patch pytest-instafail so that we ALSO get the full
+# traceback/failure summary at the end of the run, see:
+# https://github.com/pytest-dev/pytest-instafail/issues/21.
+try:
+    import pytest_instafail
+    from _pytest.terminal import TerminalReporter
+
+    pytest_instafail.InstafailingTerminalReporter  # noqa: B018
+except (ImportError, AttributeError):
+    warnings.warn(
+        "failed to monkey patch pytest-instafail",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
+else:
+    pytest_instafail.InstafailingTerminalReporter.summary_failures = (
+        TerminalReporter.summary_failures
+    )
+    pytest_instafail.InstafailingTerminalReporter.summary_errors = (
+        TerminalReporter.summary_errors
+    )
diff --git a/tests/test_aix.py b/tests/test_aix.py
new file mode 100755
index 0000000000..6d9c72f585
--- /dev/null
+++ b/tests/test_aix.py
@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'
+# Copyright (c) 2017, Arnon Yaari
+# All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""AIX specific tests."""
+
+import re
+
+import psutil
+from psutil import AIX
+
+from . import PsutilTestCase
+from . import sh
+from . import skipif
+
+
+@skipif(not AIX, reason="AIX only")
+class AIXSpecificTestCase(PsutilTestCase):
+    def test_virtual_memory(self):
+        out = sh('/usr/bin/svmon -O unit=KB')
+        re_pattern = r"memory\s*"
+        for field in [
+            "size",
+            "inuse",
+            "free",
+            "pin",
+            "virtual",
+            "available",
+            "mmode",
+        ]:
+            re_pattern += rf"(?P<{field}>\S+)\s+"
+        matchobj = re.search(re_pattern, out)
+
+        assert matchobj is not None
+
+        KB = 1024
+        total = int(matchobj.group("size")) * KB
+        available = int(matchobj.group("available")) * KB
+        used = int(matchobj.group("inuse")) * KB
+        free = int(matchobj.group("free")) * KB
+
+        psutil_result = psutil.virtual_memory()
+
+        # TOLERANCE_SYS_MEM is not enough. For some reason we're seeing
+        # differences of ~1.2 MB. 2 MB is still a good tolerance when
+        # compared to GBs.
+        TOLERANCE_SYS_MEM = 2 * KB * KB  # 2 MB
+        assert psutil_result.total == total
+        assert abs(psutil_result.used - used) < TOLERANCE_SYS_MEM
+        assert abs(psutil_result.available - available) < TOLERANCE_SYS_MEM
+        assert abs(psutil_result.free - free) < TOLERANCE_SYS_MEM
+
+    def test_swap_memory(self):
+        out = sh('/usr/sbin/lsps -a')
+        # From the man page, "The size is given in megabytes" so we assume
+        # we'll always have 'MB' in the result
+        # TODO maybe try to use "swap -l" to check "used" too, but its units
+        # are not guaranteed to be "MB" so parsing may not be consistent
+        matchobj = re.search(
+            r"(?P<space>\S+)\s+"
+            r"(?P<vol>\S+)\s+"
+            r"(?P<vg>\S+)\s+"
+            r"(?P<size>\d+)MB",
+            out,
+        )
+
+        assert matchobj is not None
+
+        total_mb = int(matchobj.group("size"))
+        MB = 1024**2
+        psutil_result = psutil.swap_memory()
+        # we divide our result by MB instead of multiplying the lsps value by
+        # MB because lsps may round down, so we round down too
+        assert int(psutil_result.total / MB) == total_mb
+
+    def test_cpu_stats(self):
+        out = sh('/usr/bin/mpstat -a')
+
+        re_pattern = r"ALL\s*"
+        for field in [
+            "min",
+            "maj",
+            "mpcs",
+            "mpcr",
+            "dev",
+            "soft",
+            "dec",
+            "ph",
+            "cs",
+            "ics",
+            "bound",
+            "rq",
+            "push",
+            "S3pull",
+            "S3grd",
+            "S0rd",
+            "S1rd",
+            "S2rd",
+            "S3rd",
+            "S4rd",
+            "S5rd",
+            "sysc",
+        ]:
+            re_pattern += rf"(?P<{field}>\S+)\s+"
+        matchobj = re.search(re_pattern, out)
+
+        assert matchobj is not None
+
+        # numbers are usually in the millions so 1000 is ok for tolerance
+        CPU_STATS_TOLERANCE = 1000
+        psutil_result = psutil.cpu_stats()
+        assert (
+            abs(psutil_result.ctx_switches - int(matchobj.group("cs")))
+            < CPU_STATS_TOLERANCE
+        )
+        assert (
+            abs(psutil_result.syscalls - int(matchobj.group("sysc")))
+            < CPU_STATS_TOLERANCE
+        )
+        assert (
+            abs(psutil_result.interrupts - int(matchobj.group("dev")))
+            < CPU_STATS_TOLERANCE
+        )
+        assert (
+            abs(psutil_result.soft_interrupts - int(matchobj.group("soft")))
+            < CPU_STATS_TOLERANCE
+        )
+
+    def test_cpu_count_logical(self):
+        out = sh('/usr/bin/mpstat -a')
+        mpstat_lcpu = int(re.search(r"lcpu=(\d+)", out).group(1))
+        psutil_lcpu = psutil.cpu_count(logical=True)
+        assert mpstat_lcpu == psutil_lcpu
+
+    def test_net_if_addrs_names(self):
+        out = sh('/etc/ifconfig -l')
+        ifconfig_names = set(out.split())
+        psutil_names = set(psutil.net_if_addrs().keys())
+        assert ifconfig_names == psutil_names
diff --git a/tests/test_bsd.py b/tests/test_bsd.py
new file mode 100755
index 0000000000..a83057ca9e
--- /dev/null
+++ b/tests/test_bsd.py
@@ -0,0 +1,656 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# TODO: (FreeBSD) add test for comparing connections with 'sockstat' cmd.
+
+
+"""Tests specific to all BSD platforms."""
+
+import datetime
+import os
+import re
+import time
+from unittest import mock
+
+import psutil
+from psutil import BSD
+from psutil import FREEBSD
+from psutil import NETBSD
+from psutil import OPENBSD
+from psutil import _psutil
+
+from . import HAS_BATTERY
+from . import TOLERANCE_SYS_MEM
+from . import PsutilTestCase
+from . import isolated
+from . import pytest
+from . import requires_cli
+from . import retry_on_failure
+from . import sh
+from . import skipif
+from . import spawn_subproc
+from . import terminate
+
+PAGESIZE = _psutil.getpagesize() if BSD else None
+
+
+def sysctl(cmdline):
+    """Expects a sysctl command with an argument and parse the result
+    returning only the value of interest.
+    """
+    result = sh("sysctl " + cmdline)
+    if FREEBSD:
+        result = result[result.find(": ") + 2 :]
+    elif OPENBSD or NETBSD:
+        result = result[result.find("=") + 1 :]
+    try:
+        return int(result)
+    except ValueError:
+        return result
+
+
+# =====================================================================
+# --- All BSD*
+# =====================================================================
+
+
+@skipif(not BSD, reason="BSD only")
+class TestSystemAPIs(PsutilTestCase):
+    """System tests common to all BSD variants."""
+
+    def test_disks(self):
+        # test psutil.disk_usage() and psutil.disk_partitions()
+        # against "df -a"
+        def df(path):
+            out = sh(f'df -k "{path}"').strip()
+            lines = out.split('\n')
+            lines.pop(0)
+            line = lines.pop(0)
+            dev, total, used, free = line.split()[:4]
+            if dev == 'none':
+                dev = ''
+            total = int(total) * 1024
+            used = int(used) * 1024
+            free = int(free) * 1024
+            return dev, total, used, free
+
+        for part in psutil.disk_partitions(all=False):
+            usage = psutil.disk_usage(part.mountpoint)
+            dev, total, used, free = df(part.mountpoint)
+            assert part.device == dev
+            assert usage.total == total
+            # 10 MB tolerance
+            if abs(usage.free - free) > 10 * 1024 * 1024:
+                return pytest.fail(f"psutil={usage.free}, df={free}")
+            if abs(usage.used - used) > 10 * 1024 * 1024:
+                return pytest.fail(f"psutil={usage.used}, df={used}")
+
+    @requires_cli("sysctl")
+    def test_cpu_count_logical(self):
+        syst = sysctl("hw.ncpu")
+        assert psutil.cpu_count(logical=True) == syst
+
+    # On NetBSD total is UVM's managed pages, which is less than
+    # physical RAM. NetBSDTestCase.test_vmem_total covers it instead.
+    @requires_cli("sysctl")
+    @skipif(NETBSD, reason="hw.physmem is not what psutil reports")
+    def test_virtual_memory_total(self):
+        num = sysctl('hw.physmem')
+        assert num == psutil.virtual_memory().total
+
+    @requires_cli("ifconfig")
+    def test_net_if_stats(self):
+        for name, stats in psutil.net_if_stats().items():
+            try:
+                out = sh(f"ifconfig {name}")
+            except RuntimeError:
+                pass
+            else:
+                assert stats.isup == ('RUNNING' in out)
+                if "mtu" in out:
+                    assert stats.mtu == int(re.findall(r'mtu (\d+)', out)[0])
+
+
+@skipif(not BSD, reason="BSD only")
+class TestProcessAPIs(PsutilTestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.pid = spawn_subproc().pid
+
+    @classmethod
+    def tearDownClass(cls):
+        terminate(cls.pid)
+
+    @skipif(NETBSD, reason="-o lstart doesn't work on NETBSD")
+    def test_create_time(self):
+        output = sh(f"ps -o lstart -p {self.pid}")
+        start_ps = output.replace('STARTED', '').strip()
+        start_psutil = psutil.Process(self.pid).create_time()
+        start_psutil = time.strftime(
+            "%a %b %e %H:%M:%S %Y", time.localtime(start_psutil)
+        )
+        assert start_ps == start_psutil
+
+    def test_environ_zombie(self):
+        _parent, zombie = self.spawn_zombie()
+        with pytest.raises(psutil.ZombieProcess):
+            zombie.environ()
+
+
+@skipif(not BSD, reason="BSD only")
+class TestVmstat(PsutilTestCase):
+
+    @staticmethod
+    def vmstat(labels):
+        out = sh(["vmstat", "-s"], env={"LANG": "C.UTF-8"})
+        for line in out.split("\n"):
+            line = line.strip()
+            num, _, what = line.partition(" ")
+            for label in labels:
+                if label == what:
+                    return int(num)
+        return pytest.skip(f"can't find {labels} in vmstat output")
+
+    # --- virtual_memory()
+
+    def test_vmem_free(self):
+        vmstat_value = self.vmstat(['pages free']) * PAGESIZE
+        psutil_value = psutil.virtual_memory().free
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    def test_vmem_active(self):
+        vmstat_value = self.vmstat(['pages active']) * PAGESIZE
+        psutil_value = psutil.virtual_memory().active
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    def test_vmem_inactive(self):
+        vmstat_value = self.vmstat(['pages inactive']) * PAGESIZE
+        psutil_value = psutil.virtual_memory().inactive
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    def test_vmem_cached(self):
+        # NetBSD / OpenBSD
+        vmstat_value = (
+            self.vmstat(['cached file pages'])
+            + self.vmstat(['cached executable pages'])
+        ) * PAGESIZE
+        psutil_value = psutil.virtual_memory().cached
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    def test_vmem_wired(self):
+        vmstat_value = (
+            self.vmstat(['pages wired', 'pages wired down']) * PAGESIZE
+        )
+        psutil_value = psutil.virtual_memory().wired
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @skipif(not (OPENBSD or NETBSD), reason="NETBSD / OPENBSD only")
+    def test_vmem_shared(self):
+        out = sh("vmstat -t")
+        if "vm-sh" not in out:
+            return pytest.skip("can't find 'vm-sh' in vmstat output")
+        lines = out.splitlines()
+        headers = lines[1].split()
+        values = lines[2].split()
+        row = dict(zip(headers, values))
+        expected = int(row["vm-sh"]) * PAGESIZE
+        assert (
+            abs(psutil.virtual_memory().shared - expected) < TOLERANCE_SYS_MEM
+        )
+
+    # --- swap_memory()
+
+    def test_swap_total(self):
+        vmstat_value = self.vmstat(['swap pages']) * PAGESIZE
+        psutil_value = psutil.swap_memory().total
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    def test_swap_used(self):
+        vmstat_value = self.vmstat(['swap pages in use']) * PAGESIZE
+        psutil_value = psutil.swap_memory().used
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    def test_swap_sin(self):
+        vmstat_value = self.vmstat(['pages swapped in']) * PAGESIZE
+        psutil_value = psutil.swap_memory().sin
+        assert abs(vmstat_value - psutil_value) < 1024
+
+    def test_swap_sout(self):
+        vmstat_value = self.vmstat(['pages swapped oud']) * PAGESIZE
+        psutil_value = psutil.swap_memory().sout
+        assert abs(vmstat_value - psutil_value) < 1024
+
+    # --- cpu_stats()
+
+    @isolated
+    @retry_on_failure
+    def test_cpu_stats_interrupts(self):
+        vmstat_value = self.vmstat(['device interrupts', 'interrupts'])
+        psutil_value = psutil.cpu_stats().interrupts
+        assert abs(vmstat_value - psutil_value) <= 100
+
+    @isolated
+    @retry_on_failure
+    def test_cpu_stats_soft_interrupts(self):
+        vmstat_value = self.vmstat(['software interrupts'])
+        psutil_value = psutil.cpu_stats().soft_interrupts
+        assert abs(vmstat_value - psutil_value) <= 100
+
+    @isolated
+    @retry_on_failure
+    def test_cpu_stats_syscalls(self):
+        vmstat_value = self.vmstat(['system calls', 'syscalls'])
+        psutil_value = psutil.cpu_stats().syscalls
+        assert abs(vmstat_value - psutil_value) <= 100
+
+    @isolated
+    @retry_on_failure
+    def test_cpu_stats_ctx_switches(self):
+        vmstat_value = self.vmstat(['cpu context switches'])
+        psutil_value = psutil.cpu_stats().ctx_switches
+        assert abs(vmstat_value - psutil_value) <= 100
+
+
+# =====================================================================
+# --- FreeBSD
+# =====================================================================
+
+
+@skipif(not FREEBSD, reason="FREEBSD only")
+class FreeBSDProcessTestCase(PsutilTestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.pid = spawn_subproc().pid
+
+    @classmethod
+    def tearDownClass(cls):
+        terminate(cls.pid)
+
+    @retry_on_failure
+    def test_memory_maps(self):
+        out = sh(f"procstat -v {self.pid}")
+        maps = psutil.Process(self.pid).memory_maps(grouped=False)
+        lines = out.split('\n')[1:]
+        while lines:
+            line = lines.pop()
+            fields = line.split()
+            _, start, stop, _perms, res = fields[:5]
+            map = maps.pop()
+            assert f"{start}-{stop}" == map.addr
+            assert int(res) * PAGESIZE == map.rss
+            if not map.path.startswith('['):
+                assert fields[10] == map.path
+
+    def test_exe(self):
+        out = sh(f"procstat -b {self.pid}")
+        assert psutil.Process(self.pid).exe() == out.split('\n')[1].split()[-1]
+
+    def test_cmdline(self):
+        out = sh(f"procstat -c {self.pid}")
+        assert ' '.join(psutil.Process(self.pid).cmdline()) == ' '.join(
+            out.split('\n')[1].split()[2:]
+        )
+
+    def test_uids_gids(self):
+        out = sh(f"procstat -s {self.pid}")
+        euid, ruid, suid, egid, rgid, sgid = out.split('\n')[1].split()[2:8]
+        p = psutil.Process(self.pid)
+        uids = p.uids()
+        gids = p.gids()
+        assert uids.real == int(ruid)
+        assert uids.effective == int(euid)
+        assert uids.saved == int(suid)
+        assert gids.real == int(rgid)
+        assert gids.effective == int(egid)
+        assert gids.saved == int(sgid)
+
+    @retry_on_failure
+    def test_ctx_switches(self):
+        tested = []
+        out = sh(f"procstat -r {self.pid}")
+        p = psutil.Process(self.pid)
+        for line in out.split('\n'):
+            line = line.lower().strip()
+            if ' voluntary context' in line:
+                pstat_value = int(line.split()[-1])
+                psutil_value = p.num_ctx_switches().voluntary
+                assert pstat_value == psutil_value
+                tested.append(None)
+            elif ' involuntary context' in line:
+                pstat_value = int(line.split()[-1])
+                psutil_value = p.num_ctx_switches().involuntary
+                assert pstat_value == psutil_value
+                tested.append(None)
+        if len(tested) != 2:
+            raise RuntimeError("couldn't find lines match in procstat out")
+
+    @retry_on_failure
+    def test_cpu_times(self):
+        tested = []
+        out = sh(f"procstat -r {self.pid}")
+        p = psutil.Process(self.pid)
+        for line in out.split('\n'):
+            line = line.lower().strip()
+            if 'user time' in line:
+                pstat_value = float('0.' + line.split()[-1].split('.')[-1])
+                psutil_value = p.cpu_times().user
+                assert pstat_value == psutil_value
+                tested.append(None)
+            elif 'system time' in line:
+                pstat_value = float('0.' + line.split()[-1].split('.')[-1])
+                psutil_value = p.cpu_times().system
+                assert pstat_value == psutil_value
+                tested.append(None)
+        if len(tested) != 2:
+            raise RuntimeError("couldn't find lines match in procstat out")
+
+
+@skipif(not FREEBSD, reason="FREEBSD only")
+class FreeBSDSystemTestCase(PsutilTestCase):
+    @staticmethod
+    def parse_swapinfo():
+        # the last line is always the total
+        output = sh("swapinfo -k").splitlines()[-1]
+        parts = re.split(r'\s+', output)
+
+        if not parts:
+            raise ValueError(f"Can't parse swapinfo: {output}")
+
+        # the size is in 1k units, so multiply by 1024
+        total, used, free = (int(p) * 1024 for p in parts[1:4])
+        return total, used, free
+
+    def test_cpu_count_cores(self):
+        cores = sysctl("kern.smp.cores")
+        assert psutil.cpu_count(logical=False) == cores
+
+    @retry_on_failure
+    def test_cpu_times(self):
+        clk_tck = os.sysconf("SC_CLK_TCK")
+        ticks = [int(x) for x in sysctl("kern.cp_time").split()]
+        ct = psutil.cpu_times()
+        tolerance = 0.5
+        assert abs(ct.user - ticks[0] / clk_tck) < tolerance
+        assert abs(ct.nice - ticks[1] / clk_tck) < tolerance
+        assert abs(ct.system - ticks[2] / clk_tck) < tolerance
+        assert abs(ct.irq - ticks[3] / clk_tck) < tolerance
+        assert abs(ct.idle - ticks[4] / clk_tck) < tolerance
+
+    def test_cpu_frequency_against_sysctl(self):
+        # Currently only cpu 0 is frequency is supported in FreeBSD
+        # All other cores use the same frequency.
+        sensor = "dev.cpu.0.freq"
+        try:
+            sysctl_result = int(sysctl(sensor))
+        except RuntimeError:
+            return pytest.skip("frequencies not supported by kernel")
+        assert psutil.cpu_freq().current == sysctl_result
+
+        sensor = "dev.cpu.0.freq_levels"
+        sysctl_result = sysctl(sensor)
+        # sysctl returns a string of the format:
+        # <freq_level_1>/<voltage_level_1> <freq_level_2>/<voltage_level_2>...
+        # Ordered highest available to lowest available.
+        max_freq = int(sysctl_result.split()[0].split("/")[0])
+        min_freq = int(sysctl_result.split()[-1].split("/")[0])
+        assert psutil.cpu_freq().max == max_freq
+        assert psutil.cpu_freq().min == min_freq
+
+    def test_cpu_freq_no_levels(self):
+        # No freq_levels means we can't tell min / max. It used to
+        # raise NameError, or reuse the previous CPU's values.
+        with mock.patch.object(
+            _psutil, "cpu_freq", return_value=(100, "")
+        ) as m:
+            ret = psutil._psbsd.cpu_freq()
+            assert m.called
+        for nt in ret:
+            assert nt.current == 100
+            assert nt.min is None
+            assert nt.max is None
+
+    # --- virtual_memory(); tests against sysctl
+
+    @retry_on_failure
+    def test_vmem_active(self):
+        syst = sysctl("vm.stats.vm.v_active_count") * PAGESIZE
+        assert abs(psutil.virtual_memory().active - syst) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_vmem_inactive(self):
+        syst = sysctl("vm.stats.vm.v_inactive_count") * PAGESIZE
+        assert abs(psutil.virtual_memory().inactive - syst) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_vmem_wired(self):
+        syst = sysctl("vm.stats.vm.v_wire_count") * PAGESIZE
+        assert abs(psutil.virtual_memory().wired - syst) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_vmem_cached(self):
+        syst = sysctl("vm.stats.vm.v_cache_count") * PAGESIZE
+        assert abs(psutil.virtual_memory().cached - syst) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_vmem_free(self):
+        syst = sysctl("vm.stats.vm.v_free_count") * PAGESIZE
+        assert abs(psutil.virtual_memory().free - syst) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_vmem_buffers(self):
+        syst = sysctl("vfs.bufspace")
+        assert abs(psutil.virtual_memory().buffers - syst) < TOLERANCE_SYS_MEM
+
+    def test_cpu_stats_ctx_switches(self):
+        assert (
+            abs(
+                psutil.cpu_stats().ctx_switches
+                - sysctl('vm.stats.sys.v_swtch')
+            )
+            < 1000
+        )
+
+    def test_cpu_stats_interrupts(self):
+        assert (
+            abs(psutil.cpu_stats().interrupts - sysctl('vm.stats.sys.v_intr'))
+            < 1000
+        )
+
+    def test_cpu_stats_soft_interrupts(self):
+        assert (
+            abs(
+                psutil.cpu_stats().soft_interrupts
+                - sysctl('vm.stats.sys.v_soft')
+            )
+            < 1000
+        )
+
+    @retry_on_failure
+    def test_cpu_stats_syscalls(self):
+        # pretty high tolerance but it looks like it's OK.
+        assert (
+            abs(psutil.cpu_stats().syscalls - sysctl('vm.stats.sys.v_syscall'))
+            < 200000
+        )
+
+    # --- swap memory
+
+    def test_swapmem_free(self):
+        _total, _used, free = self.parse_swapinfo()
+        assert abs(psutil.swap_memory().free - free) < TOLERANCE_SYS_MEM
+
+    def test_swapmem_used(self):
+        _total, used, _free = self.parse_swapinfo()
+        assert abs(psutil.swap_memory().used - used) < TOLERANCE_SYS_MEM
+
+    def test_swapmem_total(self):
+        total, _used, _free = self.parse_swapinfo()
+        assert abs(psutil.swap_memory().total - total) < TOLERANCE_SYS_MEM
+
+    # --- net
+
+    @retry_on_failure
+    def test_net_io_counters(self):
+        out = sh("netstat -ib")
+        netstat = {}
+        for line in out.splitlines():
+            fields = line.split()
+            if len(fields) == 12 and "<Link#" in fields[2]:
+                name = fields[0]
+                netstat[name] = (int(fields[7]), int(fields[10]))
+        ps = psutil.net_io_counters(pernic=True)
+        tolerance = 1 * 1024 * 1024  # 1 MB
+        for name, (ibytes, obytes) in netstat.items():
+            if name not in ps:
+                continue
+            assert abs(ps[name].bytes_recv - ibytes) < tolerance
+            assert abs(ps[name].bytes_sent - obytes) < tolerance
+
+    # --- others
+
+    def test_boot_time(self):
+        s = sysctl('sysctl kern.boottime')
+        s = s[s.find(" sec = ") + 7 :]
+        s = s[: s.find(',')]
+        btime = int(s)
+        assert btime == psutil.boot_time()
+
+    # --- sensors_battery
+
+    @skipif(not HAS_BATTERY, reason="no battery")
+    def test_sensors_battery(self):
+        def secs2hours(secs):
+            m, _s = divmod(secs, 60)
+            h, m = divmod(m, 60)
+            return f"{int(h)}:{int(m):02}"
+
+        out = sh("acpiconf -i 0")
+        fields = {x.split('\t')[0]: x.split('\t')[-1] for x in out.split("\n")}
+        metrics = psutil.sensors_battery()
+        percent = int(fields['Remaining capacity:'].replace('%', ''))
+        remaining_time = fields['Remaining time:']
+        assert metrics.percent == percent
+        if remaining_time == 'unknown':
+            assert metrics.secsleft == psutil.POWER_TIME_UNLIMITED
+        else:
+            assert secs2hours(metrics.secsleft) == remaining_time
+
+    @skipif(not HAS_BATTERY, reason="no battery")
+    def test_sensors_battery_against_sysctl(self):
+        assert psutil.sensors_battery().percent == sysctl(
+            "hw.acpi.battery.life"
+        )
+        assert psutil.sensors_battery().power_plugged == (
+            sysctl("hw.acpi.acline") == 1
+        )
+        secsleft = psutil.sensors_battery().secsleft
+        if secsleft < 0:
+            assert sysctl("hw.acpi.battery.time") == -1
+        else:
+            assert secsleft == sysctl("hw.acpi.battery.time") * 60
+
+    @skipif(HAS_BATTERY, reason="has battery")
+    def test_sensors_battery_no_battery(self):
+        # If no battery is present one of these calls is supposed
+        # to fail, see:
+        # https://github.com/giampaolo/psutil/issues/1074
+        with pytest.raises(RuntimeError):
+            sysctl("hw.acpi.battery.life")
+            sysctl("hw.acpi.battery.time")
+            sysctl("hw.acpi.acline")
+        assert psutil.sensors_battery() is None
+
+    # --- sensors_temperatures
+
+    def test_sensors_temperatures_against_sysctl(self):
+        num_cpus = psutil.cpu_count(True)
+        for cpu in range(num_cpus):
+            sensor = f"dev.cpu.{cpu}.temperature"
+            # sysctl returns a string in the format 46.0C
+            try:
+                sysctl_result = int(float(sysctl(sensor)[:-1]))
+            except RuntimeError:
+                return pytest.skip("temperatures not supported by kernel")
+            assert (
+                abs(
+                    psutil.sensors_temperatures()["coretemp"][cpu].current
+                    - sysctl_result
+                )
+                < 10
+            )
+
+            sensor = f"dev.cpu.{cpu}.coretemp.tjmax"
+            sysctl_result = int(float(sysctl(sensor)[:-1]))
+            assert (
+                psutil.sensors_temperatures()["coretemp"][cpu].high
+                == sysctl_result
+            )
+
+
+# =====================================================================
+# --- OpenBSD
+# =====================================================================
+
+
+@skipif(not OPENBSD, reason="OPENBSD only")
+class OpenBSDSystemTestCase(PsutilTestCase):
+    def test_boot_time(self):
+        s = sysctl('kern.boottime')
+        sys_bt = datetime.datetime.strptime(s, "%a %b %d %H:%M:%S %Y")
+        psutil_bt = datetime.datetime.fromtimestamp(psutil.boot_time())
+        assert sys_bt == psutil_bt
+
+
+# =====================================================================
+# --- NetBSD
+# =====================================================================
+
+
+@skipif(not NETBSD, reason="NETBSD only")
+class NetBSDTestCase(PsutilTestCase):
+    @staticmethod
+    def parse_vmstat(look_for):
+        """Parse a cumulative field from 'vmstat -s' output.
+        Lines are formatted as: '<value> <description>'
+        Mirrors the same uvmexp_sysctl fields that psutil reads via
+        sysctl(CTL_VM, VM_UVMEXP2) in C, without requiring procfs.
+        """
+        out = sh("vmstat -s")
+        for line in out.splitlines():
+            line = line.strip()
+            if look_for in line:
+                return int(line.split()[0])
+        raise ValueError(f"can't find {look_for!r} in vmstat -s output")
+
+    # --- virtual mem
+
+    def test_vmem_total(self):
+        num = self.parse_vmstat("pages managed")
+        assert num * PAGESIZE == psutil.virtual_memory().total
+
+    @retry_on_failure
+    def test_vmem_buffers(self):
+        # uv.filepages: file-backed pages excluding executable mappings
+        assert (
+            abs(
+                psutil.virtual_memory().buffers
+                - self.parse_vmstat("cached file pages") * PAGESIZE
+            )
+            < TOLERANCE_SYS_MEM
+        )
+
+    # --- swap mem
+
+    @retry_on_failure
+    def test_swapmem_total(self):
+        assert (
+            abs(
+                psutil.swap_memory().total
+                - self.parse_vmstat("swap pages") * PAGESIZE
+            )
+            < TOLERANCE_SYS_MEM
+        )
diff --git a/tests/test_connections.py b/tests/test_connections.py
new file mode 100755
index 0000000000..d4943ec983
--- /dev/null
+++ b/tests/test_connections.py
@@ -0,0 +1,582 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Tests for psutil.net_connections() and Process.net_connections() APIs."""
+
+import os
+import socket
+import subprocess
+import textwrap
+from contextlib import closing
+from socket import AF_INET
+from socket import AF_INET6
+from socket import SOCK_DGRAM
+from socket import SOCK_STREAM
+
+import psutil
+from psutil import FREEBSD
+from psutil import LINUX
+from psutil import MACOS
+from psutil import NETBSD
+from psutil import OPENBSD
+from psutil import POSIX
+from psutil import SUNOS
+from psutil import WINDOWS
+from psutil._common import supports_ipv6
+
+from . import AF_UNIX
+from . import HAS_NET_CONNECTIONS_UNIX
+from . import ROOT_DIR
+from . import SKIP_SYSCONS
+from . import PsutilTestCase
+from . import bind_socket
+from . import bind_unix_socket
+from . import check_connection_ntuple
+from . import create_sockets
+from . import filter_proc_net_connections
+from . import pytest
+from . import reap_children
+from . import retry_on_failure
+from . import serial
+from . import skip_on_access_denied
+from . import skipif
+from . import tcp_socketpair
+from . import unix_socketpair
+from . import wait_for_file_subproc
+
+SOCK_SEQPACKET = getattr(socket, "SOCK_SEQPACKET", object())
+
+
+def this_proc_net_connections(kind):
+    cons = psutil.Process().net_connections(kind=kind)
+    if kind in {"all", "unix"}:
+        return filter_proc_net_connections(cons)
+    return cons
+
+
+@serial
+class ConnectionTestCase(PsutilTestCase):
+    def setUp(self):
+        assert this_proc_net_connections(kind='all') == []
+
+    def tearDown(self):
+        # Make sure we closed all resources.
+        assert this_proc_net_connections(kind='all') == []
+
+    def compare_procsys_connections(self, pid, proc_cons, kind='all'):
+        """Given a process PID and its list of connections compare
+        those against system-wide connections retrieved via
+        psutil.net_connections.
+        """
+        try:
+            sys_cons = psutil.net_connections(kind=kind)
+        except psutil.AccessDenied:
+            # On MACOS, system-wide connections are retrieved by iterating
+            # over all processes
+            if MACOS:
+                return
+            else:
+                raise
+        # Filter for this proc PID and exclude PIDs from the tuple.
+        sys_cons = [c[:-1] for c in sys_cons if c.pid == pid]
+        sys_cons.sort()
+        proc_cons.sort()
+        assert proc_cons == sys_cons
+
+
+class TestBasicOperations(ConnectionTestCase):
+    @skipif(SKIP_SYSCONS, reason="requires root")
+    def test_system(self):
+        with create_sockets():
+            for conn in psutil.net_connections(kind='all'):
+                check_connection_ntuple(conn)
+
+    def test_process(self):
+        with create_sockets():
+            for conn in this_proc_net_connections(kind='all'):
+                check_connection_ntuple(conn)
+
+    def test_invalid_kind(self):
+        with pytest.raises(ValueError):
+            this_proc_net_connections(kind='???')
+        with pytest.raises(ValueError):
+            psutil.net_connections(kind='???')
+
+
+@serial
+class TestUnconnectedSockets(ConnectionTestCase):
+    """Tests sockets which are open but not connected to anything."""
+
+    def get_conn_from_sock(self, sock):
+        cons = this_proc_net_connections(kind='all')
+        smap = {c.fd: c for c in cons}
+        if NETBSD or FREEBSD:
+            # NetBSD opens a UNIX socket to /var/log/run
+            # so there may be more connections.
+            return smap[sock.fileno()]
+        else:
+            assert len(cons) == 1
+            if cons[0].fd != -1:
+                assert smap[sock.fileno()].fd == sock.fileno()
+            return cons[0]
+
+    def check_socket(self, sock):
+        """Given a socket, makes sure it matches the one obtained
+        via psutil. It assumes this process created one connection
+        only (the one supposed to be checked).
+        """
+        conn = self.get_conn_from_sock(sock)
+        check_connection_ntuple(conn)
+
+        # fd, family, type
+        if conn.fd != -1:
+            assert conn.fd == sock.fileno()
+        assert conn.family == sock.family
+        # see: http://bugs.python.org/issue30204
+        assert conn.type == sock.getsockopt(socket.SOL_SOCKET, socket.SO_TYPE)
+
+        # local address
+        laddr = sock.getsockname()
+        if not laddr and isinstance(laddr, bytes):
+            # See: http://bugs.python.org/issue30205
+            laddr = laddr.decode()
+        if sock.family == AF_INET6:
+            laddr = laddr[:2]
+        assert conn.laddr == laddr
+
+        # XXX Solaris can't retrieve system-wide UNIX sockets
+        if sock.family == AF_UNIX and HAS_NET_CONNECTIONS_UNIX:
+            cons = this_proc_net_connections(kind='all')
+            self.compare_procsys_connections(os.getpid(), cons, kind='all')
+        return conn
+
+    def test_tcp_v4(self):
+        addr = ("127.0.0.1", 0)
+        with closing(bind_socket(AF_INET, SOCK_STREAM, addr=addr)) as sock:
+            conn = self.check_socket(sock)
+            assert conn.raddr == ()
+            assert conn.status == psutil.CONN_LISTEN
+
+    @skipif(not supports_ipv6(), reason="IPv6 not supported")
+    def test_tcp_v6(self):
+        addr = ("::1", 0)
+        with closing(bind_socket(AF_INET6, SOCK_STREAM, addr=addr)) as sock:
+            conn = self.check_socket(sock)
+            assert conn.raddr == ()
+            assert conn.status == psutil.CONN_LISTEN
+
+    def test_udp_v4(self):
+        addr = ("127.0.0.1", 0)
+        with closing(bind_socket(AF_INET, SOCK_DGRAM, addr=addr)) as sock:
+            conn = self.check_socket(sock)
+            assert conn.raddr == ()
+            assert conn.status == psutil.CONN_NONE
+
+    @skipif(not supports_ipv6(), reason="IPv6 not supported")
+    def test_udp_v6(self):
+        addr = ("::1", 0)
+        with closing(bind_socket(AF_INET6, SOCK_DGRAM, addr=addr)) as sock:
+            conn = self.check_socket(sock)
+            assert conn.raddr == ()
+            assert conn.status == psutil.CONN_NONE
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_unix_tcp(self):
+        testfn = self.get_testfn()
+        with closing(bind_unix_socket(testfn, type=SOCK_STREAM)) as sock:
+            conn = self.check_socket(sock)
+            assert conn.raddr == ""
+            assert conn.status == psutil.CONN_NONE
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_unix_udp(self):
+        testfn = self.get_testfn()
+        with closing(bind_unix_socket(testfn, type=SOCK_STREAM)) as sock:
+            conn = self.check_socket(sock)
+            assert conn.raddr == ""
+            assert conn.status == psutil.CONN_NONE
+
+
+@serial
+class TestConnectedSocket(ConnectionTestCase):
+    """Test socket pairs which are actually connected to
+    each other.
+    """
+
+    # On SunOS, even after we close() it, the server socket stays around
+    # in TIME_WAIT state.
+    @skipif(SUNOS, reason="unreliable on SUNOS")
+    def test_tcp(self):
+        addr = ("127.0.0.1", 0)
+        assert this_proc_net_connections(kind='tcp4') == []
+        server, client = tcp_socketpair(AF_INET, addr=addr)
+        try:
+            cons = this_proc_net_connections(kind='tcp4')
+            assert len(cons) == 2
+            assert cons[0].status == psutil.CONN_ESTABLISHED
+            assert cons[1].status == psutil.CONN_ESTABLISHED
+            # May not be fast enough to change state so it stays
+            # commented.
+            # client.close()
+            # cons = this_proc_net_connections(kind='all')
+            # assert len(cons) == 1
+            # assert cons[0].status == psutil.CONN_CLOSE_WAIT
+        finally:
+            server.close()
+            client.close()
+
+    @skipif(not POSIX, reason="POSIX only")
+    @skipif(not HAS_NET_CONNECTIONS_UNIX, reason="can't list UNIX sockets")
+    def test_unix(self):
+        testfn = self.get_testfn()
+        server, client = unix_socketpair(testfn)
+        try:
+            cons = this_proc_net_connections(kind='unix')
+            assert not (cons[0].laddr and cons[0].raddr), cons
+            assert not (cons[1].laddr and cons[1].raddr), cons
+            if NETBSD or FREEBSD:
+                # On NetBSD creating a UNIX socket will cause
+                # a UNIX connection to  /var/run/log.
+                cons = [c for c in cons if c.raddr != '/var/run/log']
+            assert len(cons) == 2
+            if LINUX or FREEBSD or SUNOS or OPENBSD:
+                # remote path is never set
+                assert cons[0].raddr == ""
+                assert cons[1].raddr == ""
+                # one local address should though
+                assert testfn == (cons[0].laddr or cons[1].laddr)
+            else:
+                # On other systems either the laddr or raddr
+                # of both peers are set.
+                assert (cons[0].laddr or cons[1].laddr) == testfn
+        finally:
+            server.close()
+            client.close()
+
+
+class TestFilters(ConnectionTestCase):
+    def test_filters(self):
+        def check(kind, families, types):
+            for conn in this_proc_net_connections(kind=kind):
+                assert conn.family in families
+                assert conn.type in types
+            if not SKIP_SYSCONS:
+                for conn in psutil.net_connections(kind=kind):
+                    assert conn.family in families
+                    assert conn.type in types
+
+        with create_sockets():
+            check(
+                'all',
+                [AF_INET, AF_INET6, AF_UNIX],
+                [SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET],
+            )
+            check('inet', [AF_INET, AF_INET6], [SOCK_STREAM, SOCK_DGRAM])
+            check('inet4', [AF_INET], [SOCK_STREAM, SOCK_DGRAM])
+            check('tcp', [AF_INET, AF_INET6], [SOCK_STREAM])
+            check('tcp4', [AF_INET], [SOCK_STREAM])
+            check('tcp6', [AF_INET6], [SOCK_STREAM])
+            check('udp', [AF_INET, AF_INET6], [SOCK_DGRAM])
+            check('udp4', [AF_INET], [SOCK_DGRAM])
+            check('udp6', [AF_INET6], [SOCK_DGRAM])
+            if HAS_NET_CONNECTIONS_UNIX:
+                check(
+                    'unix',
+                    [AF_UNIX],
+                    [SOCK_STREAM, SOCK_DGRAM, SOCK_SEQPACKET],
+                )
+
+    @skip_on_access_denied(only_if=MACOS)
+    def test_combos(self):
+        reap_children()
+
+        def check_conn(proc, conn, family, type, laddr, raddr, status, kinds):
+            all_kinds = (
+                "all",
+                "inet",
+                "inet4",
+                "inet6",
+                "tcp",
+                "tcp4",
+                "tcp6",
+                "udp",
+                "udp4",
+                "udp6",
+            )
+            check_connection_ntuple(conn)
+            assert conn.family == family
+            assert conn.type == type
+            assert conn.laddr == laddr
+            assert conn.raddr == raddr
+            assert conn.status == status
+            for kind in all_kinds:
+                cons = proc.net_connections(kind=kind)
+                if kind in kinds:
+                    assert cons != []
+                else:
+                    assert cons == []
+            # compare against system-wide connections
+            # XXX Solaris can't retrieve system-wide UNIX
+            # sockets.
+            if HAS_NET_CONNECTIONS_UNIX:
+                self.compare_procsys_connections(proc.pid, [conn])
+
+        tcp_template = textwrap.dedent("""
+            import socket, time
+            s = socket.socket({family}, socket.SOCK_STREAM)
+            s.bind(('{addr}', 0))
+            s.listen(5)
+            with open('{testfn}', 'w') as f:
+                f.write(str(s.getsockname()[:2]))
+            [time.sleep(0.1) for x in range(100)]
+            """)
+
+        udp_template = textwrap.dedent("""
+            import socket, time
+            s = socket.socket({family}, socket.SOCK_DGRAM)
+            s.bind(('{addr}', 0))
+            with open('{testfn}', 'w') as f:
+                f.write(str(s.getsockname()[:2]))
+            [time.sleep(0.1) for x in range(100)]
+            """)
+
+        # must be relative on Windows
+        testfile = os.path.basename(self.get_testfn(dir=os.getcwd()))
+        tcp4_template = tcp_template.format(
+            family=int(AF_INET), addr="127.0.0.1", testfn=testfile
+        )
+        udp4_template = udp_template.format(
+            family=int(AF_INET), addr="127.0.0.1", testfn=testfile
+        )
+        tcp6_template = tcp_template.format(
+            family=int(AF_INET6), addr="::1", testfn=testfile
+        )
+        udp6_template = udp_template.format(
+            family=int(AF_INET6), addr="::1", testfn=testfile
+        )
+
+        # launch various subprocess instantiating a socket of various
+        # families and types to enrich psutil results
+        tcp4_proc = self.pyrun(tcp4_template, stderr=subprocess.PIPE)
+        tcp4_addr = eval(
+            wait_for_file_subproc(testfile, tcp4_proc, delete=True)
+        )
+        udp4_proc = self.pyrun(udp4_template, stderr=subprocess.PIPE)
+        udp4_addr = eval(
+            wait_for_file_subproc(testfile, udp4_proc, delete=True)
+        )
+        if supports_ipv6():
+            tcp6_proc = self.pyrun(tcp6_template, stderr=subprocess.PIPE)
+            tcp6_addr = eval(
+                wait_for_file_subproc(testfile, tcp6_proc, delete=True)
+            )
+            udp6_proc = self.pyrun(udp6_template, stderr=subprocess.PIPE)
+            udp6_addr = eval(
+                wait_for_file_subproc(testfile, udp6_proc, delete=True)
+            )
+        else:
+            tcp6_proc = None
+            udp6_proc = None
+            tcp6_addr = None
+            udp6_addr = None
+
+        for p in psutil.Process().children():
+            cons = p.net_connections()
+            assert len(cons) == 1
+            for conn in cons:
+                # TCP v4
+                if p.pid == tcp4_proc.pid:
+                    check_conn(
+                        p,
+                        conn,
+                        AF_INET,
+                        SOCK_STREAM,
+                        tcp4_addr,
+                        (),
+                        psutil.CONN_LISTEN,
+                        ("all", "inet", "inet4", "tcp", "tcp4"),
+                    )
+                # UDP v4
+                elif p.pid == udp4_proc.pid:
+                    check_conn(
+                        p,
+                        conn,
+                        AF_INET,
+                        SOCK_DGRAM,
+                        udp4_addr,
+                        (),
+                        psutil.CONN_NONE,
+                        ("all", "inet", "inet4", "udp", "udp4"),
+                    )
+                # TCP v6
+                elif p.pid == getattr(tcp6_proc, "pid", None):
+                    check_conn(
+                        p,
+                        conn,
+                        AF_INET6,
+                        SOCK_STREAM,
+                        tcp6_addr,
+                        (),
+                        psutil.CONN_LISTEN,
+                        ("all", "inet", "inet6", "tcp", "tcp6"),
+                    )
+                # UDP v6
+                elif p.pid == getattr(udp6_proc, "pid", None):
+                    check_conn(
+                        p,
+                        conn,
+                        AF_INET6,
+                        SOCK_DGRAM,
+                        udp6_addr,
+                        (),
+                        psutil.CONN_NONE,
+                        ("all", "inet", "inet6", "udp", "udp6"),
+                    )
+
+    def test_count(self):
+        with create_sockets():
+            # tcp
+            cons = this_proc_net_connections(kind='tcp')
+            assert len(cons) == (2 if supports_ipv6() else 1)
+            for conn in cons:
+                assert conn.family in {AF_INET, AF_INET6}
+                assert conn.type == SOCK_STREAM
+            # tcp4
+            cons = this_proc_net_connections(kind='tcp4')
+            assert len(cons) == 1
+            assert cons[0].family == AF_INET
+            assert cons[0].type == SOCK_STREAM
+            # tcp6
+            if supports_ipv6():
+                cons = this_proc_net_connections(kind='tcp6')
+                assert len(cons) == 1
+                assert cons[0].family == AF_INET6
+                assert cons[0].type == SOCK_STREAM
+            # udp
+            cons = this_proc_net_connections(kind='udp')
+            assert len(cons) == (2 if supports_ipv6() else 1)
+            for conn in cons:
+                assert conn.family in {AF_INET, AF_INET6}
+                assert conn.type == SOCK_DGRAM
+            # udp4
+            cons = this_proc_net_connections(kind='udp4')
+            assert len(cons) == 1
+            assert cons[0].family == AF_INET
+            assert cons[0].type == SOCK_DGRAM
+            # udp6
+            if supports_ipv6():
+                cons = this_proc_net_connections(kind='udp6')
+                assert len(cons) == 1
+                assert cons[0].family == AF_INET6
+                assert cons[0].type == SOCK_DGRAM
+            # inet
+            cons = this_proc_net_connections(kind='inet')
+            assert len(cons) == (4 if supports_ipv6() else 2)
+            for conn in cons:
+                assert conn.family in {AF_INET, AF_INET6}
+                assert conn.type in {SOCK_STREAM, SOCK_DGRAM}
+            # inet6
+            if supports_ipv6():
+                cons = this_proc_net_connections(kind='inet6')
+                assert len(cons) == 2
+                for conn in cons:
+                    assert conn.family == AF_INET6
+                    assert conn.type in {SOCK_STREAM, SOCK_DGRAM}
+            # Skipped on BSD because by default the Python process
+            # creates a UNIX socket to '/var/run/log'.
+            if HAS_NET_CONNECTIONS_UNIX and not (FREEBSD or NETBSD):
+                cons = this_proc_net_connections(kind='unix')
+                assert len(cons) == 3
+                for conn in cons:
+                    assert conn.family == AF_UNIX
+                    assert conn.type in {SOCK_STREAM, SOCK_DGRAM}
+
+
+@skipif(SKIP_SYSCONS, reason="requires root")
+class TestSystemWideConnections(ConnectionTestCase):
+    """Tests for net_connections()."""
+
+    def test_it(self):
+        def check(cons, families, types_):
+            for conn in cons:
+                assert conn.family in families
+                if conn.family != AF_UNIX:
+                    assert conn.type in types_
+                check_connection_ntuple(conn)
+
+        with create_sockets():
+            from psutil._common import conn_tmap
+
+            for kind, groups in conn_tmap.items():
+                # XXX: SunOS does not retrieve UNIX sockets.
+                if kind == 'unix' and not HAS_NET_CONNECTIONS_UNIX:
+                    continue
+                families, types_ = groups
+                cons = psutil.net_connections(kind)
+                assert len(cons) == len(set(cons))
+                check(cons, families, types_)
+
+    @retry_on_failure
+    def test_multi_sockets_procs(self):
+        # Creates multiple sub processes, each creating different
+        # sockets. For each process check that proc.net_connections()
+        # and psutil.net_connections() return the same results.
+        # This is done mainly to check whether net_connections()'s
+        # pid is properly set, see:
+        # https://github.com/giampaolo/psutil/issues/1013
+        with create_sockets() as socks:
+            expected = len(socks)
+        procs = []
+        times = 10
+        fnames = []
+        for _ in range(times):
+            fname = self.get_testfn()
+            fnames.append(fname)
+            src = textwrap.dedent(f"""\
+                import time, os, sys
+                if 'CIBUILDWHEEL' not in os.environ:
+                    sys.path.insert(0, r'{ROOT_DIR}')
+                from tests import create_sockets
+                with create_sockets():
+                    with open(r'{fname}', 'w') as f:
+                        f.write("hello")
+                    [time.sleep(0.1) for x in range(100)]
+                """)
+            sproc = self.pyrun(src, stderr=subprocess.PIPE)
+            procs.append(sproc)
+
+        # sync
+        for fname, sproc in zip(fnames, procs):
+            wait_for_file_subproc(fname, sproc)
+
+        pids = [x.pid for x in procs]
+        syscons = [
+            x for x in psutil.net_connections(kind='all') if x.pid in pids
+        ]
+        for pid in pids:
+            assert len([x for x in syscons if x.pid == pid]) == expected
+            p = psutil.Process(pid)
+            assert len(p.net_connections('all')) == expected
+
+
+class TestMisc(PsutilTestCase):
+    def test_net_connection_constants(self):
+        ints = []
+        strs = []
+        for name in dir(psutil):
+            if name.startswith('CONN_'):
+                num = getattr(psutil, name)
+                str_ = str(num)
+                assert str_.isupper(), str_
+                assert str not in strs
+                assert num not in ints
+                ints.append(num)
+                strs.append(str_)
+        if SUNOS:
+            psutil.CONN_IDLE  # noqa: B018
+            psutil.CONN_BOUND  # noqa: B018
+        if WINDOWS:
+            psutil.CONN_DELETE_TCB  # noqa: B018
diff --git a/tests/test_contracts.py b/tests/test_contracts.py
new file mode 100755
index 0000000000..4d729cc3ad
--- /dev/null
+++ b/tests/test_contracts.py
@@ -0,0 +1,472 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Contracts tests. These tests mainly check API sanity in terms of
+returned types and APIs availability.
+Some of these are duplicates of tests test_system.py and test_process.py.
+"""
+
+import platform
+import socket
+
+import psutil
+from psutil import AIX
+from psutil import BSD
+from psutil import FREEBSD
+from psutil import LINUX
+from psutil import MACOS
+from psutil import NETBSD
+from psutil import OPENBSD
+from psutil import POSIX
+from psutil import SUNOS
+from psutil import WINDOWS
+from psutil import BatteryTime
+from psutil import ConnectionStatus
+from psutil import NicDuplex
+from psutil import ProcessStatus
+
+from . import HAS_CPU_FREQ
+from . import HAS_NET_IO_COUNTERS
+from . import HAS_SENSORS_FANS
+from . import HAS_SENSORS_TEMPERATURES
+from . import SKIP_SYSCONS
+from . import PsutilTestCase
+from . import create_sockets
+from . import enum
+from . import is_namedtuple
+from . import kernel_version
+from . import pytest
+from . import serial
+from . import skipif
+
+# ===================================================================
+# --- APIs availability
+# ===================================================================
+
+# Make sure code reflects what doc promises in terms of APIs
+# availability.
+
+
+class TestAvailConstantsAPIs(PsutilTestCase):
+
+    def check_constants(self, names, are_avail):
+        for name in names:
+            with self.subTest(name=name):
+                # assert CONSTANT is/isn't in psutil namespace
+                assert hasattr(psutil, name) == are_avail
+                # assert CONSTANT is/isn't in psutil.__all__
+                if are_avail:
+                    assert name in psutil.__all__
+                else:
+                    assert name not in psutil.__all__
+
+    def test_PROCFS_PATH(self):
+        self.check_constants(("PROCFS_PATH",), LINUX or SUNOS or AIX)
+
+    def test_proc_status(self):
+        names = (
+            "STATUS_RUNNING",
+            "STATUS_SLEEPING",
+            "STATUS_DISK_SLEEP",
+            "STATUS_STOPPED",
+            "STATUS_TRACING_STOP",
+            "STATUS_ZOMBIE",
+            "STATUS_DEAD",
+            "STATUS_WAKE_KILL",
+            "STATUS_WAKING",
+            "STATUS_IDLE",
+            "STATUS_LOCKED",
+            "STATUS_WAITING",
+            "STATUS_SUSPENDED",
+            "STATUS_PARKED",
+        )
+        self.check_constants(names, True)
+        assert sorted(ProcessStatus.__members__.keys()) == sorted(names)
+
+    def test_proc_status_strenum(self):
+        mapping = (
+            (psutil.STATUS_RUNNING, "running"),
+            (psutil.STATUS_SLEEPING, "sleeping"),
+            (psutil.STATUS_DISK_SLEEP, "disk-sleep"),
+            (psutil.STATUS_STOPPED, "stopped"),
+            (psutil.STATUS_TRACING_STOP, "tracing-stop"),
+            (psutil.STATUS_ZOMBIE, "zombie"),
+            (psutil.STATUS_DEAD, "dead"),
+            (psutil.STATUS_WAKE_KILL, "wake-kill"),
+            (psutil.STATUS_WAKING, "waking"),
+            (psutil.STATUS_IDLE, "idle"),
+            (psutil.STATUS_LOCKED, "locked"),
+            (psutil.STATUS_WAITING, "waiting"),
+            (psutil.STATUS_SUSPENDED, "suspended"),
+            (psutil.STATUS_PARKED, "parked"),
+        )
+        for en, str_ in mapping:
+            assert en == str_
+            assert str(en) == str_
+            assert repr(en) != str_
+
+    def test_conn_status(self):
+        names = [
+            "CONN_ESTABLISHED",
+            "CONN_SYN_SENT",
+            "CONN_SYN_RECV",
+            "CONN_FIN_WAIT1",
+            "CONN_FIN_WAIT2",
+            "CONN_TIME_WAIT",
+            "CONN_CLOSE",
+            "CONN_CLOSE_WAIT",
+            "CONN_LAST_ACK",
+            "CONN_LISTEN",
+            "CONN_CLOSING",
+            "CONN_NONE",
+        ]
+        if WINDOWS:
+            names.append("CONN_DELETE_TCB")
+        if SUNOS:
+            names.extend(["CONN_IDLE", "CONN_BOUND"])
+
+        self.check_constants(names, True)
+        assert sorted(ConnectionStatus.__members__.keys()) == sorted(names)
+
+    def test_conn_status_strenum(self):
+        mapping = (
+            (psutil.CONN_ESTABLISHED, "ESTABLISHED"),
+            (psutil.CONN_SYN_SENT, "SYN_SENT"),
+            (psutil.CONN_SYN_RECV, "SYN_RECV"),
+            (psutil.CONN_FIN_WAIT1, "FIN_WAIT1"),
+            (psutil.CONN_FIN_WAIT2, "FIN_WAIT2"),
+            (psutil.CONN_TIME_WAIT, "TIME_WAIT"),
+            (psutil.CONN_CLOSE, "CLOSE"),
+            (psutil.CONN_CLOSE_WAIT, "CLOSE_WAIT"),
+            (psutil.CONN_LAST_ACK, "LAST_ACK"),
+            (psutil.CONN_LISTEN, "LISTEN"),
+            (psutil.CONN_CLOSING, "CLOSING"),
+            (psutil.CONN_NONE, "NONE"),
+        )
+        for en, str_ in mapping:
+            assert en == str_
+            assert str(en) == str_
+            assert repr(en) != str_
+
+    def test_nic_duplex(self):
+        names = ("NIC_DUPLEX_FULL", "NIC_DUPLEX_HALF", "NIC_DUPLEX_UNKNOWN")
+        self.check_constants(names, True)
+        assert sorted(NicDuplex.__members__.keys()) == sorted(names)
+
+    def test_battery_time(self):
+        names = ("POWER_TIME_UNKNOWN", "POWER_TIME_UNLIMITED")
+        self.check_constants(names, True)
+        assert sorted(BatteryTime.__members__.keys()) == sorted(names)
+
+    def test_proc_ioprio_class_linux(self):
+        names = (
+            "IOPRIO_CLASS_NONE",
+            "IOPRIO_CLASS_RT",
+            "IOPRIO_CLASS_BE",
+            "IOPRIO_CLASS_IDLE",
+        )
+        self.check_constants(names, LINUX)
+        if LINUX:
+            assert sorted(
+                psutil.ProcessIOPriority.__members__.keys()
+            ) == sorted(names)
+        else:
+            not hasattr(psutil, "ProcessIOPriority")
+
+    def test_proc_ioprio_value_windows(self):
+        names = (
+            "IOPRIO_HIGH",
+            "IOPRIO_NORMAL",
+            "IOPRIO_LOW",
+            "IOPRIO_VERYLOW",
+        )
+        self.check_constants(names, WINDOWS)
+        if WINDOWS:
+            assert sorted(
+                psutil.ProcessIOPriority.__members__.keys()
+            ) == sorted(names)
+
+    def test_proc_priority_windows(self):
+        names = (
+            "ABOVE_NORMAL_PRIORITY_CLASS",
+            "BELOW_NORMAL_PRIORITY_CLASS",
+            "HIGH_PRIORITY_CLASS",
+            "IDLE_PRIORITY_CLASS",
+            "NORMAL_PRIORITY_CLASS",
+            "REALTIME_PRIORITY_CLASS",
+        )
+        self.check_constants(names, WINDOWS)
+        if WINDOWS:
+            assert sorted(psutil.ProcessPriority.__members__.keys()) == sorted(
+                names
+            )
+        else:
+            not hasattr(psutil, "ProcessPriority")
+
+    def test_rlimit(self):
+        names = (
+            "RLIM_INFINITY",
+            "RLIMIT_AS",
+            "RLIMIT_CORE",
+            "RLIMIT_CPU",
+            "RLIMIT_DATA",
+            "RLIMIT_FSIZE",
+            "RLIMIT_MEMLOCK",
+            "RLIMIT_NOFILE",
+            "RLIMIT_NPROC",
+            "RLIMIT_RSS",
+            "RLIMIT_STACK",
+        )
+        self.check_constants(names, LINUX or FREEBSD)
+        self.check_constants(("RLIMIT_LOCKS",), LINUX)
+        self.check_constants(
+            ("RLIMIT_SWAP", "RLIMIT_SBSIZE", "RLIMIT_NPTS"), FREEBSD
+        )
+
+        if POSIX:
+            if kernel_version() >= (2, 6, 8):
+                self.check_constants(("RLIMIT_MSGQUEUE",), LINUX)
+            if kernel_version() >= (2, 6, 12):
+                self.check_constants(("RLIMIT_NICE", "RLIMIT_RTPRIO"), LINUX)
+            if kernel_version() >= (2, 6, 25):
+                self.check_constants(("RLIMIT_RTTIME",), LINUX)
+            if kernel_version() >= (2, 6, 8):
+                self.check_constants(("RLIMIT_SIGPENDING",), LINUX)
+
+    def test_enum_containers(self):
+        self.check_constants(("ProcessStatus",), True)
+        self.check_constants(("ProcessPriority",), WINDOWS)
+        self.check_constants(("ProcessIOPriority",), LINUX or WINDOWS)
+        self.check_constants(("ConnectionStatus",), True)
+        self.check_constants(("NicDuplex",), True)
+        self.check_constants(("BatteryTime",), True)
+
+
+class TestAvailSystemAPIs(PsutilTestCase):
+    def test_win_service_iter(self):
+        assert hasattr(psutil, "win_service_iter") == WINDOWS
+
+    def test_win_service_get(self):
+        assert hasattr(psutil, "win_service_get") == WINDOWS
+
+    def test_cpu_freq(self):
+        assert hasattr(psutil, "cpu_freq") == (
+            LINUX or MACOS or WINDOWS or FREEBSD or OPENBSD
+        )
+
+    def test_sensors_temperatures(self):
+        assert hasattr(psutil, "sensors_temperatures") == (LINUX or FREEBSD)
+
+    def test_sensors_fans(self):
+        assert hasattr(psutil, "sensors_fans") == LINUX
+
+    def test_battery(self):
+        assert hasattr(psutil, "sensors_battery") == (
+            LINUX or WINDOWS or FREEBSD or MACOS
+        )
+
+    def test_heap_info(self):
+        hasit = hasattr(psutil, "heap_info")
+        if LINUX:
+            assert hasit == (platform.libc_ver()[0] == "glibc")
+        else:
+            assert hasit == MACOS or WINDOWS or BSD
+
+    def test_heap_trim(self):
+        hasit = hasattr(psutil, "heap_trim")
+        if LINUX:
+            assert hasit == (platform.libc_ver()[0] == "glibc")
+        else:
+            assert hasit == MACOS or WINDOWS or BSD
+
+
+class TestAvailProcessAPIs(PsutilTestCase):
+    def test_environ(self):
+        assert hasattr(psutil.Process, "environ") == (
+            LINUX
+            or MACOS
+            or WINDOWS
+            or AIX
+            or SUNOS
+            or FREEBSD
+            or OPENBSD
+            or NETBSD
+        )
+
+    def test_uids(self):
+        assert hasattr(psutil.Process, "uids") == POSIX
+
+    def test_gids(self):
+        assert hasattr(psutil.Process, "uids") == POSIX
+
+    def test_terminal(self):
+        assert hasattr(psutil.Process, "terminal") == POSIX
+
+    def test_ionice(self):
+        assert hasattr(psutil.Process, "ionice") == (LINUX or WINDOWS)
+
+    def test_rlimit(self):
+        assert hasattr(psutil.Process, "rlimit") == (LINUX or FREEBSD)
+
+    def test_io_counters(self):
+        hasit = hasattr(psutil.Process, "io_counters")
+        assert hasit == (not (MACOS or SUNOS))
+
+    def test_num_fds(self):
+        assert hasattr(psutil.Process, "num_fds") == POSIX
+
+    def test_num_handles(self):
+        assert hasattr(psutil.Process, "num_handles") == WINDOWS
+
+    def test_cpu_affinity(self):
+        assert hasattr(psutil.Process, "cpu_affinity") == (
+            LINUX or WINDOWS or FREEBSD
+        )
+
+    def test_cpu_num(self):
+        assert hasattr(psutil.Process, "cpu_num") == (
+            LINUX or FREEBSD or SUNOS
+        )
+
+    def test_memory_maps(self):
+        hasit = hasattr(psutil.Process, "memory_maps")
+        assert hasit == (not (OPENBSD or NETBSD or AIX or MACOS))
+
+    def test_memory_extras(self):
+        hasit = hasattr(psutil.Process, "memory_extras")
+        assert hasit == (LINUX or MACOS or WINDOWS)
+
+    def test_memory_footprint(self):
+        hasit = hasattr(psutil.Process, "memory_footprint")
+        assert hasit == (LINUX or MACOS or WINDOWS)
+
+
+# ===================================================================
+# --- API types
+# ===================================================================
+
+
+class TestSystemAPITypes(PsutilTestCase):
+    """Check the return types of system related APIs.
+    https://github.com/giampaolo/psutil/issues/1039.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        cls.proc = psutil.Process()
+
+    def assert_ntuple_of_nums(self, nt, type_=float, gezero=True):
+        assert is_namedtuple(nt)
+        for n in nt:
+            assert isinstance(n, type_)
+            if gezero:
+                assert n >= 0
+
+    def test_cpu_times(self):
+        self.assert_ntuple_of_nums(psutil.cpu_times())
+        for nt in psutil.cpu_times(percpu=True):
+            self.assert_ntuple_of_nums(nt)
+
+    def test_cpu_percent(self):
+        assert isinstance(psutil.cpu_percent(interval=None), float)
+        assert isinstance(psutil.cpu_percent(interval=0.00001), float)
+
+    def test_cpu_times_percent(self):
+        self.assert_ntuple_of_nums(psutil.cpu_times_percent(interval=None))
+        self.assert_ntuple_of_nums(psutil.cpu_times_percent(interval=0.0001))
+
+    def test_cpu_count(self):
+        assert isinstance(psutil.cpu_count(), int)
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    def test_cpu_freq(self):
+        if psutil.cpu_freq() is None:
+            return pytest.skip("cpu_freq() returns None")
+        self.assert_ntuple_of_nums(psutil.cpu_freq(), type_=(float, int))
+
+    def test_disk_io_counters(self):
+        # Duplicate of test_system.py. Keep it anyway.
+        for k, v in psutil.disk_io_counters(perdisk=True).items():
+            assert isinstance(k, str)
+            self.assert_ntuple_of_nums(v, type_=int)
+
+    def test_disk_partitions(self):
+        # Duplicate of test_system.py. Keep it anyway.
+        for disk in psutil.disk_partitions():
+            assert isinstance(disk.device, str)
+            assert isinstance(disk.mountpoint, str)
+            assert isinstance(disk.fstype, str)
+            assert isinstance(disk.opts, str)
+
+    @serial
+    @skipif(SKIP_SYSCONS, reason="requires root")
+    def test_net_connections(self):
+        with create_sockets():
+            ret = psutil.net_connections('all')
+            assert len(ret) == len(set(ret))
+            for conn in ret:
+                assert is_namedtuple(conn)
+
+    def test_net_if_addrs(self):
+        # Duplicate of test_system.py. Keep it anyway.
+        for ifname, addrs in psutil.net_if_addrs().items():
+            assert isinstance(ifname, str)
+            for addr in addrs:
+                assert isinstance(addr.family, enum.IntEnum)
+                assert isinstance(addr.address, (str, type(None)))
+                if addr.address is None:  # virtual NIC
+                    assert addr.family == socket.AF_UNSPEC
+                assert isinstance(addr.netmask, (str, type(None)))
+                assert isinstance(addr.broadcast, (str, type(None)))
+
+    def test_net_if_stats(self):
+        # Duplicate of test_system.py. Keep it anyway.
+        for ifname, info in psutil.net_if_stats().items():
+            assert isinstance(ifname, str)
+            assert isinstance(info.isup, bool)
+            assert isinstance(info.duplex, enum.IntEnum)
+            assert isinstance(info.speed, int)
+            assert isinstance(info.mtu, int)
+
+    @skipif(not HAS_NET_IO_COUNTERS, reason="not supported")
+    def test_net_io_counters(self):
+        # Duplicate of test_system.py. Keep it anyway.
+        for ifname in psutil.net_io_counters(pernic=True):
+            assert isinstance(ifname, str)
+
+    @skipif(not HAS_SENSORS_FANS, reason="not supported")
+    def test_sensors_fans(self):
+        # Duplicate of test_system.py. Keep it anyway.
+        for name, units in psutil.sensors_fans().items():
+            assert isinstance(name, str)
+            for unit in units:
+                assert isinstance(unit.label, str)
+                assert isinstance(unit.current, (float, int, type(None)))
+
+    @skipif(not HAS_SENSORS_TEMPERATURES, reason="not supported")
+    def test_sensors_temperatures(self):
+        # Duplicate of test_system.py. Keep it anyway.
+        for name, units in psutil.sensors_temperatures().items():
+            assert isinstance(name, str)
+            for unit in units:
+                assert isinstance(unit.label, str)
+                assert isinstance(unit.current, (float, int, type(None)))
+                assert isinstance(unit.high, (float, int, type(None)))
+                assert isinstance(unit.critical, (float, int, type(None)))
+
+    def test_boot_time(self):
+        # Duplicate of test_system.py. Keep it anyway.
+        assert isinstance(psutil.boot_time(), float)
+
+    def test_users(self):
+        # Duplicate of test_system.py. Keep it anyway.
+        for user in psutil.users():
+            assert isinstance(user.name, str)
+            assert isinstance(user.terminal, (str, type(None)))
+            assert isinstance(user.host, (str, type(None)))
+            assert isinstance(user.pid, (int, type(None)))
+            if isinstance(user.pid, int):
+                assert user.pid > 0
diff --git a/tests/test_heap.py b/tests/test_heap.py
new file mode 100755
index 0000000000..ab6d1f9ad2
--- /dev/null
+++ b/tests/test_heap.py
@@ -0,0 +1,332 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Tests for `psutil.heap_info()`.
+
+This module deliberately creates **controlled memory leaks** by calling
+low-level C allocation functions (`malloc()`, `HeapAlloc()`,
+`VirtualAllocEx()`, etc.) **without** freeing them - exactly how
+real-world memory leaks occur in native C extensions code.
+
+By bypassing Python's memory manager entirely (via `ctypes`), we
+directly exercise the underlying system allocator:
+
+UNIX
+
+- Small `malloc()` allocations (≤ 128KB on glibc) without `free()`
+  increase `heap_used`.
+- Large `malloc()` allocations  without `free()` trigger `mmap()` and
+  increase `mmap_used`.
+    - Note: direct `mmap()` / `munmap()` via `ctypes` was attempted but
+      proved unreliable.
+
+Windows
+
+- `HeapAlloc()` without `HeapFree()` increases `heap_used`.
+- `VirtualAllocEx()` without `VirtualFreeEx()` increases `mmap_used`.
+- `HeapCreate()` without `HeapDestroy()` increases `heap_count`.
+
+These tests ensure that `psutil.heap_info()` detects unreleased
+native memory across different allocators (glibc on Linux,
+jemalloc on BSD/macOS, Windows CRT).
+"""
+
+import ctypes
+import gc
+
+import psutil
+from psutil import LINUX
+from psutil import MACOS
+from psutil import POSIX
+from psutil import WINDOWS
+
+from . import HAS_HEAP_INFO
+from . import PYPY
+from . import PsutilTestCase
+from . import isolated
+from . import retry_on_failure
+from . import skipif
+
+# Small allocation (64 KiB), below M_MMAP_THRESHOLD (128 KiB).
+# Increases heap_used (uordblks) without triggering mmap().
+HEAP_SIZE = 64 * 1024
+# Large allocation (64 MiB), exceeds DEFAULT_MMAP_THRESHOLD_MAX (32
+# MiB). Forces malloc() to use mmap() internally and increases
+# mmap_used (hblkhd). See `man mallopt`.
+MMAP_SIZE = 64 * 1024 * 1024
+
+
+# =====================================================================
+# --- Utils
+# =====================================================================
+
+
+if POSIX:  # noqa: SIM108
+    libc = ctypes.CDLL(None)
+else:
+    libc = ctypes.CDLL("msvcrt.dll")
+
+
+def malloc(size):
+    """Allocate memory via malloc(). If passed a small size, usually
+    affects heap_used, else mmap_used (not on Windows).
+    """
+    fun = libc.malloc
+    fun.argtypes = [ctypes.c_size_t]
+    fun.restype = ctypes.c_void_p
+    ptr = fun(size)
+    assert ptr, "malloc() failed"
+    return ptr
+
+
+def free(ptr):
+    """Free malloc() memory."""
+    fun = libc.free
+    fun.argtypes = [ctypes.c_void_p]
+    fun.restype = None
+    fun(ptr)
+
+
+if WINDOWS:
+    from ctypes import wintypes
+
+    import win32api
+    import win32con
+    import win32process
+
+    kernel32 = ctypes.windll.kernel32
+    HEAP_NO_SERIALIZE = 0x00000001
+
+    # --- for `heap_used`
+
+    def GetProcessHeap():
+        fun = kernel32.GetProcessHeap
+        fun.argtypes = []
+        fun.restype = wintypes.HANDLE
+        heap = fun()
+        assert heap != 0, "GetProcessHeap failed"
+        return heap
+
+    def HeapAlloc(heap, size):
+        fun = kernel32.HeapAlloc
+        fun.argtypes = [wintypes.HANDLE, wintypes.DWORD, ctypes.c_size_t]
+        fun.restype = ctypes.c_void_p
+        addr = fun(heap, 0, size)
+        assert addr, "HeapAlloc failed"
+        return addr
+
+    def HeapFree(heap, addr):
+        fun = kernel32.HeapFree
+        fun.argtypes = [wintypes.HANDLE, wintypes.DWORD, ctypes.c_void_p]
+        fun.restype = wintypes.BOOL
+        assert fun(heap, 0, addr) != 0, "HeapFree failed"
+
+    # --- for `mmap_used`
+
+    def VirtualAllocEx(size):
+        return win32process.VirtualAllocEx(
+            win32api.GetCurrentProcess(),
+            0,
+            size,
+            win32con.MEM_COMMIT | win32con.MEM_RESERVE,
+            win32con.PAGE_READWRITE,
+        )
+
+    def VirtualFreeEx(addr):
+        win32process.VirtualFreeEx(
+            win32api.GetCurrentProcess(), addr, 0, win32con.MEM_RELEASE
+        )
+
+    # --- for `heap_count`
+
+    def HeapCreate(initial_size, max_size):
+        fun = kernel32.HeapCreate
+        fun.argtypes = [
+            wintypes.DWORD,
+            ctypes.c_size_t,
+            ctypes.c_size_t,
+        ]
+        fun.restype = wintypes.HANDLE
+        heap = fun(HEAP_NO_SERIALIZE, initial_size, max_size)
+        assert heap != 0, "HeapCreate failed"
+        return heap
+
+    def HeapDestroy(heap):
+        fun = kernel32.HeapDestroy
+        fun.argtypes = [wintypes.HANDLE]
+        fun.restype = wintypes.BOOL
+        assert fun(heap) != 0, "HeapDestroy failed"
+
+
+# =====================================================================
+# --- Tests
+# =====================================================================
+
+
+def trim_memory():
+    gc.collect()
+    psutil.heap_trim()
+
+
+def assert_within_percent(actual, expected, percent):
+    """Assert that `actual` is within `percent` tolerance of `expected`."""
+    lower = expected * (1 - percent / 100)
+    upper = expected * (1 + percent / 100)
+    if not (lower <= actual <= upper):
+        raise AssertionError(
+            f"{actual} is not within {percent}% tolerance of expected"
+            f" {expected} (allowed range: {lower} - {upper})"
+        )
+
+
+@skipif(not HAS_HEAP_INFO, reason="heap_info() not supported")
+class HeapTestCase(PsutilTestCase):
+    def setUp(self):
+        trim_memory()
+
+    @classmethod
+    def tearDownClass(cls):
+        trim_memory()
+
+
+class TestHeap(HeapTestCase):
+
+    # On Windows malloc() increases mmap_used
+    @skipif(WINDOWS, reason="not on WINDOWS")
+    @retry_on_failure
+    def test_heap_used(self):
+        """Test that a small malloc() allocation without free()
+        increases heap_used.
+        """
+        size = HEAP_SIZE
+
+        mem1 = psutil.heap_info()
+        ptr = malloc(size)
+        mem2 = psutil.heap_info()
+
+        try:
+            # heap_used should increase (roughly) by the requested size
+            diff = mem2.heap_used - mem1.heap_used
+            assert diff > 0
+            assert_within_percent(diff, size, percent=10)
+
+            # mmap_used should not increase for small allocations, but
+            # sometimes it does.
+            diff = mem2.mmap_used - mem1.mmap_used
+            if diff != 0:
+                assert diff > 0
+                assert_within_percent(diff, size, percent=10)
+        finally:
+            free(ptr)
+
+        # assert we returned close to the baseline (mem1) after free()
+        trim_memory()
+        mem3 = psutil.heap_info()
+        assert_within_percent(mem3.heap_used, mem1.heap_used, percent=10)
+        assert_within_percent(mem3.mmap_used, mem1.mmap_used, percent=10)
+
+    @skipif(MACOS, reason="not supported on MACOS")
+    @skipif(PYPY, reason="unstable on PYPY")
+    @retry_on_failure
+    def test_mmap_used(self):
+        """Test that a large malloc allocation increases mmap_used.
+        NOTE: `mmap()` / `munmap()` via ctypes proved to be unreliable.
+        """
+        size = MMAP_SIZE
+
+        mem1 = psutil.heap_info()
+        ptr = malloc(size)
+        mem2 = psutil.heap_info()
+
+        try:
+            # mmap_used should increase (roughly) by the requested size
+            diff = mem2.mmap_used - mem1.mmap_used
+            assert diff > 0
+            assert_within_percent(diff, size, percent=10)
+
+            diff = mem2.heap_used - mem1.heap_used
+            if diff != 0:
+                if LINUX:
+                    # heap_used should not increase significantly
+                    assert diff >= 0
+                    assert_within_percent(diff, 0, percent=5)
+                else:
+                    # On BSD jemalloc allocates big memory both into
+                    # heap_used and mmap_used.
+                    assert_within_percent(diff, size, percent=10)
+
+        finally:
+            free(ptr)
+
+        # assert we returned close to the baseline (mem1) after free()
+        trim_memory()
+        mem3 = psutil.heap_info()
+        assert_within_percent(mem3.heap_used, mem1.heap_used, percent=10)
+        assert_within_percent(mem3.mmap_used, mem1.mmap_used, percent=10)
+
+        if WINDOWS:
+            assert mem1.heap_count == mem2.heap_count == mem3.heap_count
+
+
+@skipif(not WINDOWS, reason="WINDOWS only")
+@isolated
+class TestHeapWindows(HeapTestCase):
+
+    @retry_on_failure
+    def test_heap_used(self):
+        """Test that HeapAlloc() without HeapFree() increases heap_used."""
+        size = HEAP_SIZE
+
+        mem1 = psutil.heap_info()
+        heap = GetProcessHeap()
+        addr = HeapAlloc(heap, size)
+        mem2 = psutil.heap_info()
+
+        try:
+            assert mem2.heap_used - mem1.heap_used == size
+        finally:
+            HeapFree(heap, addr)
+
+        trim_memory()
+        mem3 = psutil.heap_info()
+        assert mem3.heap_used == mem1.heap_used
+
+    @retry_on_failure
+    def test_mmap_used(self):
+        """Test that VirtualAllocEx() without VirtualFreeEx() increases
+        mmap_used.
+        """
+        size = MMAP_SIZE
+
+        mem1 = psutil.heap_info()
+        addr = VirtualAllocEx(size)
+        mem2 = psutil.heap_info()
+
+        try:
+            assert mem2.mmap_used - mem1.mmap_used == size
+        finally:
+            VirtualFreeEx(addr)
+
+        trim_memory()
+        mem3 = psutil.heap_info()
+        assert mem3.mmap_used == mem1.mmap_used
+
+    @retry_on_failure
+    def test_heap_count(self):
+        """Test that HeapCreate() without HeapDestroy() increases
+        heap_count.
+        """
+        mem1 = psutil.heap_info()
+        heap = HeapCreate(HEAP_SIZE, 0)
+        mem2 = psutil.heap_info()
+        try:
+            assert mem2.heap_count == mem1.heap_count + 1
+        finally:
+            HeapDestroy(heap)
+
+        trim_memory()
+        mem3 = psutil.heap_info()
+        assert mem3.heap_count == mem1.heap_count
diff --git a/tests/test_linux.py b/tests/test_linux.py
new file mode 100755
index 0000000000..ada860ce9c
--- /dev/null
+++ b/tests/test_linux.py
@@ -0,0 +1,2651 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Linux specific tests."""
+
+import collections
+import contextlib
+import errno
+import glob
+import io
+import os
+import platform
+import re
+import shutil
+import socket
+import struct
+import textwrap
+import time
+import warnings
+from unittest import mock
+
+import psutil
+from psutil import LINUX
+from psutil import _psutil
+
+from . import AARCH64
+from . import GLOBAL_TIMEOUT
+from . import HAS_BATTERY
+from . import HAS_CPU_FREQ
+from . import HAS_PROC_RLIMIT
+from . import TOLERANCE_DISK_USAGE
+from . import TOLERANCE_SYS_MEM
+from . import PsutilTestCase
+from . import ThreadTask
+from . import call_until
+from . import is_busybox
+from . import isolated
+from . import pytest
+from . import reload_module
+from . import requires_cli
+from . import retry_on_failure
+from . import safe_rmpath
+from . import serial
+from . import sh
+from . import skip_on_not_implemented
+from . import skipif
+
+if LINUX:
+    from psutil._pslinux import CLOCK_TICKS
+    from psutil._pslinux import RootFsDeviceFinder
+    from psutil._pslinux import _cpu_get_cpuinfo_freq
+    from psutil._pslinux import _parse_cpulist
+    from psutil._pslinux import calculate_avail_vmem
+    from psutil._pslinux import open_binary
+
+
+SIOCGIFADDR = 0x8915
+SIOCGIFHWADDR = 0x8927
+SIOCGIFNETMASK = 0x891B
+SIOCGIFBRDADDR = 0x8919
+if LINUX:
+    SECTOR_SIZE = 512
+# Overlayfs and btrfs give / an anonymous device (major 0), which has
+# no /proc/partitions or /sys/dev/block entry to look up.
+ROOTFS_ON_BLOCK_DEV = LINUX and os.major(os.stat("/").st_dev) != 0
+CPUINFO_HAS_MHZ = LINUX and bool(_cpu_get_cpuinfo_freq())
+
+
+@skipif(not LINUX, reason="LINUX only")
+class LinuxTestCase(PsutilTestCase):
+    pass
+
+
+# =====================================================================
+# --- utils
+# =====================================================================
+
+
+def get_ipv4_address(ifname):
+    import fcntl
+
+    ifname = bytes(ifname[:15], "ascii")
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+        return socket.inet_ntoa(
+            fcntl.ioctl(s.fileno(), SIOCGIFADDR, struct.pack('256s', ifname))[
+                20:24
+            ]
+        )
+
+
+def get_ipv4_netmask(ifname):
+    import fcntl
+
+    ifname = bytes(ifname[:15], "ascii")
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+        return socket.inet_ntoa(
+            fcntl.ioctl(
+                s.fileno(), SIOCGIFNETMASK, struct.pack('256s', ifname)
+            )[20:24]
+        )
+
+
+def get_ipv4_broadcast(ifname):
+    import fcntl
+
+    ifname = bytes(ifname[:15], "ascii")
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+        return socket.inet_ntoa(
+            fcntl.ioctl(
+                s.fileno(), SIOCGIFBRDADDR, struct.pack('256s', ifname)
+            )[20:24]
+        )
+
+
+def get_ipv6_addresses(ifname):
+    with open("/proc/net/if_inet6") as f:
+        all_fields = []
+        for line in f:
+            fields = line.split()
+            if fields[-1] == ifname:
+                all_fields.append(fields)
+
+        if len(all_fields) == 0:
+            raise ValueError(f"could not find interface {ifname!r}")
+
+    for i in range(len(all_fields)):
+        unformatted = all_fields[i][0]
+        groups = [
+            unformatted[j : j + 4] for j in range(0, len(unformatted), 4)
+        ]
+        formatted = ":".join(groups)
+        packed = socket.inet_pton(socket.AF_INET6, formatted)
+        all_fields[i] = socket.inet_ntop(socket.AF_INET6, packed)
+    return all_fields
+
+
+def get_mac_address(ifname):
+    import fcntl
+
+    ifname = bytes(ifname[:15], "ascii")
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+        info = fcntl.ioctl(
+            s.fileno(), SIOCGIFHWADDR, struct.pack('256s', ifname)
+        )
+        return "".join([f"{char:02x}:" for char in info[18:24]])[:-1]
+
+
+def free_swap():
+    """Parse 'free' cmd and return swap memory's s total, used and free
+    values.
+    """
+    out = sh(["free", "-b"], env={"LANG": "C.UTF-8"})
+    lines = out.split('\n')
+    for line in lines:
+        if line.startswith('Swap'):
+            _, total, used, free = line.split()
+            nt = collections.namedtuple('free', 'total used free')
+            return nt(int(total), int(used), int(free))
+    raise ValueError(f"can't find 'Swap' in 'free' output:\n{out}")
+
+
+def free_physmem():
+    """Parse 'free' cmd and return physical memory's total, used
+    and free values.
+    """
+    # Note: free can have 2 different formats, invalidating 'shared'
+    # and 'cached' memory which may have different positions so we
+    # do not return them.
+    # https://github.com/giampaolo/psutil/issues/538#issuecomment-57059946
+    out = sh(["free", "-b"], env={"LANG": "C.UTF-8"})
+    lines = out.split('\n')
+    for line in lines:
+        if line.startswith('Mem'):
+            total, used, free, shared = (int(x) for x in line.split()[1:5])
+            nt = collections.namedtuple(
+                'free', 'total used free shared output'
+            )
+            return nt(total, used, free, shared, out)
+    raise ValueError(f"can't find 'Mem' in 'free' output:\n{out}")
+
+
+@requires_cli("vmstat")
+def vmstat(stat):
+    out = sh(["vmstat", "-s"], env={"LANG": "C.UTF-8"})
+    for line in out.split("\n"):
+        line = line.strip()
+        if stat in line:
+            return int(line.split(' ')[0])
+    raise ValueError(f"can't find {stat!r} in 'vmstat' output")
+
+
+def get_free_version_info():
+    if is_busybox("free"):
+        return pytest.skip("busybox free has no -V option")
+    out = sh(["free", "-V"]).strip()
+    if 'UNKNOWN' in out:
+        return pytest.skip("can't determine free version")
+    return tuple(map(int, re.findall(r'\d+', out.split()[-1])))
+
+
+@contextlib.contextmanager
+def mock_open_content(pairs):
+    """Mock open() builtin and forces it to return a certain content
+    for a given path. `pairs` is a {"path": "content", ...} dict.
+    """
+
+    def open_mock(name, *args, **kwargs):
+        if name in pairs:
+            content = pairs[name]
+            if isinstance(content, str):
+                return io.StringIO(content)
+            else:
+                return io.BytesIO(content)
+        else:
+            return orig_open(name, *args, **kwargs)
+
+    orig_open = open
+    with mock.patch("builtins.open", create=True, side_effect=open_mock) as m:
+        yield m
+
+
+@contextlib.contextmanager
+def mock_open_exception(for_path, exc):
+    """Mock open() builtin and raises `exc` if the path being opened
+    matches `for_path`.
+    """
+
+    def open_mock(name, *args, **kwargs):
+        if name == for_path:
+            raise exc
+        return orig_open(name, *args, **kwargs)
+
+    orig_open = open
+    with mock.patch("builtins.open", create=True, side_effect=open_mock) as m:
+        yield m
+
+
+# =====================================================================
+# --- system virtual memory
+# =====================================================================
+
+
+class TestVirtualMemoryAgainstFree(LinuxTestCase):
+    def test_total(self):
+        cli_value = free_physmem().total
+        psutil_value = psutil.virtual_memory().total
+        assert cli_value == psutil_value
+
+    @retry_on_failure
+    def test_used(self):
+        # Older versions of procps used slab memory to calculate used memory.
+        # This got changed in:
+        # https://gitlab.com/procps-ng/procps/-/commit/05d751c4f07
+        # Newer versions of procps (>=4.0.1) are using yet another way to
+        # compute used memory.
+        # https://gitlab.com/procps-ng/procps/-/commit/2184e90d2e7
+        if get_free_version_info() < (4, 0, 1):
+            return pytest.skip("free version too old")
+        cli_value = free_physmem().used
+        psutil_value = psutil.virtual_memory().used
+        assert abs(cli_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_free(self):
+        cli_value = free_physmem().free
+        psutil_value = psutil.virtual_memory().free
+        assert abs(cli_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_shared(self):
+        free = free_physmem()
+        free_value = free.shared
+        if free_value == 0:
+            return pytest.skip("free does not support 'shared' column")
+        psutil_value = psutil.virtual_memory().shared
+        assert (
+            abs(free_value - psutil_value) < TOLERANCE_SYS_MEM
+        ), f"{free_value} {psutil_value} \n{free.output}"
+
+    @retry_on_failure
+    def test_available(self):
+        # "free" output format has changed at some point:
+        # https://github.com/giampaolo/psutil/issues/538#issuecomment-147192098
+        out = sh(["free", "-b"])
+        lines = out.split('\n')
+        if 'available' not in lines[0]:
+            return pytest.skip("free does not support 'available' column")
+        free_value = int(lines[1].split()[-1])
+        psutil_value = psutil.virtual_memory().available
+        assert abs(free_value - psutil_value) < TOLERANCE_SYS_MEM
+
+
+class TestVirtualMemoryAgainstVmstat(LinuxTestCase):
+    def test_total(self):
+        vmstat_value = vmstat('total memory') * 1024
+        psutil_value = psutil.virtual_memory().total
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_used(self):
+        # Older versions of procps used slab memory to calculate used memory.
+        # This got changed in:
+        # https://gitlab.com/procps-ng/procps/-/commit/05d751c4f07
+        # Newer versions of procps (>=4.0.1) are using yet another way to
+        # compute used memory.
+        # https://gitlab.com/procps-ng/procps/-/commit/2184e90d2e7
+        if get_free_version_info() < (4, 0, 1):
+            return pytest.skip("free version too old")
+        vmstat_value = vmstat('used memory') * 1024
+        psutil_value = psutil.virtual_memory().used
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_free(self):
+        vmstat_value = vmstat('free memory') * 1024
+        psutil_value = psutil.virtual_memory().free
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_buffers(self):
+        vmstat_value = vmstat('buffer memory') * 1024
+        psutil_value = psutil.virtual_memory().buffers
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_active(self):
+        vmstat_value = vmstat('active memory') * 1024
+        psutil_value = psutil.virtual_memory().active
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_inactive(self):
+        vmstat_value = vmstat('inactive memory') * 1024
+        psutil_value = psutil.virtual_memory().inactive
+        assert abs(vmstat_value - psutil_value) < TOLERANCE_SYS_MEM
+
+
+class TestVirtualMemoryAgainstMeminfo(LinuxTestCase):
+    @staticmethod
+    def read_meminfo():
+        mems = {}
+        with open("/proc/meminfo") as f:
+            for line in f:
+                fields = line.split()
+                if len(fields) >= 2:
+                    mems[fields[0]] = int(fields[1]) * 1024
+        return mems
+
+    @retry_on_failure
+    def test_buffers(self):
+        proc_value = self.read_meminfo()["Buffers:"]
+        psutil_value = psutil.virtual_memory().buffers
+        assert abs(psutil_value - proc_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_cached(self):
+        # psutil cached = Cached + SReclaimable
+        mems = self.read_meminfo()
+        proc_value = mems["Cached:"] + mems.get("SReclaimable:", 0)
+        psutil_value = psutil.virtual_memory().cached
+        assert abs(psutil_value - proc_value) < TOLERANCE_SYS_MEM
+
+
+class TestVirtualMemoryMocks(LinuxTestCase):
+    def test_warnings_on_misses(self):
+        # Emulate a case where /proc/meminfo provides few info.
+        # psutil is supposed to set the missing fields to 0 and
+        # raise a warning.
+        content = textwrap.dedent("""\
+            Active(anon):    6145416 kB
+            Active(file):    2950064 kB
+            Inactive(anon):   574764 kB
+            Inactive(file):  1567648 kB
+            MemAvailable:         -1 kB
+            MemFree:         2057400 kB
+            MemTotal:       16325648 kB
+            SReclaimable:     346648 kB
+            """).encode()
+        with mock_open_content({'/proc/meminfo': content}) as m:
+            with warnings.catch_warnings(record=True) as ws:
+                warnings.simplefilter("always")
+                ret = psutil.virtual_memory()
+                assert m.called
+                assert len(ws) == 1
+                w = ws[0]
+                assert "memory stats couldn't be determined" in str(w.message)
+                assert "cached" in str(w.message)
+                assert "shared" in str(w.message)
+                assert "active" in str(w.message)
+                assert "inactive" in str(w.message)
+                assert "buffers" in str(w.message)
+                assert "available" in str(w.message)
+                assert ret.cached == 0
+                assert ret.active == 0
+                assert ret.inactive == 0
+                assert ret.shared == 0
+                assert ret.buffers == 0
+                assert ret.available == 0
+                assert ret.slab == 0
+
+    @retry_on_failure
+    def test_avail_old_percent(self):
+        # Make sure that our calculation of avail mem for old kernels
+        # is off by max 15%.
+        mems = {}
+        with open_binary('/proc/meminfo') as f:
+            for line in f:
+                fields = line.split()
+                mems[fields[0]] = int(fields[1]) * 1024
+
+        a = calculate_avail_vmem(mems)
+        if b'MemAvailable:' in mems:
+            b = mems[b'MemAvailable:']
+            diff_percent = abs(a - b) / a * 100
+            assert diff_percent < 15
+
+    def test_avail_old_comes_from_kernel(self):
+        # Make sure "MemAvailable:" coluimn is used instead of relying
+        # on our internal algorithm to calculate avail mem.
+        content = textwrap.dedent("""\
+            Active:          9444728 kB
+            Active(anon):    6145416 kB
+            Active(file):    2950064 kB
+            Buffers:          287952 kB
+            Cached:          4818144 kB
+            Inactive(file):  1578132 kB
+            Inactive(anon):   574764 kB
+            Inactive(file):  1567648 kB
+            MemAvailable:    6574984 kB
+            MemFree:         2057400 kB
+            MemTotal:       16325648 kB
+            Shmem:            577588 kB
+            SReclaimable:     346648 kB
+            """).encode()
+        with mock_open_content({'/proc/meminfo': content}) as m:
+            with warnings.catch_warnings(record=True) as ws:
+                ret = psutil.virtual_memory()
+            assert m.called
+            assert ret.available == 6574984 * 1024
+            w = ws[0]
+            assert "inactive memory stats couldn't be determined" in str(
+                w.message
+            )
+
+    def test_avail_old_missing_fields(self):
+        # Remove Active(file), Inactive(file) and SReclaimable
+        # from /proc/meminfo and make sure the fallback is used
+        # (free + cached),
+        content = textwrap.dedent("""\
+            Active:          9444728 kB
+            Active(anon):    6145416 kB
+            Buffers:          287952 kB
+            Cached:          4818144 kB
+            Inactive(file):  1578132 kB
+            Inactive(anon):   574764 kB
+            MemFree:         2057400 kB
+            MemTotal:       16325648 kB
+            Shmem:            577588 kB
+            """).encode()
+        with mock_open_content({"/proc/meminfo": content}) as m:
+            with warnings.catch_warnings(record=True) as ws:
+                ret = psutil.virtual_memory()
+            assert m.called
+            assert ret.available == 2057400 * 1024 + 4818144 * 1024
+            w = ws[0]
+            assert "inactive memory stats couldn't be determined" in str(
+                w.message
+            )
+
+    def test_avail_old_missing_zoneinfo(self):
+        # Remove /proc/zoneinfo file. Make sure fallback is used
+        # (free + cached).
+        content = textwrap.dedent("""\
+            Active:          9444728 kB
+            Active(anon):    6145416 kB
+            Active(file):    2950064 kB
+            Buffers:          287952 kB
+            Cached:          4818144 kB
+            Inactive(file):  1578132 kB
+            Inactive(anon):   574764 kB
+            Inactive(file):  1567648 kB
+            MemFree:         2057400 kB
+            MemTotal:       16325648 kB
+            Shmem:            577588 kB
+            SReclaimable:     346648 kB
+            """).encode()
+        with mock_open_content({"/proc/meminfo": content}):
+            with mock_open_exception("/proc/zoneinfo", FileNotFoundError):
+                with warnings.catch_warnings(record=True) as ws:
+                    ret = psutil.virtual_memory()
+                    assert ret.available == 2057400 * 1024 + 4818144 * 1024
+                    w = ws[0]
+                    assert (
+                        "inactive memory stats couldn't be determined"
+                        in str(w.message)
+                    )
+
+    def test_virtual_memory_mocked(self):
+        # Emulate /proc/meminfo because neither vmstat nor free return slab.
+        content = textwrap.dedent("""\
+            MemTotal:              100 kB
+            MemFree:               2 kB
+            MemAvailable:          3 kB
+            Buffers:               4 kB
+            Cached:                5 kB
+            SwapCached:            6 kB
+            Active:                7 kB
+            Inactive:              8 kB
+            Active(anon):          9 kB
+            Inactive(anon):        10 kB
+            Active(file):          11 kB
+            Inactive(file):        12 kB
+            Unevictable:           13 kB
+            Mlocked:               14 kB
+            SwapTotal:             15 kB
+            SwapFree:              16 kB
+            Dirty:                 17 kB
+            Writeback:             18 kB
+            AnonPages:             19 kB
+            Mapped:                20 kB
+            Shmem:                 21 kB
+            Slab:                  22 kB
+            SReclaimable:          23 kB
+            SUnreclaim:            24 kB
+            KernelStack:           25 kB
+            PageTables:            26 kB
+            NFS_Unstable:          27 kB
+            Bounce:                28 kB
+            WritebackTmp:          29 kB
+            CommitLimit:           30 kB
+            Committed_AS:          31 kB
+            VmallocTotal:          32 kB
+            VmallocUsed:           33 kB
+            VmallocChunk:          34 kB
+            HardwareCorrupted:     35 kB
+            AnonHugePages:         36 kB
+            ShmemHugePages:        37 kB
+            ShmemPmdMapped:        38 kB
+            CmaTotal:              39 kB
+            CmaFree:               40 kB
+            HugePages_Total:       41 kB
+            HugePages_Free:        42 kB
+            HugePages_Rsvd:        43 kB
+            HugePages_Surp:        44 kB
+            Hugepagesize:          45 kB
+            DirectMap46k:          46 kB
+            DirectMap47M:          47 kB
+            DirectMap48G:          48 kB
+            """).encode()
+        with mock_open_content({"/proc/meminfo": content}) as m:
+            mem = psutil.virtual_memory()
+            assert m.called
+            assert mem.total == 100 * 1024
+            assert mem.free == 2 * 1024
+            assert mem.buffers == 4 * 1024
+            # cached mem also includes reclaimable memory
+            assert mem.cached == (5 + 23) * 1024
+            assert mem.shared == 21 * 1024
+            assert mem.active == 7 * 1024
+            assert mem.inactive == 8 * 1024
+            assert mem.slab == 22 * 1024
+            assert mem.available == 3 * 1024
+
+    def test_virtual_memory_no_space_after_colon(self):
+        """Some Linux meminfo fields may not have a space after the colon:
+        https://github.com/torvalds/linux/blob/8356a5a3b078ca89c526dd6d71e9a76fec571c37/fs/proc/meminfo.c#L113-L116
+        """
+        content = textwrap.dedent("""\
+            MemTotal:              100 kB
+            MemFree:               2 kB
+            MemAvailable:          3 kB
+            Buffers:               4 kB
+            Cached:                5 kB
+            Active:                6 kB
+            Inactive:              7 kB
+            Shmem:                 8 kB
+            Slab:                  9 kB
+            ShadowCallStack:10373888 kB
+            """).encode()
+        with mock_open_content({"/proc/meminfo": content}) as m:
+            mem = psutil.virtual_memory()
+            assert m.called
+            assert mem.total == 100 * 1024
+
+
+# =====================================================================
+# --- system swap memory
+# =====================================================================
+
+
+class TestSwapMemory(LinuxTestCase):
+    @staticmethod
+    def meminfo_has_swap_info():
+        """Return True if /proc/meminfo provides swap metrics."""
+        with open("/proc/meminfo") as f:
+            data = f.read()
+        return 'SwapTotal:' in data and 'SwapFree:' in data
+
+    def test_total(self):
+        free_value = free_swap().total
+        psutil_value = psutil.swap_memory().total
+        assert abs(free_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_used(self):
+        free_value = free_swap().used
+        psutil_value = psutil.swap_memory().used
+        assert abs(free_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_free(self):
+        free_value = free_swap().free
+        psutil_value = psutil.swap_memory().free
+        assert abs(free_value - psutil_value) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_sin_sout(self):
+        # Cross-check sin/sout against /proc/vmstat pswpin/pswpout fields.
+        # psutil converts pages to bytes using a 4096-byte page size.
+        PAGE_SIZE = 4 * 1024
+        with open("/proc/vmstat") as f:
+            vmstat = dict(line.split() for line in f if line.split())
+        sin = int(vmstat["pswpin"]) * PAGE_SIZE
+        sout = int(vmstat["pswpout"]) * PAGE_SIZE
+        swap = psutil.swap_memory()
+        assert swap.sin == sin
+        assert swap.sout == sout
+
+    def test_missing_sin_sout(self):
+        with mock.patch('psutil._common.open', create=True) as m:
+            with warnings.catch_warnings(record=True) as ws:
+                warnings.simplefilter("always")
+                ret = psutil.swap_memory()
+                assert m.called
+                assert len(ws) == 1
+                w = ws[0]
+                assert (
+                    "'sin' and 'sout' swap memory stats couldn't be determined"
+                    in str(w.message)
+                )
+                assert ret.sin == 0
+                assert ret.sout == 0
+
+    def test_no_vmstat_mocked(self):
+        # see https://github.com/giampaolo/psutil/issues/722
+        with mock_open_exception("/proc/vmstat", FileNotFoundError) as m:
+            with warnings.catch_warnings(record=True) as ws:
+                warnings.simplefilter("always")
+                ret = psutil.swap_memory()
+                assert m.called
+                assert len(ws) == 1
+                w = ws[0]
+                assert (
+                    "'sin' and 'sout' swap memory stats couldn't "
+                    "be determined and were set to 0"
+                    in str(w.message)
+                )
+                assert ret.sin == 0
+                assert ret.sout == 0
+
+    def test_meminfo_against_sysinfo(self):
+        # Make sure the content of /proc/meminfo about swap memory
+        # matches sysinfo() syscall, see:
+        # https://github.com/giampaolo/psutil/issues/1015
+        if not self.meminfo_has_swap_info():
+            return pytest.skip("/proc/meminfo has no swap metrics")
+        with mock.patch.object(_psutil, 'linux_sysinfo') as m:
+            swap = psutil.swap_memory()
+        assert not m.called
+
+        _, _, _, _, total, free, unit_multiplier = _psutil.linux_sysinfo()
+        total *= unit_multiplier
+        free *= unit_multiplier
+        assert swap.total == total
+        assert abs(swap.free - free) < TOLERANCE_SYS_MEM
+
+    def test_emulate_meminfo_has_no_metrics(self):
+        # Emulate a case where /proc/meminfo provides no swap metrics
+        # in which case sysinfo() syscall is supposed to be used
+        # as a fallback.
+        with mock_open_content({"/proc/meminfo": b""}) as m:
+            psutil.swap_memory()
+            assert m.called
+
+    def test_no_space_after_colon(self):
+        # Some Linux meminfo fields may not have a space after the
+        # colon, see:
+        # https://github.com/giampaolo/psutil/issues/2809
+        content = textwrap.dedent("""\
+            MemTotal:              100 kB
+            MemFree:               2 kB
+            SwapTotal:             15 kB
+            SwapFree:              14 kB
+            ShadowCallStack:10373888 kB
+            """).encode()
+        with mock_open_content({"/proc/meminfo": content}) as m:
+            swap = psutil.swap_memory()
+            assert m.called
+            assert swap.total == 15 * 1024
+            assert swap.free == 14 * 1024
+
+
+# =====================================================================
+# --- system CPU
+# =====================================================================
+
+
+class TestCpuCountLogical(LinuxTestCase):
+    @skipif(
+        not os.path.exists("/sys/devices/system/cpu/online"),
+        reason="/sys/devices/system/cpu/online does not exist",
+    )
+    def test_against_sysdev_cpu_online(self):
+        with open("/sys/devices/system/cpu/online") as f:
+            value = f.read().strip()
+        if "-" in str(value):
+            value = int(value.split('-')[1]) + 1
+            assert psutil.cpu_count() == value
+
+    @skipif(
+        not os.path.exists("/sys/devices/system/cpu"),
+        reason="/sys/devices/system/cpu does not exist",
+    )
+    def test_against_sysdev_cpu_num(self):
+        # The kernel creates a directory for every *possible* CPU, so
+        # this is an upper bound: cpu_count() counts the online ones.
+        ls = os.listdir("/sys/devices/system/cpu")
+        count = len([x for x in ls if re.search(r"cpu\d+$", x) is not None])
+        assert psutil.cpu_count() <= count
+
+    @requires_cli("nproc")
+    def test_against_nproc(self):
+        num = int(sh("nproc"))
+        assert psutil.cpu_count(logical=True) == num
+
+    @requires_cli("lscpu")
+    def test_against_lscpu(self):
+        out = sh("lscpu -p")
+        num = len([x for x in out.split('\n') if not x.startswith('#')])
+        assert psutil.cpu_count(logical=True) == num
+
+    def test_emulate_fallbacks(self):
+        import psutil._pslinux
+
+        original = psutil._pslinux.cpu_count_logical()
+        # Here we want to mock os.sysconf("SC_NPROCESSORS_ONLN") in
+        # order to cause the parsing of /proc/cpuinfo and /proc/stat.
+        with mock.patch(
+            'psutil._pslinux.os.sysconf', side_effect=ValueError
+        ) as m:
+            assert psutil._pslinux.cpu_count_logical() == original
+            assert m.called
+
+            # Let's have open() return empty data and make sure None is
+            # returned ('cause we mimic os.cpu_count()).
+            with mock.patch('psutil._common.open', create=True) as m:
+                assert psutil._pslinux.cpu_count_logical() is None
+                assert m.call_count == 2
+                # /proc/stat should be the last one
+                assert m.call_args[0][0] == '/proc/stat'
+
+            # Let's push this a bit further and make sure /proc/cpuinfo
+            # parsing works as expected.
+            with open('/proc/cpuinfo', 'rb') as f:
+                cpuinfo_data = f.read()
+            with mock_open_content({"/proc/cpuinfo": cpuinfo_data}) as m:
+                assert psutil._pslinux.cpu_count_logical() == original
+                assert m.called
+
+            # Finally, let's make /proc/cpuinfo return meaningless data;
+            # this way we'll fall back on relying on /proc/stat
+            with mock_open_content({"/proc/cpuinfo": b""}) as m:
+                assert psutil._pslinux.cpu_count_logical() == original
+                assert m.called
+
+
+class TestCpuCountCores(LinuxTestCase):
+    @requires_cli("lscpu")
+    def test_against_lscpu(self):
+        pairs = []
+        per_socket = ""
+        for line in sh("lscpu").splitlines():
+            key, _, value = line.partition(":")
+            key, value = key.strip(), value.strip()
+            if key == "Core(s) per socket":
+                per_socket = value
+            elif key == "Socket(s)":
+                pairs.append((per_socket, value))
+        # In a VM lscpu may print "-" instead of a number.
+        if not pairs or not all(x.isdigit() and y.isdigit() for x, y in pairs):
+            return pytest.skip("lscpu doesn't report the number of cores")
+        cores = sum(int(x) * int(y) for x, y in pairs)
+        assert psutil.cpu_count(logical=False) == cores
+
+    @skipif(
+        platform.machine() not in {"x86_64", "i686"}, reason="x86_64/i686 only"
+    )
+    def test_method_2(self):
+        meth_1 = psutil._pslinux.cpu_count_cores()
+        with mock.patch('glob.glob', return_value=[]) as m:
+            meth_2 = psutil._pslinux.cpu_count_cores()
+            assert m.called
+        if meth_1 is not None:
+            assert meth_1 == meth_2
+
+    def test_emulate_none(self):
+        with mock.patch('glob.glob', return_value=[]) as m1:
+            with mock.patch('psutil._common.open', create=True) as m2:
+                assert psutil._pslinux.cpu_count_cores() is None
+        assert m1.called
+        assert m2.called
+
+
+class TestCpuFreq(LinuxTestCase):
+    def test_cpuinfo_freq_ppc(self):
+        content = b"clock\t\t: 2750.000000MHz\nclock\t\t: 2500.000000MHz\n"
+        with mock_open_content({"/proc/cpuinfo": content}):
+            assert _cpu_get_cpuinfo_freq() == [2750.0, 2500.0]
+
+    def test_cpuinfo_freq_s390x(self):
+        content = (
+            b"cpu MHz dynamic : 5200\ncpu MHz static  : 5000\n"
+            b"cpu MHz dynamic : 5100\ncpu MHz static  : 5000\n"
+        )
+        with mock_open_content({"/proc/cpuinfo": content}):
+            assert _cpu_get_cpuinfo_freq() == [5200.0, 5100.0]
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    @skipif(AARCH64, reason="aarch64 does not always expose frequency")
+    def test_emulate_use_second_file(self):
+        # https://github.com/giampaolo/psutil/issues/981
+        def path_exists_mock(path):
+            if path.startswith("/sys/devices/system/cpu/cpufreq/policy"):
+                return False
+            else:
+                return orig_exists(path)
+
+        orig_exists = os.path.exists
+        with mock.patch(
+            "os.path.exists", side_effect=path_exists_mock, create=True
+        ):
+            assert psutil.cpu_freq()
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    @skipif(not CPUINFO_HAS_MHZ, reason="no 'cpu MHz' in /proc/cpuinfo")
+    def test_emulate_use_cpuinfo(self):
+        # Emulate a case where /sys/devices/system/cpu/cpufreq* does not
+        # exist and /proc/cpuinfo is used instead.
+        def path_exists_mock(path):
+            if path.startswith('/sys/devices/system/cpu/'):
+                return False
+            else:
+                return os_path_exists(path)
+
+        os_path_exists = os.path.exists
+        try:
+            with mock.patch("os.path.exists", side_effect=path_exists_mock):
+                reload_module(psutil._pslinux)
+                ret = psutil.cpu_freq()
+                assert ret, ret
+                assert ret.max == 0.0
+                assert ret.min == 0.0
+                for freq in psutil.cpu_freq(percpu=True):
+                    assert freq.max == 0.0
+                    assert freq.min == 0.0
+        finally:
+            reload_module(psutil._pslinux)
+            reload_module(psutil)
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    def test_emulate_data(self):
+        def open_mock(name, *args, **kwargs):
+            if name.endswith('/scaling_cur_freq') and name.startswith(
+                "/sys/devices/system/cpu/cpufreq/policy"
+            ):
+                return io.BytesIO(b"500000")
+            elif name.endswith('/scaling_min_freq') and name.startswith(
+                "/sys/devices/system/cpu/cpufreq/policy"
+            ):
+                return io.BytesIO(b"600000")
+            elif name.endswith('/scaling_max_freq') and name.startswith(
+                "/sys/devices/system/cpu/cpufreq/policy"
+            ):
+                return io.BytesIO(b"700000")
+            elif name == '/proc/cpuinfo':
+                return io.BytesIO(b"cpu MHz     : 500")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock):
+            with mock.patch('os.path.exists', return_value=True):
+                freq = psutil.cpu_freq()
+                assert freq.current == 500.0
+                # when /proc/cpuinfo is used min and max frequencies are not
+                # available and are set to 0.
+                if freq.min != 0.0:
+                    assert freq.min == 600.0
+                if freq.max != 0.0:
+                    assert freq.max == 700.0
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    def test_emulate_multi_cpu(self):
+        def open_mock(name, *args, **kwargs):
+            n = name
+            if n.endswith('/scaling_cur_freq') and n.startswith(
+                "/sys/devices/system/cpu/cpufreq/policy0"
+            ):
+                return io.BytesIO(b"100000")
+            elif n.endswith('/scaling_min_freq') and n.startswith(
+                "/sys/devices/system/cpu/cpufreq/policy0"
+            ):
+                return io.BytesIO(b"200000")
+            elif n.endswith('/scaling_max_freq') and n.startswith(
+                "/sys/devices/system/cpu/cpufreq/policy0"
+            ):
+                return io.BytesIO(b"300000")
+            elif n.endswith('/scaling_cur_freq') and n.startswith(
+                "/sys/devices/system/cpu/cpufreq/policy1"
+            ):
+                return io.BytesIO(b"400000")
+            elif n.endswith('/scaling_min_freq') and n.startswith(
+                "/sys/devices/system/cpu/cpufreq/policy1"
+            ):
+                return io.BytesIO(b"500000")
+            elif n.endswith('/scaling_max_freq') and n.startswith(
+                "/sys/devices/system/cpu/cpufreq/policy1"
+            ):
+                return io.BytesIO(b"600000")
+            elif n.endswith('/affected_cpus'):
+                return io.BytesIO(b"0" if "/policy0/" in n else b"1")
+            elif name == '/proc/cpuinfo':
+                return io.BytesIO(b"cpu MHz     : 100\ncpu MHz     : 400")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        def glob_mock(pattern):
+            if pattern == "/sys/devices/system/cpu/cpufreq/policy[0-9]*":
+                return list(policies)
+            return orig_glob(pattern)
+
+        policies = [
+            f"/sys/devices/system/cpu/cpufreq/policy{n}" for n in range(2)
+        ]
+        orig_glob = glob.glob
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock):
+            with mock.patch('os.path.exists', return_value=True):
+                with mock.patch("glob.glob", side_effect=glob_mock):
+                    # min and max are 0 when the /proc/cpuinfo-only
+                    # implementation is in use, e.g. in a container
+                    # with no /sys/devices/system/cpu/cpufreq.
+                    freq = psutil.cpu_freq(percpu=True)
+                    assert freq[0].current == 100.0
+                    if freq[0].min != 0.0:
+                        assert freq[0].min == 200.0
+                    if freq[0].max != 0.0:
+                        assert freq[0].max == 300.0
+                    assert freq[1].current == 400.0
+                    if freq[1].min != 0.0:
+                        assert freq[1].min == 500.0
+                    if freq[1].max != 0.0:
+                        assert freq[1].max == 600.0
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    def test_emulate_shared_policy(self):
+        # A single policy governing 4 CPUs must yield 4 entries, see:
+        # https://github.com/giampaolo/psutil/issues/2512
+        def open_mock(name, *args, **kwargs):
+            if name.endswith('/affected_cpus'):
+                return io.BytesIO(b"0 1 2 3")
+            elif name.endswith('/scaling_cur_freq'):
+                return io.BytesIO(b"100000")
+            elif name.endswith('/scaling_min_freq'):
+                return io.BytesIO(b"200000")
+            elif name.endswith('/scaling_max_freq'):
+                return io.BytesIO(b"300000")
+            elif name == '/proc/cpuinfo':
+                return io.BytesIO(b"")
+            return orig_open(name, *args, **kwargs)
+
+        def glob_mock(pattern):
+            if pattern == "/sys/devices/system/cpu/cpufreq/policy[0-9]*":
+                return ["/sys/devices/system/cpu/cpufreq/policy0"]
+            return orig_glob(pattern)
+
+        def exists_mock(path):
+            # Make sure the sysfs-based implementation is used.
+            if path.startswith("/sys/devices/system/cpu/"):
+                return True
+            return orig_exists(path)
+
+        orig_exists = os.path.exists
+        orig_glob = glob.glob
+        orig_open = open
+        try:
+            with mock.patch("os.path.exists", side_effect=exists_mock):
+                reload_module(psutil._pslinux)
+                with mock.patch("glob.glob", side_effect=glob_mock):
+                    with mock.patch("builtins.open", side_effect=open_mock):
+                        freq = psutil.cpu_freq(percpu=True)
+            assert len(freq) == 4
+            for nt in freq:
+                assert nt == (100.0, 200.0, 300.0)
+        finally:
+            reload_module(psutil._pslinux)
+            reload_module(psutil)
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    def test_emulate_no_scaling_cur_freq_file(self):
+        # See: https://github.com/giampaolo/psutil/issues/1071
+        def open_mock(name, *args, **kwargs):
+            if name.endswith('/scaling_cur_freq'):
+                raise FileNotFoundError
+            if name.endswith('/cpuinfo_cur_freq'):
+                return io.BytesIO(b"200000")
+            elif name == '/proc/cpuinfo':
+                return io.BytesIO(b"cpu MHz     : 200")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock):
+            with mock.patch('os.path.exists', return_value=True):
+                with mock.patch(
+                    'psutil._pslinux.cpu_count_logical', return_value=1
+                ):
+                    freq = psutil.cpu_freq()
+                    assert freq.current == 200
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    def test_emulate_offline_cpus(self):
+        # Offline CPU cores must not be taken into account, else they
+        # drag down the average frequency. See:
+        # https://github.com/giampaolo/psutil/issues/2628
+        policies = [
+            f"/sys/devices/system/cpu/cpufreq/policy{n}" for n in range(4)
+        ]
+
+        def exists_mock(path):
+            # Make sure the sysfs-based implementation is used.
+            if path.startswith("/sys/devices/system/cpu/"):
+                return True
+            return orig_exists(path)
+
+        def glob_mock(pattern):
+            if pattern == "/sys/devices/system/cpu/cpufreq/policy[0-9]*":
+                return list(policies)
+            return orig_glob(pattern)
+
+        def open_mock(name, *args, **kwargs):
+            # Only CPUs 0 and 1 are online; 2 and 3 are offline.
+            if name == '/proc/cpuinfo':
+                return io.BytesIO(b"cpu MHz\t: 200\ncpu MHz\t: 400")
+            elif name.endswith('/affected_cpus'):
+                num = re.search(r"/policy(\d+)/", name).group(1)
+                return io.BytesIO(num.encode())
+            elif "/policy0/" in name or "/policy1/" in name:
+                if name.endswith('/scaling_cur_freq'):
+                    cur = b"200000" if "/policy0/" in name else b"400000"
+                    return io.BytesIO(cur)
+                elif name.endswith('/scaling_min_freq'):
+                    return io.BytesIO(b"100000")
+                elif name.endswith('/scaling_max_freq'):
+                    return io.BytesIO(b"300000")
+            elif "/policy2/" in name or "/policy3/" in name:
+                # Offline cores have no frequency files.
+                if name.endswith(('/scaling_cur_freq', '/cpuinfo_cur_freq')):
+                    raise FileNotFoundError
+            elif name.endswith('/online'):
+                # CPUs 2 and 3 are offline.
+                return io.StringIO("0\n")
+            return orig_open(name, *args, **kwargs)
+
+        orig_exists = os.path.exists
+        orig_glob = glob.glob
+        orig_open = open
+        try:
+            with mock.patch("os.path.exists", side_effect=exists_mock):
+                reload_module(psutil._pslinux)
+                with mock.patch("glob.glob", side_effect=glob_mock):
+                    with mock.patch("builtins.open", side_effect=open_mock):
+                        percpu = psutil.cpu_freq(percpu=True)
+                        assert len(percpu) == 2
+                        assert [f.current for f in percpu] == [200.0, 400.0]
+
+                        freq = psutil.cpu_freq()
+                        assert freq.current == 300.0
+                        assert freq.min == 100.0
+                        assert freq.max == 300.0
+        finally:
+            reload_module(psutil._pslinux)
+            reload_module(psutil)
+
+
+class TestCpuTimes(LinuxTestCase):
+
+    @retry_on_failure
+    def test_against_proc_stat(self):
+        with open("/proc/stat") as f:
+            line = f.readline()
+        ticks = [float(x) for x in line.split()[1:]]
+        fields = [t / CLOCK_TICKS for t in ticks]
+        ct = psutil.cpu_times()
+        TOLERANCE = 1  # 1 second
+        assert abs(ct.user - fields[0]) < TOLERANCE
+        assert abs(ct.nice - fields[1]) < TOLERANCE
+        assert abs(ct.system - fields[2]) < TOLERANCE
+        assert abs(ct.idle - fields[3]) < TOLERANCE
+        assert abs(ct.iowait - fields[4]) < TOLERANCE
+        assert abs(ct.irq - fields[5]) < TOLERANCE
+        assert abs(ct.softirq - fields[6]) < TOLERANCE
+        assert abs(ct.steal - fields[7]) < TOLERANCE
+
+
+class TestCpuStats(LinuxTestCase):
+
+    @staticmethod
+    def assert_close_to_vmstat(vmstat_value, psutil_value):
+        # Old procps keeps these counters in 32 bits, so it wraps once
+        # the kernel goes past 2**32 and psutil doesn't.
+        if psutil_value >= 2**32 and vmstat_value < 2**32:
+            return pytest.skip("vmstat truncated the counter to 32 bits")
+        assert abs(vmstat_value - psutil_value) < 500
+
+    @isolated
+    def test_ctx_switches(self):
+        vmstat_value = vmstat("context switches")
+        psutil_value = psutil.cpu_stats().ctx_switches
+        self.assert_close_to_vmstat(vmstat_value, psutil_value)
+
+    @isolated
+    def test_interrupts(self):
+        vmstat_value = vmstat("interrupts")
+        psutil_value = psutil.cpu_stats().interrupts
+        self.assert_close_to_vmstat(vmstat_value, psutil_value)
+
+
+class TestLoadAvg(LinuxTestCase):
+    def test_getloadavg(self):
+        psutil_value = psutil.getloadavg()
+        with open("/proc/loadavg") as f:
+            proc_value = f.read().split()
+
+        assert abs(float(proc_value[0]) - psutil_value[0]) < 1
+        assert abs(float(proc_value[1]) - psutil_value[1]) < 1
+        assert abs(float(proc_value[2]) - psutil_value[2]) < 1
+
+
+# =====================================================================
+# --- system network
+# =====================================================================
+
+
+class TestNetIfAddrs(LinuxTestCase):
+    def test_ips(self):
+        for name, addrs in psutil.net_if_addrs().items():
+            for addr in addrs:
+                if addr.family == psutil.AF_LINK:
+                    assert addr.address == get_mac_address(name)
+                elif addr.family == socket.AF_INET:
+                    assert addr.address == get_ipv4_address(name)
+                    assert addr.netmask == get_ipv4_netmask(name)
+                    if addr.broadcast is not None:
+                        assert addr.broadcast == get_ipv4_broadcast(name)
+                    else:
+                        # SIOCGIFBRDADDR shares a union with the peer
+                        # address, so on a /32 it echoes the address
+                        # back and on a ptp link it gives the peer.
+                        assert get_ipv4_broadcast(name) in {
+                            '0.0.0.0',
+                            addr.address,
+                            addr.ptp,
+                        }
+                elif addr.family == socket.AF_INET6:
+                    # IPv6 addresses can have a percent symbol at the end.
+                    # E.g. these 2 are equivalent:
+                    # "fe80::1ff:fe23:4567:890a"
+                    # "fe80::1ff:fe23:4567:890a%eth0"
+                    # That is the "zone id" portion, which usually is the name
+                    # of the network interface.
+                    address = addr.address.split('%')[0]
+                    assert address in get_ipv6_addresses(name)
+
+    @requires_cli("ip")
+    @retry_on_failure
+    def test_against_ip_addr_v4(self):
+        # Parse IPv4 addresses per interface from `ip addr` output and
+        # compare against psutil. Use the label at the end of each inet
+        # line as the interface name, since it reflects aliases like
+        # "vboxnet0:avahi" that psutil also uses as keys.
+        out = sh("ip addr")
+        ip_addrs = {}  # {ifname: [addr, ...]}
+        for line in out.splitlines():
+            # "    inet 1.2.3.4/24 brd ... scope global eth0"
+            m = re.match(r'^\s+inet\s+(\S+).*\s+(\S+)$', line)
+            if m:
+                addr = m.group(1).split('/')[0]
+                ifname = m.group(2)
+                ip_addrs.setdefault(ifname, []).append(addr)
+        psutil_addrs = psutil.net_if_addrs()
+        for ifname, addrs in ip_addrs.items():
+            if ifname not in psutil_addrs:
+                continue
+            psutil_ipv4 = {
+                a.address
+                for a in psutil_addrs[ifname]
+                if a.family == socket.AF_INET
+            }
+            for addr in addrs:
+                assert addr in psutil_ipv4
+
+    @requires_cli("ip")
+    @retry_on_failure
+    def test_against_ip_addr_v6(self):
+        # Parse IPv6 addresses per interface from `ip addr` output and
+        # compare against psutil. Unlike inet, inet6 lines have no label,
+        # so the interface name comes from the header line.
+        out = sh("ip addr")
+        ip_addrs = {}  # {ifname: [addr, ...]}
+        current_if = None
+        for line in out.splitlines():
+            m = re.match(r'^\d+:\s+(\S+):', line)
+            if m:
+                current_if = m.group(1).rstrip(':')
+            m = re.match(r'^\s+inet6\s+(\S+)', line)
+            if m and current_if:
+                addr = m.group(1).split('/')[0]
+                ip_addrs.setdefault(current_if, []).append(addr)
+        psutil_addrs = psutil.net_if_addrs()
+        for ifname, addrs in ip_addrs.items():
+            if ifname not in psutil_addrs:
+                continue
+            # psutil may append %ifname zone ID to link-local addresses.
+            psutil_ipv6 = {
+                a.address.split('%')[0]
+                for a in psutil_addrs[ifname]
+                if a.family == socket.AF_INET6
+            }
+            for addr in addrs:
+                assert addr in psutil_ipv6
+
+    @requires_cli("ip")
+    def test_net_if_names(self):
+        out = sh("ip addr").strip()
+        nics = [x for x in psutil.net_if_addrs() if ':' not in x]
+        found = 0
+        for line in out.split('\n'):
+            line = line.strip()
+            if re.search(r"^\d+:", line):
+                found += 1
+                name = line.split(':')[1].strip().split('@')[0]
+                assert name in nics
+        assert len(nics) == found
+
+
+class TestNetIfStats(LinuxTestCase):
+    @requires_cli("ifconfig")
+    def test_against_ifconfig(self):
+        for name, stats in psutil.net_if_stats().items():
+            try:
+                out = sh(f"ifconfig {name}")
+            except RuntimeError:
+                pass
+            else:
+                assert stats.isup == ('RUNNING' in out), out
+                assert stats.mtu == int(
+                    re.findall(r'(?i)MTU[: ](\d+)', out)[0]
+                )
+
+    def test_mtu(self):
+        for name, stats in psutil.net_if_stats().items():
+            with open(f"/sys/class/net/{name}/mtu") as f:
+                assert stats.mtu == int(f.read().strip())
+
+    @requires_cli("ifconfig")
+    def test_flags(self):
+        # first line looks like this:
+        # "eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500"
+        matches_found = 0
+        for name, stats in psutil.net_if_stats().items():
+            try:
+                out = sh(f"ifconfig {name}")
+            except RuntimeError:
+                pass
+            else:
+                match = re.search(r"flags=(\d+)?<(.*?)>", out)
+                if match and len(match.groups()) >= 2:
+                    matches_found += 1
+                    ifconfig_flags = set(match.group(2).lower().split(","))
+                    psutil_flags = set(stats.flags.split(","))
+                    assert ifconfig_flags == psutil_flags
+                else:
+                    # ifconfig has a different output on CentOS 6
+                    # let's try that
+                    match = re.search(r"(.*)  MTU:(\d+)  Metric:(\d+)", out)
+                    if match and len(match.groups()) >= 3:
+                        matches_found += 1
+                        ifconfig_flags = set(match.group(1).lower().split())
+                        psutil_flags = set(stats.flags.split(","))
+                        assert ifconfig_flags == psutil_flags
+
+        if not matches_found:
+            return pytest.fail("no matches were found")
+
+
+class TestNetIoCounters(LinuxTestCase):
+    @requires_cli("ifconfig")
+    @retry_on_failure
+    def test_against_ifconfig(self):
+        def ifconfig(nic):
+            ret = {}
+            out = sh(f"ifconfig {nic}")
+            ret['packets_recv'] = int(
+                re.findall(r'RX packets[: ](\d+)', out)[0]
+            )
+            ret['packets_sent'] = int(
+                re.findall(r'TX packets[: ](\d+)', out)[0]
+            )
+            ret['errin'] = int(re.findall(r'errors[: ](\d+)', out)[0])
+            ret['errout'] = int(re.findall(r'errors[: ](\d+)', out)[1])
+            ret['dropin'] = int(re.findall(r'dropped[: ](\d+)', out)[0])
+            ret['dropout'] = int(re.findall(r'dropped[: ](\d+)', out)[1])
+            ret['bytes_recv'] = int(
+                re.findall(r'RX (?:packets \d+ +)?bytes[: ](\d+)', out)[0]
+            )
+            ret['bytes_sent'] = int(
+                re.findall(r'TX (?:packets \d+ +)?bytes[: ](\d+)', out)[0]
+            )
+            return ret
+
+        nio = psutil.net_io_counters(pernic=True, nowrap=False)
+        for name, stats in nio.items():
+            try:
+                ifconfig_ret = ifconfig(name)
+            except RuntimeError:
+                continue
+            if not any(ifconfig_ret.values()):
+                # net-tools can't parse /proc/net/dev lines whose NIC
+                # name fills the whole 15 chars (e.g. enxbaa44ee7dd5e),
+                # and prints zeros for the whole interface.
+                continue
+
+            assert (
+                abs(stats.bytes_recv - ifconfig_ret['bytes_recv']) < 1024 * 10
+            )
+            assert (
+                abs(stats.bytes_sent - ifconfig_ret['bytes_sent']) < 1024 * 10
+            )
+            assert (
+                abs(stats.packets_recv - ifconfig_ret['packets_recv']) < 1024
+            )
+            assert (
+                abs(stats.packets_sent - ifconfig_ret['packets_sent']) < 1024
+            )
+            assert abs(stats.errin - ifconfig_ret['errin']) < 10
+            assert abs(stats.errout - ifconfig_ret['errout']) < 10
+            assert abs(stats.dropin - ifconfig_ret['dropin']) < 10
+            assert abs(stats.dropout - ifconfig_ret['dropout']) < 10
+
+
+class TestNetConnections(LinuxTestCase):
+    @mock.patch('psutil._pslinux.socket.inet_ntop', side_effect=ValueError)
+    @mock.patch('psutil._pslinux.supports_ipv6', return_value=False)
+    def test_emulate_ipv6_unsupported(self, supports_ipv6, inet_ntop):
+        # see: https://github.com/giampaolo/psutil/issues/623
+        with socket.socket(socket.AF_INET6, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(("::1", 0))
+            except OSError:
+                pass
+            psutil.net_connections(kind='inet6')
+
+    def test_emulate_unix(self):
+        content = textwrap.dedent("""\
+            0: 00000003 000 000 0001 03 462170 @/tmp/dbus-Qw2hMPIU3n
+            0: 00000003 000 000 0001 03 35010 @/tmp/dbus-tB2X8h69BQ
+            0: 00000003 000 000 0001 03 34424 @/tmp/dbus-cHy80Y8O
+            000000000000000000000000000000000000000000000000000000
+            """)
+        with mock_open_content({"/proc/net/unix": content}) as m:
+            psutil.net_connections(kind='unix')
+            assert m.called
+
+    @serial
+    @requires_cli("ss")
+    @retry_on_failure
+    def test_against_ss(self):
+        # Listening ports are more stable, so an exact set comparison is
+        # more reliable.
+        out = sh(["ss", "-tuanp"])
+        ss_ports = set()
+        for line in out.splitlines():
+            fields = line.split()
+            if (
+                len(fields) >= 5
+                and fields[0] == "tcp"
+                and fields[1] == "LISTEN"
+            ):
+                port = int(fields[4].rsplit(":", 1)[-1])
+                ss_ports.add(port)
+        psutil_ports = {
+            c.laddr.port
+            for c in psutil.net_connections(kind="tcp")
+            if c.status == psutil.CONN_LISTEN
+        }
+        assert ss_ports == psutil_ports
+
+
+# =====================================================================
+# --- system disks
+# =====================================================================
+
+
+class TestDiskPartitions(LinuxTestCase):
+    @skipif(not hasattr(os, 'statvfs'), reason="os.statvfs() not available")
+    @skip_on_not_implemented
+    def test_against_df(self):
+        # test psutil.disk_usage() and psutil.disk_partitions()
+        # against "df -a"
+        def df(path):
+            out = sh(f'df -P -B 1 "{path}"').strip()
+            lines = out.split('\n')
+            lines.pop(0)
+            line = lines.pop(0)
+            dev, total, used, free = line.split()[:4]
+            if dev == 'none':
+                dev = ''
+            total, used, free = int(total), int(used), int(free)
+            return dev, total, used, free
+
+        for part in psutil.disk_partitions(all=False):
+            usage = psutil.disk_usage(part.mountpoint)
+            _, total, used, free = df(part.mountpoint)
+            assert usage.total == total
+            assert abs(usage.free - free) < TOLERANCE_DISK_USAGE
+            assert abs(usage.used - used) < TOLERANCE_DISK_USAGE
+
+    def test_zfs_fs(self):
+        # Test that ZFS partitions are returned.
+        with open("/proc/filesystems") as f:
+            data = f.read()
+        if 'zfs' in data:
+            for part in psutil.disk_partitions():
+                if part.fstype == 'zfs':
+                    return
+
+        # No ZFS partitions on this system. Let's fake one.
+        fake_file = io.StringIO("nodev\tzfs\n")
+        with mock.patch(
+            'psutil._common.open', return_value=fake_file, create=True
+        ) as m1:
+            with mock.patch.object(
+                _psutil,
+                'disk_partitions',
+                return_value=[('/dev/sdb3', '/', 'zfs', 'rw')],
+            ) as m2:
+                ret = psutil.disk_partitions()
+                assert m1.called
+                assert m2.called
+                assert ret
+                assert ret[0].fstype == 'zfs'
+
+    def test_emulate_realpath_fail(self):
+        # See: https://github.com/giampaolo/psutil/issues/1307
+        try:
+            with mock.patch(
+                'os.path.realpath', return_value='/non/existent'
+            ) as m:
+                with pytest.raises(FileNotFoundError):
+                    psutil.disk_partitions()
+                assert m.called
+        finally:
+            psutil.PROCFS_PATH = "/proc"
+
+
+class TestDiskIoCounters(LinuxTestCase):
+    def test_emulate_kernel_2_4(self):
+        # Tests /proc/diskstats parsing format for 2.4 kernels, see:
+        # https://github.com/giampaolo/psutil/issues/767
+        content = "   3     0   1 hda 2 3 4 5 6 7 8 9 10 11 12"
+        with mock_open_content({'/proc/diskstats': content}):
+            with mock.patch(
+                'psutil._pslinux.is_storage_device', return_value=True
+            ):
+                ret = psutil.disk_io_counters(nowrap=False)
+                assert ret.read_count == 1
+                assert ret.read_merged_count == 2
+                assert ret.read_bytes == 3 * SECTOR_SIZE
+                assert ret.read_time == 4
+                assert ret.write_count == 5
+                assert ret.write_merged_count == 6
+                assert ret.write_bytes == 7 * SECTOR_SIZE
+                assert ret.write_time == 8
+                assert ret.busy_time == 10
+
+    def test_emulate_kernel_2_6_full(self):
+        # Tests /proc/diskstats parsing format for 2.6 kernels,
+        # lines reporting all metrics:
+        # https://github.com/giampaolo/psutil/issues/767
+        content = "   3    0   hda 1 2 3 4 5 6 7 8 9 10 11"
+        with mock_open_content({"/proc/diskstats": content}):
+            with mock.patch(
+                'psutil._pslinux.is_storage_device', return_value=True
+            ):
+                ret = psutil.disk_io_counters(nowrap=False)
+                assert ret.read_count == 1
+                assert ret.read_merged_count == 2
+                assert ret.read_bytes == 3 * SECTOR_SIZE
+                assert ret.read_time == 4
+                assert ret.write_count == 5
+                assert ret.write_merged_count == 6
+                assert ret.write_bytes == 7 * SECTOR_SIZE
+                assert ret.write_time == 8
+                assert ret.busy_time == 10
+
+    def test_emulate_kernel_2_6_limited(self):
+        # Tests /proc/diskstats parsing format for 2.6 kernels,
+        # where one line of /proc/partitions return a limited
+        # amount of metrics when it bumps into a partition
+        # (instead of a disk). See:
+        # https://github.com/giampaolo/psutil/issues/767
+        with mock_open_content({"/proc/diskstats": "   3    1   hda 1 2 3 4"}):
+            with mock.patch(
+                'psutil._pslinux.is_storage_device', return_value=True
+            ):
+                ret = psutil.disk_io_counters(nowrap=False)
+                assert ret.read_count == 1
+                assert ret.read_bytes == 2 * SECTOR_SIZE
+                assert ret.write_count == 3
+                assert ret.write_bytes == 4 * SECTOR_SIZE
+
+                assert ret.read_merged_count == 0
+                assert ret.read_time == 0
+                assert ret.write_merged_count == 0
+                assert ret.write_time == 0
+                assert ret.busy_time == 0
+
+    def test_emulate_include_partitions(self):
+        # Make sure that when perdisk=True disk partitions are returned,
+        # see:
+        # https://github.com/giampaolo/psutil/pull/1313#issuecomment-408626842
+        content = textwrap.dedent("""\
+            3    0   nvme0n1 1 2 3 4 5 6 7 8 9 10 11
+            3    0   nvme0n1p1 1 2 3 4 5 6 7 8 9 10 11
+            """)
+        with mock_open_content({"/proc/diskstats": content}):
+            with mock.patch(
+                'psutil._pslinux.is_storage_device', return_value=False
+            ):
+                ret = psutil.disk_io_counters(perdisk=True, nowrap=False)
+                assert len(ret) == 2
+                assert ret['nvme0n1'].read_count == 1
+                assert ret['nvme0n1p1'].read_count == 1
+                assert ret['nvme0n1'].write_count == 5
+                assert ret['nvme0n1p1'].write_count == 5
+
+    def test_emulate_exclude_partitions(self):
+        # Make sure that when perdisk=False partitions (e.g. 'sda1',
+        # 'nvme0n1p1') are skipped and not included in the total count.
+        # https://github.com/giampaolo/psutil/pull/1313#issuecomment-408626842
+        content = textwrap.dedent("""\
+            3    0   nvme0n1 1 2 3 4 5 6 7 8 9 10 11
+            3    0   nvme0n1p1 1 2 3 4 5 6 7 8 9 10 11
+            """)
+        with mock_open_content({"/proc/diskstats": content}):
+            with mock.patch(
+                'psutil._pslinux.is_storage_device', return_value=False
+            ):
+                ret = psutil.disk_io_counters(perdisk=False, nowrap=False)
+                assert ret is None
+
+        def is_storage_device(name):
+            return name == 'nvme0n1'
+
+        content = textwrap.dedent("""\
+            3    0   nvme0n1 1 2 3 4 5 6 7 8 9 10 11
+            3    0   nvme0n1p1 1 2 3 4 5 6 7 8 9 10 11
+            """)
+        with mock_open_content({"/proc/diskstats": content}):
+            with mock.patch(
+                'psutil._pslinux.is_storage_device',
+                create=True,
+                side_effect=is_storage_device,
+            ):
+                ret = psutil.disk_io_counters(perdisk=False, nowrap=False)
+                assert ret.read_count == 1
+                assert ret.write_count == 5
+
+    def test_emulate_use_sysfs(self):
+        def exists(path):
+            return path == '/proc/diskstats'
+
+        wprocfs = psutil.disk_io_counters(perdisk=True)
+        with mock.patch(
+            'psutil._pslinux.os.path.exists', create=True, side_effect=exists
+        ):
+            wsysfs = psutil.disk_io_counters(perdisk=True)
+        assert len(wprocfs) == len(wsysfs)
+
+    def test_emulate_not_impl(self):
+        def exists(path):
+            return False
+
+        with mock.patch(
+            'psutil._pslinux.os.path.exists', create=True, side_effect=exists
+        ):
+            with pytest.raises(NotImplementedError):
+                psutil.disk_io_counters()
+
+    @requires_cli("iostat")
+    @retry_on_failure
+    def test_against_iostat(self):
+        # Cross-check read_bytes/write_bytes against 'iostat -d -k'
+        # cumulative totals (kB_read, kB_wrtn columns).
+        out = sh(["iostat", "-d", "-k"])
+        iostat_disks = {}
+        for line in out.splitlines():
+            fields = line.split()
+            if len(fields) < 7 or fields[0] in {"Linux", "Device"}:
+                continue
+            name = fields[0]
+            try:
+                kb_read = int(fields[5])
+                kb_wrtn = int(fields[6])
+            except ValueError:
+                continue
+            iostat_disks[name] = (kb_read * 1024, kb_wrtn * 1024)
+
+        psutil_disks = psutil.disk_io_counters(perdisk=True, nowrap=False)
+        for name, (bytes_read, bytes_wrtn) in iostat_disks.items():
+            if name not in psutil_disks:
+                continue
+            stats = psutil_disks[name]
+            assert abs(stats.read_bytes - bytes_read) < 1024 * 1024
+            assert abs(stats.write_bytes - bytes_wrtn) < 1024 * 1024
+
+
+class TestRootFsDeviceFinder(LinuxTestCase):
+    def setUp(self):
+        dev = os.stat("/").st_dev
+        self.major = os.major(dev)
+        self.minor = os.minor(dev)
+
+    def test_call_methods(self):
+        finder = RootFsDeviceFinder()
+        if os.path.exists("/proc/partitions"):
+            finder.ask_proc_partitions()
+        else:
+            with pytest.raises(FileNotFoundError):
+                finder.ask_proc_partitions()
+        if os.path.exists(f"/sys/dev/block/{self.major}:{self.minor}/uevent"):
+            finder.ask_sys_dev_block()
+        else:
+            with pytest.raises(FileNotFoundError):
+                finder.ask_sys_dev_block()
+        finder.ask_sys_class_block()
+
+    @skipif(not ROOTFS_ON_BLOCK_DEV, reason="/ is not on a block device")
+    def test_comparisons(self):
+        finder = RootFsDeviceFinder()
+        assert finder.find() is not None
+
+        a = b = c = None
+        if os.path.exists("/proc/partitions"):
+            a = finder.ask_proc_partitions()
+        if os.path.exists(f"/sys/dev/block/{self.major}:{self.minor}/uevent"):
+            b = finder.ask_sys_class_block()
+        c = finder.ask_sys_dev_block()
+
+        base = a or b or c
+        if base and a:
+            assert base == a
+        if base and b:
+            assert base == b
+        if base and c:
+            assert base == c
+
+    @requires_cli("findmnt")
+    @skipif(not ROOTFS_ON_BLOCK_DEV, reason="/ is not on a block device")
+    def test_against_findmnt(self):
+        psutil_value = RootFsDeviceFinder().find()
+        findmnt_value = sh("findmnt -o SOURCE -rn /")
+        # findmnt prints the friendly alias (e.g. /dev/mapper/vg-root),
+        # psutil the kernel name it points to (e.g. /dev/dm-0).
+        assert os.path.realpath(psutil_value) == os.path.realpath(
+            findmnt_value
+        )
+
+    def test_disk_partitions_mocked(self):
+        with mock.patch.object(
+            _psutil,
+            'disk_partitions',
+            return_value=[('/dev/root', '/', 'ext4', 'rw')],
+        ) as m:
+            part = psutil.disk_partitions(all=True)[0]
+            assert m.called
+            assert part.device != "/dev/root"
+            assert part.device == RootFsDeviceFinder().find()
+
+
+# =====================================================================
+# --- misc
+# =====================================================================
+
+
+class TestMisc(LinuxTestCase):
+    def test_boot_time(self):
+        vmstat_value = vmstat('boot time')
+        psutil_value = psutil.boot_time()
+        assert int(vmstat_value) == int(psutil_value)
+
+    def test_no_procfs_on_import(self):
+        my_procfs = self.get_testfn()
+        os.mkdir(my_procfs)
+
+        with open(os.path.join(my_procfs, 'stat'), 'w') as f:
+            f.write('cpu   0 0 0 0 0 0 0 0 0 0\n')
+            f.write('cpu0  0 0 0 0 0 0 0 0 0 0\n')
+            f.write('cpu1  0 0 0 0 0 0 0 0 0 0\n')
+
+        try:
+            orig_open = open
+
+            def open_mock(name, *args, **kwargs):
+                if name.startswith('/proc'):
+                    raise FileNotFoundError
+                return orig_open(name, *args, **kwargs)
+
+            with mock.patch("builtins.open", side_effect=open_mock):
+                reload_module(psutil)
+
+                with pytest.raises(OSError):
+                    psutil.cpu_times()
+                with pytest.raises(OSError):
+                    psutil.cpu_times(percpu=True)
+                with pytest.raises(OSError):
+                    psutil.cpu_percent()
+                with pytest.raises(OSError):
+                    psutil.cpu_percent(percpu=True)
+                with pytest.raises(OSError):
+                    psutil.cpu_times_percent()
+                with pytest.raises(OSError):
+                    psutil.cpu_times_percent(percpu=True)
+
+                psutil.PROCFS_PATH = my_procfs
+
+                assert psutil.cpu_percent() == 0
+                assert sum(psutil.cpu_times_percent()) == 0
+
+                # since we don't know the number of CPUs at import time,
+                # we awkwardly say there are none until the second call
+                per_cpu_percent = psutil.cpu_percent(percpu=True)
+                assert sum(per_cpu_percent) == 0
+
+                # ditto awkward length
+                per_cpu_times_percent = psutil.cpu_times_percent(percpu=True)
+                assert sum(map(sum, per_cpu_times_percent)) == 0
+
+                # much user, very busy
+                with open(os.path.join(my_procfs, 'stat'), 'w') as f:
+                    f.write('cpu   1 0 0 0 0 0 0 0 0 0\n')
+                    f.write('cpu0  1 0 0 0 0 0 0 0 0 0\n')
+                    f.write('cpu1  1 0 0 0 0 0 0 0 0 0\n')
+
+                assert psutil.cpu_percent() != 0
+                assert sum(psutil.cpu_percent(percpu=True)) != 0
+                assert sum(psutil.cpu_times_percent()) != 0
+                assert (
+                    sum(map(sum, psutil.cpu_times_percent(percpu=True))) != 0
+                )
+        finally:
+            shutil.rmtree(my_procfs)
+            reload_module(psutil)
+
+        assert psutil.PROCFS_PATH == '/proc'
+
+    def test_cpu_steal_decrease(self):
+        # Test cumulative cpu stats decrease. We should ignore this.
+        # See issue #1210.
+        content = textwrap.dedent("""\
+            cpu   0 0 0 0 0 0 0 1 0 0
+            cpu0  0 0 0 0 0 0 0 1 0 0
+            cpu1  0 0 0 0 0 0 0 1 0 0
+            """).encode()
+        with mock_open_content({"/proc/stat": content}) as m:
+            # first call to "percent" functions should read the new stat file
+            # and compare to the "real" file read at import time - so the
+            # values are meaningless
+            psutil.cpu_percent()
+            assert m.called
+            psutil.cpu_percent(percpu=True)
+            psutil.cpu_times_percent()
+            psutil.cpu_times_percent(percpu=True)
+
+        content = textwrap.dedent("""\
+            cpu   1 0 0 0 0 0 0 0 0 0
+            cpu0  1 0 0 0 0 0 0 0 0 0
+            cpu1  1 0 0 0 0 0 0 0 0 0
+            """).encode()
+        with mock_open_content({"/proc/stat": content}):
+            # Increase "user" while steal goes "backwards" to zero.
+            cpu_percent = psutil.cpu_percent()
+            assert m.called
+            cpu_percent_percpu = psutil.cpu_percent(percpu=True)
+            cpu_times_percent = psutil.cpu_times_percent()
+            cpu_times_percent_percpu = psutil.cpu_times_percent(percpu=True)
+            assert cpu_percent != 0
+            assert sum(cpu_percent_percpu) != 0
+            assert sum(cpu_times_percent) != 0
+            assert sum(cpu_times_percent) != 100.0
+            assert sum(map(sum, cpu_times_percent_percpu)) != 0
+            assert sum(map(sum, cpu_times_percent_percpu)) != 100.0
+            assert cpu_times_percent.steal == 0
+            assert cpu_times_percent.user != 0
+
+    def test_boot_time_mocked(self):
+        with mock.patch('psutil._common.open', create=True) as m:
+            with pytest.raises(RuntimeError):
+                psutil._pslinux.boot_time()
+            assert m.called
+
+    def test_users(self):
+        # Make sure the C extension converts ':0' and ':0.0' to
+        # 'localhost'.
+        for user in psutil.users():
+            assert user.host not in {":0", ":0.0"}
+
+    def test_procfs_path(self):
+        tdir = self.get_testfn()
+        os.mkdir(tdir)
+        try:
+            psutil.PROCFS_PATH = tdir
+            with pytest.raises(OSError):
+                psutil.virtual_memory()
+            with pytest.raises(OSError):
+                psutil.cpu_times()
+            with pytest.raises(OSError):
+                psutil.cpu_times(percpu=True)
+            with pytest.raises(OSError):
+                psutil.boot_time()
+            with pytest.raises(OSError):
+                psutil.net_connections()
+            with pytest.raises(OSError):
+                psutil.net_io_counters()
+            with pytest.raises(OSError):
+                psutil.net_if_stats()
+            with pytest.raises(OSError):
+                psutil.disk_partitions()
+            with pytest.raises(psutil.NoSuchProcess):
+                psutil.Process()
+        finally:
+            psutil.PROCFS_PATH = "/proc"
+
+    @retry_on_failure
+    @isolated
+    def test_issue_687(self):
+        # In case of thread ID:
+        # - pid_exists() is supposed to return False
+        # - Process(tid) is supposed to work
+        # - pids() should not return the TID
+        # See: https://github.com/giampaolo/psutil/issues/687
+
+        p = psutil.Process()
+        nthreads = len(p.threads())
+        with ThreadTask():
+            threads = p.threads()
+            assert len(threads) == nthreads + 1
+            tid = sorted(threads, key=lambda x: x.id)[1].id
+            assert p.pid != tid
+            pt = psutil.Process(tid)
+            pt.as_dict()
+            assert tid not in psutil.pids()
+
+    def test_pid_exists_no_proc_status(self):
+        # Internally pid_exists relies on /proc/{pid}/status.
+        # Emulate a case where this file is empty in which case
+        # psutil is supposed to fall back on using pids().
+        with mock_open_content({"/proc/%s/status": ""}) as m:
+            assert psutil.pid_exists(os.getpid())
+            assert m.called
+
+
+# =====================================================================
+# --- sensors
+# =====================================================================
+
+
+@skipif(not HAS_BATTERY, reason="no battery")
+class TestSensorsBattery(LinuxTestCase):
+    @requires_cli("acpi")
+    def test_percent(self):
+        out = sh("acpi -b")
+        first_battery = out.split("\n")[0]
+        acpi_value = int(first_battery.split(",")[1].strip().replace('%', ''))
+        psutil_value = psutil.sensors_battery().percent
+        assert abs(acpi_value - psutil_value) < 1
+
+    def test_emulate_power_plugged(self):
+        # Pretend the AC power cable is connected.
+        def open_mock(name, *args, **kwargs):
+            if name.endswith(('AC0/online', 'AC/online')):
+                return io.BytesIO(b"1")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock) as m:
+            assert psutil.sensors_battery().power_plugged is True
+            assert (
+                psutil.sensors_battery().secsleft
+                == psutil.POWER_TIME_UNLIMITED
+            )
+            assert m.called
+
+    def test_emulate_power_plugged_2(self):
+        # Same as above but pretend /AC0/online does not exist in which
+        # case code relies on /status file.
+        def open_mock(name, *args, **kwargs):
+            if name.endswith(('AC0/online', 'AC/online')):
+                raise FileNotFoundError
+            if name.endswith("/status"):
+                return io.StringIO("charging")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock) as m:
+            assert psutil.sensors_battery().power_plugged is True
+            assert m.called
+
+    def test_emulate_power_not_plugged(self):
+        # Pretend the AC power cable is not connected.
+        def open_mock(name, *args, **kwargs):
+            if name.endswith(('AC0/online', 'AC/online')):
+                return io.BytesIO(b"0")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock) as m:
+            assert psutil.sensors_battery().power_plugged is False
+            assert m.called
+
+    def test_emulate_power_not_plugged_2(self):
+        # Same as above but pretend /AC0/online does not exist in which
+        # case code relies on /status file.
+        def open_mock(name, *args, **kwargs):
+            if name.endswith(('AC0/online', 'AC/online')):
+                raise FileNotFoundError
+            if name.endswith("/status"):
+                return io.StringIO("discharging")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock) as m:
+            assert psutil.sensors_battery().power_plugged is False
+            assert m.called
+
+    def test_emulate_power_undetermined(self):
+        # Pretend we can't know whether the AC power cable not
+        # connected (assert fallback to False).
+        def open_mock(name, *args, **kwargs):
+            if name.startswith((
+                '/sys/class/power_supply/AC0/online',
+                '/sys/class/power_supply/AC/online',
+            )):
+                raise FileNotFoundError
+            if name.startswith("/sys/class/power_supply/BAT0/status"):
+                return io.BytesIO(b"???")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock) as m:
+            assert psutil.sensors_battery().power_plugged is None
+            assert m.called
+
+    def test_emulate_energy_full_0(self):
+        # Emulate a case where energy_full files returns 0.
+        with mock_open_content(
+            {"/sys/class/power_supply/BAT0/energy_full": b"0"}
+        ) as m:
+            assert psutil.sensors_battery().percent == 0
+            assert m.called
+
+    def test_emulate_energy_full_not_avail(self):
+        # Emulate a case where energy_full file does not exist.
+        # Expected fallback on /capacity.
+        with mock_open_exception(
+            "/sys/class/power_supply/BAT0/energy_full",
+            FileNotFoundError,
+        ):
+            with mock_open_exception(
+                "/sys/class/power_supply/BAT0/charge_full",
+                FileNotFoundError,
+            ):
+                with mock_open_content(
+                    {"/sys/class/power_supply/BAT0/capacity": b"88"}
+                ):
+                    assert psutil.sensors_battery().percent == 88
+
+    @skipif(
+        not os.path.isfile("/sys/class/power_supply/BAT0/capacity"),
+        reason="BAT /capacity file don't exist",
+    )
+    def test_percent_against_capacity(self):
+        # Internally, if we have /energy_full, the percentage will be
+        # calculated by NOT reading the /capacity file, to get more
+        # accuracy. Check against /capacity to make sure our percentage
+        # is calculated correctly.
+        with open("/sys/class/power_supply/BAT0/capacity") as f:
+            capacity = float(f.read())
+        assert psutil.sensors_battery().percent == pytest.approx(
+            capacity, abs=1
+        )
+
+    def test_emulate_no_power(self):
+        # Emulate a case where /AC0/online file nor /BAT0/status exist.
+        with mock_open_exception(
+            "/sys/class/power_supply/AC/online", FileNotFoundError
+        ):
+            with mock_open_exception(
+                "/sys/class/power_supply/AC0/online", FileNotFoundError
+            ):
+                with mock_open_exception(
+                    "/sys/class/power_supply/BAT0/status",
+                    FileNotFoundError,
+                ):
+                    assert psutil.sensors_battery().power_plugged is None
+
+    def test_fully_emulated(self):
+        def open_mock(name, *args, **kwargs):
+            if name.endswith("/energy_now"):
+                return io.StringIO("60000000")
+            elif name.endswith("/power_now"):
+                return io.StringIO("0")
+            elif name.endswith("/energy_full"):
+                return io.StringIO("60000001")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch('os.listdir', return_value=["BAT0"]) as mlistdir:
+            with mock.patch("builtins.open", side_effect=open_mock) as mopen:
+                assert psutil.sensors_battery() is not None
+        assert mlistdir.called
+        assert mopen.called
+
+
+class TestSensorsTemperatures(LinuxTestCase):
+    def test_emulate_class_hwmon(self):
+        def open_mock(name, *args, **kwargs):
+            if name.endswith('/name'):
+                return io.StringIO("name")
+            elif name.endswith('/temp1_label'):
+                return io.StringIO("label")
+            elif name.endswith('/temp1_input'):
+                return io.BytesIO(b"30000")
+            elif name.endswith('/temp1_max'):
+                return io.BytesIO(b"40000")
+            elif name.endswith('/temp1_crit'):
+                return io.BytesIO(b"50000")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock):
+            # Test case with /sys/class/hwmon
+            with mock.patch(
+                'glob.glob', return_value=['/sys/class/hwmon/hwmon0/temp1']
+            ):
+                temp = psutil.sensors_temperatures()['name'][0]
+                assert temp.label == 'label'
+                assert temp.current == 30.0
+                assert temp.high == 40.0
+                assert temp.critical == 50.0
+
+    def test_emulate_class_thermal(self):
+        def open_mock(name, *args, **kwargs):
+            if name.endswith('0_temp'):
+                return io.BytesIO(b"50000")
+            elif name.endswith('temp'):
+                return io.BytesIO(b"30000")
+            elif name.endswith('0_type'):
+                return io.StringIO("critical")
+            elif name.endswith('type'):
+                return io.StringIO("name")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        def glob_mock(path):
+            if path in {
+                '/sys/class/hwmon/hwmon*/temp*_*',
+                '/sys/class/hwmon/hwmon*/device/temp*_*',
+            }:
+                return []
+            elif path == '/sys/class/thermal/thermal_zone*':
+                return ['/sys/class/thermal/thermal_zone0']
+            elif path == '/sys/class/thermal/thermal_zone0/trip_point*':
+                return [
+                    '/sys/class/thermal/thermal_zone1/trip_point_0_type',
+                    '/sys/class/thermal/thermal_zone1/trip_point_0_temp',
+                ]
+            return []
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock):
+            with mock.patch('glob.glob', create=True, side_effect=glob_mock):
+                temp = psutil.sensors_temperatures()['name'][0]
+                assert temp.label == ''
+                assert temp.current == 30.0
+                assert temp.high == 50.0
+                assert temp.critical == 50.0
+
+
+class TestSensorsFans(LinuxTestCase):
+    def test_emulate_data(self):
+        def open_mock(name, *args, **kwargs):
+            if name.endswith('/name'):
+                return io.StringIO("name")
+            elif name.endswith('/fan1_label'):
+                return io.StringIO("label")
+            elif name.endswith('/fan1_input'):
+                return io.StringIO("2000")
+            else:
+                return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock):
+            with mock.patch(
+                'glob.glob', return_value=['/sys/class/hwmon/hwmon2/fan1']
+            ):
+                fan = psutil.sensors_fans()['name'][0]
+                assert fan.label == 'label'
+                assert fan.current == 2000
+
+
+# =====================================================================
+# --- test process
+# =====================================================================
+
+
+class TestProcess(LinuxTestCase):
+    @retry_on_failure
+    def test_parse_smaps_vs_memory_maps(self):
+        sproc = self.spawn_subproc()
+        uss, pss, swap = psutil._pslinux.Process(sproc.pid)._parse_smaps()
+        maps = psutil.Process(sproc.pid).memory_maps(grouped=False)
+        assert (
+            abs(uss - sum(x.private_dirty + x.private_clean for x in maps))
+            < 4096
+        )
+        assert abs(pss - sum(x.pss for x in maps)) < 4096
+        assert abs(swap - sum(x.swap for x in maps)) < 4096
+
+    def test_parse_smaps_mocked(self):
+        # See: https://github.com/giampaolo/psutil/issues/1222
+        content = textwrap.dedent("""\
+            fffff0 r-xp 00000000 00:00 0                  [vsyscall]
+            Size:                  1 kB
+            Rss:                   2 kB
+            Pss:                   3 kB
+            Shared_Clean:          4 kB
+            Shared_Dirty:          5 kB
+            Private_Clean:         6 kB
+            Private_Dirty:         7 kB
+            Referenced:            8 kB
+            Anonymous:             9 kB
+            LazyFree:              10 kB
+            AnonHugePages:         11 kB
+            ShmemPmdMapped:        12 kB
+            Shared_Hugetlb:        13 kB
+            Private_Hugetlb:       14 kB
+            Swap:                  15 kB
+            SwapPss:               16 kB
+            KernelPageSize:        17 kB
+            MMUPageSize:           18 kB
+            Locked:                19 kB
+            VmFlags: rd ex
+            """).encode()
+        with mock_open_content({f"/proc/{os.getpid()}/smaps": content}) as m:
+            p = psutil._pslinux.Process(os.getpid())
+            uss, pss, swap = p._parse_smaps()
+            assert m.called
+            assert uss == (6 + 7 + 14) * 1024
+            assert pss == 3 * 1024
+            assert swap == 15 * 1024
+
+    def test_open_files_mode(self):
+        def get_test_file(fname):
+            p = psutil.Process()
+            giveup_at = time.monotonic() + GLOBAL_TIMEOUT
+            while True:
+                for file in p.open_files():
+                    if file.path == os.path.abspath(fname):
+                        return file
+                    elif time.monotonic() > giveup_at:
+                        break
+            raise RuntimeError("timeout looking for test file")
+
+        testfn = self.get_testfn()
+        with open(testfn, "w"):
+            assert get_test_file(testfn).mode == "w"
+        with open(testfn):
+            assert get_test_file(testfn).mode == "r"
+        with open(testfn, "a"):
+            assert get_test_file(testfn).mode == "a"
+        with open(testfn, "r+"):
+            assert get_test_file(testfn).mode == "r+"
+        with open(testfn, "w+"):
+            assert get_test_file(testfn).mode == "r+"
+        with open(testfn, "a+"):
+            assert get_test_file(testfn).mode == "a+"
+
+        safe_rmpath(testfn)
+        with open(testfn, "x"):
+            assert get_test_file(testfn).mode == "w"
+        safe_rmpath(testfn)
+        with open(testfn, "x+"):
+            assert get_test_file(testfn).mode == "r+"
+
+    def test_open_files_file_gone(self):
+        # simulates a file which gets deleted during open_files()
+        # execution
+        p = psutil.Process()
+        files = p.open_files()
+        with open(self.get_testfn(), 'w'):
+            # give the kernel some time to see the new file
+            call_until(lambda: len(p.open_files()) != len(files))
+            with mock.patch(
+                'psutil._pslinux.os.readlink',
+                side_effect=FileNotFoundError,
+            ) as m:
+                assert p.open_files() == []
+                assert m.called
+            # also simulate the case where os.readlink() returns EINVAL
+            # in which case psutil is supposed to 'continue'
+            with mock.patch(
+                'psutil._pslinux.os.readlink',
+                side_effect=OSError(errno.EINVAL, ""),
+            ) as m:
+                assert p.open_files() == []
+                assert m.called
+
+    def test_open_files_fd_gone(self):
+        # Simulate a case where /proc/{pid}/fdinfo/{fd} disappears
+        # while iterating through fds.
+        # https://travis-ci.org/giampaolo/psutil/jobs/225694530
+        p = psutil.Process()
+        files = p.open_files()
+        with open(self.get_testfn(), 'w'):
+            # give the kernel some time to see the new file
+            call_until(lambda: len(p.open_files()) != len(files))
+            with mock.patch(
+                "builtins.open", side_effect=FileNotFoundError
+            ) as m:
+                assert p.open_files() == []
+                assert m.called
+
+    def test_open_files_enametoolong(self):
+        # Simulate a case where /proc/{pid}/fd/{fd} symlink
+        # points to a file with full path longer than PATH_MAX, see:
+        # https://github.com/giampaolo/psutil/issues/1940
+        p = psutil.Process()
+        files = p.open_files()
+        with open(self.get_testfn(), 'w'):
+            # give the kernel some time to see the new file
+            call_until(lambda: len(p.open_files()) != len(files))
+            patch_point = 'psutil._pslinux.os.readlink'
+            with mock.patch(
+                patch_point, side_effect=OSError(errno.ENAMETOOLONG, "")
+            ) as m:
+                with mock.patch("psutil._pslinux.debug"):
+                    assert p.open_files() == []
+                    assert m.called
+
+    # --- mocked tests
+
+    def test_terminal_mocked(self):
+        with mock.patch(
+            'psutil._pslinux._psposix._get_terminal_map', return_value={}
+        ):
+            assert psutil._pslinux.Process(os.getpid()).terminal() is None
+
+    def test_cmdline_mocked(self):
+        # see: https://github.com/giampaolo/psutil/issues/639
+        p = psutil.Process()
+        fake_file = io.StringIO('foo\x00bar\x00')
+        with mock.patch(
+            'psutil._common.open', return_value=fake_file, create=True
+        ) as m:
+            assert p.cmdline() == ['foo', 'bar']
+            assert m.called
+        fake_file = io.StringIO('foo\x00bar\x00\x00')
+        with mock.patch(
+            'psutil._common.open', return_value=fake_file, create=True
+        ) as m:
+            assert p.cmdline() == ['foo', 'bar', '']
+            assert m.called
+
+    def test_cmdline_spaces_mocked(self):
+        # see: https://github.com/giampaolo/psutil/issues/1179
+        p = psutil.Process()
+        fake_file = io.StringIO('foo bar ')
+        with mock.patch(
+            'psutil._common.open', return_value=fake_file, create=True
+        ) as m:
+            assert p.cmdline() == ['foo', 'bar']
+            assert m.called
+        fake_file = io.StringIO('foo bar  ')
+        with mock.patch(
+            'psutil._common.open', return_value=fake_file, create=True
+        ) as m:
+            assert p.cmdline() == ['foo', 'bar', '']
+            assert m.called
+
+    def test_cmdline_mixed_separators(self):
+        # https://github.com/giampaolo/psutil/issues/1179#issuecomment-552984549
+        p = psutil.Process()
+        fake_file = io.StringIO('foo\x20bar\x00')
+        with mock.patch(
+            'psutil._common.open', return_value=fake_file, create=True
+        ) as m:
+            assert p.cmdline() == ['foo', 'bar']
+            assert m.called
+
+    def test_readlink_path_deleted_mocked(self):
+        with mock.patch(
+            'psutil._pslinux.os.readlink', return_value='/home/foo (deleted)'
+        ):
+            assert psutil.Process().exe() == "/home/foo"
+            assert psutil.Process().cwd() == "/home/foo"
+
+    def test_threads_mocked(self):
+        # Test the case where os.listdir() returns a file (thread)
+        # which no longer exists by the time we open() it (race
+        # condition). threads() is supposed to ignore that instead
+        # of raising NSP.
+        def open_mock_1(name, *args, **kwargs):
+            if name.startswith(f"/proc/{os.getpid()}/task"):
+                raise FileNotFoundError
+            return orig_open(name, *args, **kwargs)
+
+        orig_open = open
+        with mock.patch("builtins.open", side_effect=open_mock_1) as m:
+            ret = psutil.Process().threads()
+            assert m.called
+            assert ret == []
+
+        # ...but if it bumps into something != ENOENT we want an
+        # exception.
+        def open_mock_2(name, *args, **kwargs):
+            if name.startswith(f"/proc/{os.getpid()}/task"):
+                raise PermissionError
+            return orig_open(name, *args, **kwargs)
+
+        with mock.patch("builtins.open", side_effect=open_mock_2):
+            with pytest.raises(psutil.AccessDenied):
+                psutil.Process().threads()
+
+    def test_exe_mocked(self):
+        with mock.patch(
+            'psutil._pslinux.readlink', side_effect=FileNotFoundError
+        ) as m:
+            # de-activate guessing from cmdline()
+            with mock.patch(
+                'psutil._pslinux.Process.cmdline', return_value=[]
+            ):
+                ret = psutil.Process().exe()
+                assert m.called
+                assert ret == ""
+
+    def test_cwd_mocked(self):
+        # https://github.com/giampaolo/psutil/issues/2514
+        with mock.patch(
+            'psutil._pslinux.readlink', side_effect=FileNotFoundError
+        ) as m:
+            ret = psutil.Process().cwd()
+            assert m.called
+            assert ret == ""
+
+    def test_issue_1014(self):
+        # Emulates a case where smaps file does not exist. In this case
+        # wrap_exception decorator should not raise NoSuchProcess.
+        with mock_open_exception(
+            f"/proc/{os.getpid()}/smaps", FileNotFoundError
+        ) as m:
+            p = psutil.Process()
+            with pytest.raises(FileNotFoundError):
+                p.memory_maps()
+            assert m.called
+
+    def test_issue_2418(self):
+        p = psutil.Process()
+        with mock_open_exception(
+            f"/proc/{os.getpid()}/statm", FileNotFoundError
+        ):
+            with mock.patch("os.path.exists", return_value=False):
+                with pytest.raises(psutil.NoSuchProcess):
+                    p.memory_info()
+
+    @skipif(not HAS_PROC_RLIMIT, reason="not supported")
+    def test_rlimit_zombie(self):
+        # Emulate a case where rlimit() raises ENOSYS, which may
+        # happen in case of zombie process:
+        # https://travis-ci.org/giampaolo/psutil/jobs/51368273
+        with mock.patch(
+            "resource.prlimit", side_effect=OSError(errno.ENOSYS, "")
+        ) as m1:
+            with mock.patch(
+                "psutil._pslinux.Process._is_zombie", return_value=True
+            ) as m2:
+                p = psutil.Process()
+                p.name()
+                with pytest.raises(psutil.ZombieProcess) as cm:
+                    p.rlimit(psutil.RLIMIT_NOFILE)
+        assert m1.called
+        assert m2.called
+        assert cm.value.pid == p.pid
+        assert cm.value.name == p.name()
+
+    def test_stat_file_parsing(self):
+        args = [
+            "0",  # pid
+            "(cat)",  # name
+            "Z",  # status
+            "1",  # ppid
+            "0",  # pgrp
+            "0",  # session
+            "0",  # tty
+            "0",  # tpgid
+            "0",  # flags
+            "0",  # minflt
+            "0",  # cminflt
+            "0",  # majflt
+            "0",  # cmajflt
+            "2",  # utime
+            "3",  # stime
+            "4",  # cutime
+            "5",  # cstime
+            "0",  # priority
+            "0",  # nice
+            "0",  # num_threads
+            "0",  # itrealvalue
+            "6",  # starttime
+            "0",  # vsize
+            "0",  # rss
+            "0",  # rsslim
+            "0",  # startcode
+            "0",  # endcode
+            "0",  # startstack
+            "0",  # kstkesp
+            "0",  # kstkeip
+            "0",  # signal
+            "0",  # blocked
+            "0",  # sigignore
+            "0",  # sigcatch
+            "0",  # wchan
+            "0",  # nswap
+            "0",  # cnswap
+            "0",  # exit_signal
+            "6",  # processor
+            "0",  # rt priority
+            "0",  # policy
+            "7",  # delayacct_blkio_ticks
+        ]
+        content = " ".join(args).encode()
+        with mock_open_content({f"/proc/{os.getpid()}/stat": content}):
+            p = psutil.Process()
+            assert p.name() == 'cat'
+            assert p.status() == psutil.STATUS_ZOMBIE
+            assert p.ppid() == 1
+            assert p.create_time() == 6 / CLOCK_TICKS + psutil.boot_time()
+            cpu = p.cpu_times()
+            assert cpu.user == 2 / CLOCK_TICKS
+            assert cpu.system == 3 / CLOCK_TICKS
+            assert cpu.children_user == 4 / CLOCK_TICKS
+            assert cpu.children_system == 5 / CLOCK_TICKS
+            assert cpu.iowait == 7 / CLOCK_TICKS
+            assert p.cpu_num() == 6
+
+    def test_status_file_parsing(self):
+        content = textwrap.dedent("""\
+            Uid:\t1000\t1001\t1002\t1003
+            Gid:\t1004\t1005\t1006\t1007
+            Threads:\t66
+            Cpus_allowed:\tf
+            Cpus_allowed_list:\t0-7
+            voluntary_ctxt_switches:\t12
+            nonvoluntary_ctxt_switches:\t13""").encode()
+        with mock_open_content({f"/proc/{os.getpid()}/status": content}):
+            p = psutil.Process()
+            assert p.num_ctx_switches().voluntary == 12
+            assert p.num_ctx_switches().involuntary == 13
+            assert p.num_threads() == 66
+            uids = p.uids()
+            assert uids.real == 1000
+            assert uids.effective == 1001
+            assert uids.saved == 1002
+            gids = p.gids()
+            assert gids.real == 1004
+            assert gids.effective == 1005
+            assert gids.saved == 1006
+            assert p._proc._get_eligible_cpus() == list(range(8))
+
+    def test_status_file_cpus_allowed_list(self):
+        content = b"Cpus_allowed_list:\t0-3,8\n"
+        with mock_open_content({f"/proc/{os.getpid()}/status": content}):
+            p = psutil.Process()
+            assert p._proc._get_eligible_cpus() == [0, 1, 2, 3, 8]
+
+    def test_net_connections_enametoolong(self):
+        # Simulate a case where /proc/{pid}/fd/{fd} symlink points to
+        # a file with full path longer than PATH_MAX, see:
+        # https://github.com/giampaolo/psutil/issues/1940
+        with mock.patch(
+            'psutil._pslinux.os.readlink',
+            side_effect=OSError(errno.ENAMETOOLONG, ""),
+        ) as m:
+            p = psutil.Process()
+            with mock.patch("psutil._pslinux.debug"):
+                assert p.net_connections() == []
+                assert m.called
+
+    def test_create_time_monotonic(self):
+        p = psutil.Process()
+        assert p._proc.create_time() != p._proc.create_time(monotonic=True)
+        assert p._get_ident()[1] == p._proc.create_time(monotonic=True)
+
+    def test_memory_extras(self):
+        p = psutil.Process()
+        with open(f"/proc/{p.pid}/status", "rb") as f:
+            data = f.read()
+        with mock.patch.object(
+            psutil._pslinux.Process, "_read_status_file", return_value=data
+        ):
+            mem = p.memory_extras()
+        vmrss = int(re.search(br"VmRSS:\s+(\d+)", data).group(1)) * 1024
+        assert mem.rss_anon + mem.rss_file + mem.rss_shmem == vmrss
+
+    def test_rlimit_infinity_normalized(self):
+        # Python 3.15 changed resource.prlimit() to return RLIM_INFINITY
+        # as the unsigned 2**64-1 instead of -1; psutil maps it back.
+        unsigned = 2**64 - 1
+        p = psutil.Process()
+        with mock.patch(
+            "psutil._pslinux.resource.prlimit",
+            return_value=(unsigned, unsigned),
+        ) as m:
+            soft, hard = p.rlimit(psutil.RLIMIT_FSIZE)
+            assert m.called
+        assert soft == psutil.RLIM_INFINITY
+        assert hard == psutil.RLIM_INFINITY
+
+
+class TestProcessAgainstStatus(LinuxTestCase):
+    """/proc/pid/stat and /proc/pid/status have many values in common.
+    Whenever possible, psutil uses /proc/pid/stat (it's faster).
+    For all those cases we check that the value found in
+    /proc/pid/stat (by psutil) matches the one found in
+    /proc/pid/status.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        cls.proc = psutil.Process()
+
+    def read_status_file(self, linestart):
+        with psutil._psplatform.open_text(
+            f"/proc/{self.proc.pid}/status"
+        ) as f:
+            for line in f:
+                line = line.strip()
+                if line.startswith(linestart):
+                    value = line.partition('\t')[2]
+                    try:
+                        return int(value)
+                    except ValueError:
+                        return value
+            raise ValueError(f"can't find {linestart!r}")
+
+    def test_name(self):
+        value = self.read_status_file("Name:")
+        assert self.proc.name() == value
+
+    def test_status(self):
+        value = self.read_status_file("State:")
+        value = value[value.find('(') + 1 : value.rfind(')')]
+        value = value.replace(' ', '-')
+        assert self.proc.status() == value
+
+    def test_ppid(self):
+        value = self.read_status_file("PPid:")
+        assert self.proc.ppid() == value
+
+    def test_num_threads(self):
+        value = self.read_status_file("Threads:")
+        assert self.proc.num_threads() == value
+
+    def test_uids(self):
+        value = self.read_status_file("Uid:")
+        value = tuple(map(int, value.split()[1:4]))
+        assert self.proc.uids() == value
+
+    def test_gids(self):
+        value = self.read_status_file("Gid:")
+        value = tuple(map(int, value.split()[1:4]))
+        assert self.proc.gids() == value
+
+    @retry_on_failure
+    def test_num_ctx_switches(self):
+        value = self.read_status_file("voluntary_ctxt_switches:")
+        assert self.proc.num_ctx_switches().voluntary == value
+        value = self.read_status_file("nonvoluntary_ctxt_switches:")
+        assert self.proc.num_ctx_switches().involuntary == value
+
+    def test_cpu_affinity(self):
+        value = self.read_status_file("Cpus_allowed_list:")
+        if '-' in str(value):
+            # The mask covers the possible CPUs, while sched_getaffinity
+            # only reports the online ones.
+            with open("/sys/devices/system/cpu/online") as f:
+                online = f.read().strip()
+            omin, omax = map(int, online.split('-'))
+            min_, max_ = map(int, value.split('-'))
+            expected = [x for x in range(min_, max_ + 1) if omin <= x <= omax]
+            assert self.proc.cpu_affinity() == expected
+
+    def test_cpu_affinity_eligible_cpus(self):
+        value = self.read_status_file("Cpus_allowed_list:")
+        with mock.patch("psutil._pslinux.per_cpu_times") as m:
+            cpus = self.proc._proc._get_eligible_cpus()
+        assert cpus == _parse_cpulist(str(value))
+        assert not m.called
+
+
+# =====================================================================
+# --- test utils
+# =====================================================================
+
+
+class TestUtils(LinuxTestCase):
+    def test_readlink(self):
+        with mock.patch("os.readlink", return_value="foo (deleted)") as m:
+            assert psutil._psplatform.readlink("bar") == "foo"
+            assert m.called
diff --git a/tests/test_memleaks.py b/tests/test_memleaks.py
new file mode 100755
index 0000000000..f00e413da4
--- /dev/null
+++ b/tests/test_memleaks.py
@@ -0,0 +1,589 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Regression test suite for detecting memory leaks in the underlying C
+extension. Requires https://github.com/giampaolo/psleak.
+"""
+
+import inspect
+import os
+
+from psleak import LeakTest
+from psleak import MemoryLeakTestCase
+
+import psutil
+from psutil import FREEBSD
+from psutil import LINUX
+from psutil import MACOS
+from psutil import OPENBSD
+from psutil import POSIX
+from psutil import SUNOS
+from psutil import WINDOWS
+from psutil import _psutil
+
+from . import HAS_CPU_FREQ
+from . import HAS_HEAP_INFO
+from . import HAS_NET_IO_COUNTERS
+from . import HAS_PROC_CPU_AFFINITY
+from . import HAS_PROC_CPU_NUM
+from . import HAS_PROC_ENVIRON
+from . import HAS_PROC_IO_COUNTERS
+from . import HAS_PROC_IONICE
+from . import HAS_PROC_MEMORY_EXTRAS
+from . import HAS_PROC_MEMORY_FOOTPRINT
+from . import HAS_PROC_MEMORY_MAPS
+from . import HAS_PROC_RLIMIT
+from . import HAS_SENSORS_BATTERY
+from . import HAS_SENSORS_FANS
+from . import HAS_SENSORS_TEMPERATURES
+from . import PYTEST_PARALLEL
+from . import create_sockets
+from . import get_testfn
+from . import process_namespace
+from . import pytest
+from . import skip_on_access_denied
+from . import skipif
+from . import spawn_subproc
+from . import system_namespace
+from . import terminate
+
+thisproc = psutil.Process()
+
+
+MemoryLeakTestCase.retries = 30  # minimize false positives
+
+# Be quiet when running under xdist.
+MemoryLeakTestCase.verbosity = 0 if PYTEST_PARALLEL else 1
+
+TIMES = MemoryLeakTestCase.times
+FEW_TIMES = int(TIMES / 10)
+
+
+# ===================================================================
+# Process class
+# ===================================================================
+
+
+class TestProcess(MemoryLeakTestCase):
+    """Test leaks of Process class methods."""
+
+    proc = thisproc
+
+    def test_coverage(self):
+        ns = process_namespace(None)
+        ns.test_class_coverage(self, ns.getters + ns.setters)
+
+    def test_name(self):
+        self.execute(self.proc.name)
+
+    def test_cmdline(self):
+        if WINDOWS and self.proc.is_running():
+            self.proc.cmdline()
+        self.execute(self.proc.cmdline)
+
+    def test_exe(self):
+        self.execute(self.proc.exe)
+
+    def test_ppid(self):
+        self.execute(self.proc.ppid)
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_uids(self):
+        self.execute(self.proc.uids)
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_gids(self):
+        self.execute(self.proc.gids)
+
+    def test_status(self):
+        self.execute(self.proc.status)
+
+    def test_nice(self):
+        self.execute(self.proc.nice)
+
+    def test_nice_set(self):
+        niceness = thisproc.nice()
+        self.execute(lambda: self.proc.nice(niceness))
+
+    @skipif(not HAS_PROC_IONICE, reason="not supported")
+    def test_ionice(self):
+        self.execute(self.proc.ionice)
+
+    @skipif(not HAS_PROC_IONICE, reason="not supported")
+    def test_ionice_set(self):
+        if WINDOWS:
+            value = thisproc.ionice()
+            self.execute(lambda: self.proc.ionice(value))
+        else:
+            self.execute(lambda: self.proc.ionice(psutil.IOPRIO_CLASS_NONE))
+
+    @skipif(not HAS_PROC_IO_COUNTERS, reason="not supported")
+    def test_io_counters(self):
+        self.execute(self.proc.io_counters)
+
+    @skipif(POSIX, reason="worthless on POSIX")
+    def test_username(self):
+        # always open 1 handle on Windows (only once)
+        psutil.Process().username()
+        self.execute(self.proc.username)
+
+    def test_create_time(self):
+        self.execute(self.proc.create_time)
+
+    @skip_on_access_denied(only_if=OPENBSD)
+    def test_num_threads(self):
+        self.execute(self.proc.num_threads)
+
+    @skipif(not WINDOWS, reason="WINDOWS only")
+    def test_num_handles(self):
+        self.execute(self.proc.num_handles)
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_num_fds(self):
+        self.execute(self.proc.num_fds)
+
+    def test_num_ctx_switches(self):
+        self.execute(self.proc.num_ctx_switches)
+
+    @skip_on_access_denied(only_if=OPENBSD)
+    def test_threads(self):
+        self.execute(self.proc.threads, times=50 if WINDOWS else TIMES)
+
+    def test_cpu_times(self):
+        self.execute(self.proc.cpu_times)
+
+    @skipif(not HAS_PROC_CPU_NUM, reason="not supported")
+    def test_cpu_num(self):
+        self.execute(self.proc.cpu_num)
+
+    def test_memory_info(self):
+        self.execute(self.proc.memory_info)
+
+    @skipif(not HAS_PROC_MEMORY_EXTRAS, reason="not supported")
+    def test_memory_extras(self):
+        self.execute(self.proc.memory_extras)
+
+    @skipif(not HAS_PROC_MEMORY_FOOTPRINT, reason="not supported")
+    def test_memory_footprint(self):
+        self.execute(self.proc.memory_footprint, times=50)  # slow
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_terminal(self):
+        self.execute(self.proc.terminal)
+
+    def test_resume(self):
+        times = FEW_TIMES if POSIX else self.times
+        self.execute(self.proc.resume, times=times)
+
+    def test_cwd(self):
+        self.execute(self.proc.cwd)
+
+    @skipif(not HAS_PROC_CPU_AFFINITY, reason="not supported")
+    def test_cpu_affinity(self):
+        self.execute(self.proc.cpu_affinity)
+
+    @skipif(not HAS_PROC_CPU_AFFINITY, reason="not supported")
+    def test_cpu_affinity_set(self):
+        affinity = thisproc.cpu_affinity()
+        self.execute(lambda: self.proc.cpu_affinity(affinity))
+
+    def test_open_files(self):
+        with open(get_testfn(), 'w'):
+            self.execute(self.proc.open_files)
+
+    @skipif(not HAS_PROC_MEMORY_MAPS, reason="not supported")
+    @skipif(LINUX, reason="too slow on LINUX")
+    def test_memory_maps(self):
+        self.execute(self.proc.memory_maps, times=60, retries=10)
+
+    def test_page_faults(self):
+        self.execute(self.proc.page_faults)
+
+    @skipif(not LINUX, reason="LINUX only")
+    @skipif(not HAS_PROC_RLIMIT, reason="not supported")
+    def test_rlimit(self):
+        self.execute(lambda: self.proc.rlimit(psutil.RLIMIT_NOFILE))
+
+    @skipif(not LINUX, reason="LINUX only")
+    @skipif(not HAS_PROC_RLIMIT, reason="not supported")
+    def test_rlimit_set(self):
+        limit = thisproc.rlimit(psutil.RLIMIT_NOFILE)
+        self.execute(lambda: self.proc.rlimit(psutil.RLIMIT_NOFILE, limit))
+
+    # Windows implementation is based on a single system-wide
+    # function (tested later).
+    @skipif(WINDOWS, reason="worthless on WINDOWS")
+    @skipif(LINUX, reason="pure python, too slow")
+    @skipif(SUNOS, reason="parses pfiles CLI")
+    def test_net_connections(self):
+        with create_sockets():
+            kind = 'inet' if SUNOS else 'all'
+            self.execute(lambda: self.proc.net_connections(kind))
+
+    @skipif(not HAS_PROC_ENVIRON, reason="not supported")
+    def test_environ(self):
+        self.execute(self.proc.environ)
+
+    @skipif(not WINDOWS, reason="WINDOWS only")
+    def test_proc_oneshot(self):
+        self.execute(lambda: _psutil.proc_oneshot(os.getpid()))
+
+
+class TestTerminatedProcess(TestProcess):
+    """Repeat the tests above looking for leaks occurring when dealing
+    with terminated processes raising NoSuchProcess exception.
+    The C functions are still invoked but will follow different code
+    paths. We'll check those code paths.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.subp = spawn_subproc()
+        cls.proc = psutil.Process(cls.subp.pid)
+        cls.proc.kill()
+        cls.proc.wait()
+
+    @classmethod
+    def tearDownClass(cls):
+        super().tearDownClass()
+        terminate(cls.subp)
+
+    def call(self, fun):
+        try:
+            fun()
+        except psutil.NoSuchProcess:
+            pass
+
+    if WINDOWS:
+
+        def test_kill(self):
+            self.execute(self.proc.kill)
+
+        def test_terminate(self):
+            self.execute(self.proc.terminate)
+
+        def test_suspend(self):
+            self.execute(self.proc.suspend)
+
+        def test_resume(self):
+            self.execute(self.proc.resume)
+
+        def test_wait(self):
+            self.execute(self.proc.wait)
+
+        def test_proc_oneshot(self):
+            # test dual implementation
+            def call():
+                try:
+                    return _psutil.proc_oneshot(self.proc.pid)
+                except ProcessLookupError:
+                    pass
+
+            self.execute(call)
+
+
+@skipif(not WINDOWS, reason="WINDOWS only")
+class TestProcessDualImplementation(MemoryLeakTestCase):
+    def test_cmdline_peb_true(self):
+        # The first CommandLineToArgvW() call loads shell32, leaving
+        # persistent handles.
+        _psutil.proc_cmdline(os.getpid(), use_peb=True)
+        self.execute(lambda: _psutil.proc_cmdline(os.getpid(), use_peb=True))
+
+    def test_cmdline_peb_false(self):
+        _psutil.proc_cmdline(os.getpid(), use_peb=False)  # prime (see above)
+        self.execute(lambda: _psutil.proc_cmdline(os.getpid(), use_peb=False))
+
+
+# ===================================================================
+# system APIs
+# ===================================================================
+
+
+class TestModuleFunctions(MemoryLeakTestCase):
+    """Test leaks of psutil module functions."""
+
+    def test_coverage(self):
+        ns = system_namespace()
+        ns.test_class_coverage(self, ns.all)
+
+    # --- cpu
+
+    def test_cpu_count(self):  # logical
+        self.execute(lambda: psutil.cpu_count(logical=True))
+
+    def test_cpu_count_cores(self):
+        self.execute(lambda: psutil.cpu_count(logical=False))
+
+    def test_cpu_times(self):
+        self.execute(psutil.cpu_times)
+
+    def test_per_cpu_times(self):
+        self.execute(lambda: psutil.cpu_times(percpu=True))
+
+    def test_cpu_stats(self):
+        self.execute(psutil.cpu_stats)
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    def test_cpu_freq(self):
+        times = FEW_TIMES if LINUX else self.times
+        self.execute(psutil.cpu_freq, times=times)
+
+    @skipif(not WINDOWS, reason="WINDOWS only")
+    def test_getloadavg(self):
+        psutil.getloadavg()
+        self.execute(psutil.getloadavg)
+
+    # --- mem
+
+    def test_virtual_memory(self):
+        self.execute(psutil.virtual_memory)
+
+    # TODO: remove this skip when this gets fixed
+    @skipif(SUNOS, reason="worthless on SUNOS (uses a subprocess)")
+    def test_swap_memory(self):
+        self.execute(psutil.swap_memory)
+
+    def test_pid_exists(self):
+        times = FEW_TIMES if POSIX else self.times
+        self.execute(lambda: psutil.pid_exists(os.getpid()), times=times)
+
+    # --- disk
+
+    def test_disk_usage(self):
+        times = FEW_TIMES if POSIX else self.times
+        self.execute(lambda: psutil.disk_usage('.'), times=times)
+
+    def test_disk_partitions(self):
+        self.execute(psutil.disk_partitions)
+
+    @skipif(
+        LINUX and not os.path.exists('/proc/diskstats'),
+        reason="/proc/diskstats not available on this Linux version",
+    )
+    def test_disk_io_counters(self):
+        self.execute(lambda: psutil.disk_io_counters(nowrap=False))
+
+    # --- proc
+
+    def test_pids(self):
+        self.execute(psutil.pids)
+
+    # --- net
+
+    @skipif(not HAS_NET_IO_COUNTERS, reason="not supported")
+    def test_net_io_counters(self):
+        self.execute(lambda: psutil.net_io_counters(nowrap=False))
+
+    @skipif(MACOS and os.getuid() != 0, reason="need root access")
+    @skipif(LINUX, reason="pure python, too slow")
+    def test_net_connections(self):
+        # slow
+        with create_sockets():
+            psutil.net_connections(kind='all')
+            self.execute(
+                lambda: psutil.net_connections(kind='all'), times=TIMES / 2
+            )
+
+    def test_net_if_addrs(self):
+        psutil.net_if_addrs()  # XXX prime
+        # Note: verified that on Windows this was a false positive.
+        tolerance = 80 * 1024 if WINDOWS else self.tolerance
+        self.execute(psutil.net_if_addrs, tolerance=tolerance)
+
+    def test_net_if_stats(self):
+        self.execute(psutil.net_if_stats)
+
+    # --- sensors
+
+    @skipif(not HAS_SENSORS_BATTERY, reason="not supported")
+    def test_sensors_battery(self):
+        self.execute(psutil.sensors_battery)
+
+    @skipif(not HAS_SENSORS_TEMPERATURES, reason="not supported")
+    @skipif(LINUX, reason="too slow on LINUX")
+    def test_sensors_temperatures(self):
+        times = FEW_TIMES if LINUX else self.times
+        self.execute(psutil.sensors_temperatures, times=times)
+
+    @skipif(not HAS_SENSORS_FANS, reason="not supported")
+    def test_sensors_fans(self):
+        times = FEW_TIMES if LINUX else self.times
+        self.execute(psutil.sensors_fans, times=times)
+
+    # --- others
+
+    def test_boot_time(self):
+        self.execute(psutil.boot_time)
+
+    def test_users(self):
+        self.execute(psutil.users)
+
+    def test_set_debug(self):
+        self.execute(lambda: psutil._set_debug(False))
+
+    @skipif(not HAS_HEAP_INFO, reason="not supported")
+    def test_heap_info(self):
+        self.execute(psutil.heap_info, times=25 if WINDOWS else TIMES)  # slow
+
+    @skipif(not HAS_HEAP_INFO, reason="not supported")
+    def test_heap_trim(self):
+        self.execute(psutil.heap_trim)
+
+    if WINDOWS:
+
+        # --- win services
+
+        def test_win_service_iter(self):
+            self.execute(_psutil.winservice_enumerate)
+
+        def test_win_service_get(self):
+            pass
+
+        def test_win_service_get_config(self):
+            name = next(psutil.win_service_iter()).name()
+            self.execute(lambda: _psutil.winservice_query_config(name))
+
+        def test_win_service_get_status(self):
+            name = next(psutil.win_service_iter()).name()
+            self.execute(lambda: _psutil.winservice_query_status(name))
+
+        def test_win_service_get_description(self):
+            name = next(psutil.win_service_iter()).name()
+            self.execute(lambda: _psutil.winservice_query_descr(name))
+
+
+# ===================================================================
+# bad arguments
+# ===================================================================
+
+
+class TestBadargs(MemoryLeakTestCase):
+    """Pass a bad argument to each C function that accepts one, and make
+    sure the resulting `PyArg_ParseTuple` failure path doesn't leak
+    memory: a C function may allocate its return object before parsing
+    its arguments, see: https://github.com/giampaolo/psutil/pull/2857/.
+    """
+
+    retries = 20
+    badargs = (object(),) * 20
+
+    def execute(self, fun, *args, **kwargs):
+        # Every function here is called with a bad arg and must raise
+        # TypeError (the parse-failure path we check for leaks).
+        def call():
+            try:
+                fun(*args)
+            except TypeError:
+                pass
+            else:
+                pytest.fail(f"{fun} did not raise TypeError")
+
+        super().execute(call, **kwargs)
+
+    @classmethod
+    def cext_arg_funcs(cls):
+        # Names of the C functions that actually parse at least one
+        # argument.
+        names = []
+        for name in dir(_psutil):
+            if name.startswith("_"):
+                continue
+            func = getattr(_psutil, name)
+            if not inspect.isbuiltin(func):  # skip exception classes
+                continue
+            try:
+                func(*cls.badargs)
+            except NotImplementedError:
+                pass
+            except TypeError as err:
+                # "takes no arguments" => METH_NOARGS (no arg to test).
+                if "takes no arguments" not in str(err):
+                    names.append(name)
+        return names
+
+    @classmethod
+    def auto_generate(cls):
+        return {
+            name: LeakTest(getattr(_psutil, name), *cls.badargs)
+            for name in cls.cext_arg_funcs()
+        }
+
+
+def cext_has(name):
+    return skipif(not hasattr(_psutil, name), reason=f"no _psutil.{name}()")
+
+
+class TestBadargs2(MemoryLeakTestCase):
+    """Like TestBadargsMemleaks, but for the error paths reached
+    *after* `PyArg_ParseTuple` succeeds, by passing an invalid arg like
+    a negative PID, a bogus NIC name etc., making the C function fail
+    deeper.
+    """
+
+    retries = 20
+    pid = os.getpid()
+
+    # --- portable: same signature and error everywhere they exist
+
+    @cext_has("proc_priority_get")
+    def test_proc_priority_get(self):
+        self.execute_w_exc(OSError, _psutil.proc_priority_get, -1)
+
+    @cext_has("proc_priority_set")
+    def test_proc_priority_set(self):
+        self.execute_w_exc(OSError, _psutil.proc_priority_set, -1, 0)
+
+    @cext_has("proc_cpu_affinity_get")
+    def test_proc_cpu_affinity_get(self):
+        # FreeBSD's cpuset_getaffinity() reads -1 as "the current
+        # process", so it succeeds. Use another negative PID.
+        pid = -2 if FREEBSD else -1
+        self.execute_w_exc(OSError, _psutil.proc_cpu_affinity_get, pid)
+
+    @cext_has("net_if_flags")
+    def test_net_if_flags(self):
+        self.execute_w_exc(OSError, _psutil.net_if_flags, "nonexistent0")
+
+    @cext_has("net_if_mtu")
+    def test_net_if_mtu(self):
+        self.execute_w_exc(OSError, _psutil.net_if_mtu, "nonexistent0")
+
+    @cext_has("net_if_is_running")
+    def test_net_if_is_running(self):
+        self.execute_w_exc(OSError, _psutil.net_if_is_running, "nonexistent0")
+
+    # --- Linux only
+
+    @cext_has("proc_ioprio_set")
+    def test_proc_ioprio_set(self):
+        self.execute_w_exc(OSError, _psutil.proc_ioprio_set, self.pid, -1, 0)
+
+    @cext_has("proc_ioprio_get")
+    def test_proc_ioprio_get(self):
+        self.execute_w_exc(OSError, _psutil.proc_ioprio_get, -1)
+
+    @skipif(not LINUX, reason="LINUX only")
+    def test_disk_partitions(self):
+        self.execute_w_exc(OSError, _psutil.disk_partitions, "/does/not/exist")
+
+    @skipif(not LINUX, reason="LINUX only")
+    def test_net_if_duplex_speed(self):
+        self.execute_w_exc(
+            OSError, _psutil.net_if_duplex_speed, "nonexistent0"
+        )
+
+    # --- other platform-specific behavior
+
+    @skipif(not LINUX, reason="LINUX only")
+    def test_proc_cpu_affinity_set(self):
+        self.execute_w_exc(
+            ValueError, _psutil.proc_cpu_affinity_set, self.pid, [-1]
+        )
+
+    def test_check_pid_range(self):
+        self.execute_w_exc(ValueError, _psutil.check_pid_range, -1)
diff --git a/tests/test_misc.py b/tests/test_misc.py
new file mode 100755
index 0000000000..2b0386642f
--- /dev/null
+++ b/tests/test_misc.py
@@ -0,0 +1,883 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Miscellaneous tests."""
+
+import collections
+import contextlib
+import io
+import json
+import os
+import pickle
+import socket
+import subprocess
+import sys
+import textwrap
+import warnings
+from unittest import mock
+
+import psutil
+from psutil import POSIX
+from psutil import WINDOWS
+from psutil import _psutil
+from psutil._common import bcat
+from psutil._common import broadcast_addr
+from psutil._common import cat
+from psutil._common import debug
+from psutil._common import isfile_strict
+from psutil._common import memoize_when_activated
+from psutil._common import parse_environ_block
+from psutil._common import supports_ipv6
+from psutil._common import warn
+from psutil._common import wrap_numbers
+from psutil._ntuples import snicaddr
+
+from . import HAS_NET_IO_COUNTERS
+from . import ROOT_DIR
+from . import PsutilTestCase
+from . import import_module_by_path
+from . import process_namespace
+from . import pytest
+from . import reload_module
+from . import skipif
+from . import system_namespace
+
+# ===================================================================
+# --- Test classes' repr(), str(), ...
+# ===================================================================
+
+
+class TestSpecialMethods(PsutilTestCase):
+    def test_check_pid_range(self):
+        with pytest.raises(OverflowError):
+            _psutil.check_pid_range(2**128)
+        with pytest.raises(psutil.NoSuchProcess):
+            psutil.Process(2**128)
+
+    def test_process__repr__(self, func=repr):
+        p = psutil.Process(self.spawn_subproc().pid)
+        r = func(p)
+        assert "psutil.Process" in r
+        assert f"pid={p.pid}" in r
+        assert f"name='{p.name()}'" in r.replace("name=u'", "name='")
+        assert "status=" in r
+        assert "exitcode=" not in r
+        p.terminate()
+        p.wait()
+        r = func(p)
+        assert "status='terminated'" in r
+        assert "exitcode=" in r
+
+        with mock.patch.object(
+            psutil.Process,
+            "name",
+            side_effect=psutil.ZombieProcess(os.getpid()),
+        ):
+            p = psutil.Process()
+            r = func(p)
+            assert f"pid={p.pid}" in r
+            assert "status='zombie'" in r
+            assert "name=" not in r
+        with mock.patch.object(
+            psutil.Process,
+            "name",
+            side_effect=psutil.NoSuchProcess(os.getpid()),
+        ):
+            p = psutil.Process()
+            r = func(p)
+            assert f"pid={p.pid}" in r
+            assert "terminated" in r
+            assert "name=" not in r
+        with mock.patch.object(
+            psutil.Process,
+            "name",
+            side_effect=psutil.AccessDenied(os.getpid()),
+        ):
+            p = psutil.Process()
+            r = func(p)
+            assert f"pid={p.pid}" in r
+            assert "name=" not in r
+
+    def test_process__str__(self):
+        self.test_process__repr__(func=str)
+
+    def test_error__repr__(self):
+        assert repr(psutil.Error()) == "psutil.Error()"
+
+    def test_error__str__(self):
+        assert str(psutil.Error()) == ""
+
+    def test_no_such_process__repr__(self):
+        assert (
+            repr(psutil.NoSuchProcess(321))
+            == "psutil.NoSuchProcess(pid=321, msg='process no longer exists')"
+        )
+        assert (
+            repr(psutil.NoSuchProcess(321, name="name", msg="msg"))
+            == "psutil.NoSuchProcess(pid=321, name='name', msg='msg')"
+        )
+
+    def test_no_such_process__str__(self):
+        assert (
+            str(psutil.NoSuchProcess(321))
+            == "process no longer exists (pid=321)"
+        )
+        assert (
+            str(psutil.NoSuchProcess(321, name="name", msg="msg"))
+            == "msg (pid=321, name='name')"
+        )
+
+    def test_zombie_process__repr__(self):
+        assert (
+            repr(psutil.ZombieProcess(321))
+            == 'psutil.ZombieProcess(pid=321, msg="PID still '
+            'exists but it\'s a zombie")'
+        )
+        assert (
+            repr(psutil.ZombieProcess(321, name="name", ppid=320, msg="foo"))
+            == "psutil.ZombieProcess(pid=321, ppid=320, name='name',"
+            " msg='foo')"
+        )
+
+    def test_zombie_process__str__(self):
+        assert (
+            str(psutil.ZombieProcess(321))
+            == "PID still exists but it's a zombie (pid=321)"
+        )
+        assert (
+            str(psutil.ZombieProcess(321, name="name", ppid=320, msg="foo"))
+            == "foo (pid=321, ppid=320, name='name')"
+        )
+
+    def test_access_denied__repr__(self):
+        assert repr(psutil.AccessDenied(321)) == "psutil.AccessDenied(pid=321)"
+        assert (
+            repr(psutil.AccessDenied(321, name="name", msg="msg"))
+            == "psutil.AccessDenied(pid=321, name='name', msg='msg')"
+        )
+
+    def test_access_denied__str__(self):
+        assert str(psutil.AccessDenied(321)) == "(pid=321)"
+        assert (
+            str(psutil.AccessDenied(321, name="name", msg="msg"))
+            == "msg (pid=321, name='name')"
+        )
+
+    def test_timeout_expired__repr__(self):
+        assert (
+            repr(psutil.TimeoutExpired(5))
+            == "psutil.TimeoutExpired(seconds=5, msg='timeout after 5"
+            " seconds')"
+        )
+        assert (
+            repr(psutil.TimeoutExpired(5, pid=321, name="name"))
+            == "psutil.TimeoutExpired(pid=321, name='name', seconds=5, "
+            "msg='timeout after 5 seconds')"
+        )
+
+    def test_timeout_expired__str__(self):
+        assert str(psutil.TimeoutExpired(5)) == "timeout after 5 seconds"
+        assert (
+            str(psutil.TimeoutExpired(5, pid=321, name="name"))
+            == "timeout after 5 seconds (pid=321, name='name')"
+        )
+
+
+# ===================================================================
+# --- Misc, generic, corner cases
+# ===================================================================
+
+
+class TestMisc(PsutilTestCase):
+    def test__all__(self):
+        dir_psutil = dir(psutil)
+        # assert there's no duplicates
+        assert len(dir_psutil) == len(set(dir_psutil))
+        for name in dir_psutil:
+            if name in {
+                'debug',
+                'warn',
+                'tests',
+                'test',
+                'PermissionError',
+                'ProcessLookupError',
+            }:
+                continue
+            if not name.startswith('_'):
+                try:
+                    __import__(name)
+                except ImportError:
+                    if name not in psutil.__all__:
+                        fun = getattr(psutil, name)
+                        if fun is None:
+                            continue
+                        if (
+                            fun.__doc__ is not None
+                            and 'deprecated' not in fun.__doc__.lower()
+                        ):
+                            return pytest.fail(
+                                f"{name!r} not in psutil.__all__"
+                            )
+
+        # Import 'star' will break if __all__ is inconsistent, see:
+        # https://github.com/giampaolo/psutil/issues/656
+        # Can't do `from psutil import *` as it won't work
+        # so we simply iterate over __all__.
+        for name in psutil.__all__:
+            assert name in dir_psutil
+
+    def test_version(self):
+        assert (
+            '.'.join([str(x) for x in psutil.version_info])
+            == psutil.__version__
+        )
+
+    def test_process_as_dict_no_new_names(self):
+        # See https://github.com/giampaolo/psutil/issues/813
+        p = psutil.Process()
+        p.foo = '1'
+        assert 'foo' not in p.as_dict()
+
+    def test_serialization(self):
+        def check(ret):
+            json.loads(json.dumps(ret))
+
+            a = pickle.dumps(ret)
+            b = pickle.loads(a)
+            assert ret == b
+
+        # --- process APIs
+
+        proc = psutil.Process()
+        check(psutil.Process().as_dict())
+
+        ns = process_namespace(proc)
+        for fun, name in ns.iter(ns.getters, clear_cache=True):
+            with self.subTest(proc=str(proc), name=name):
+                try:
+                    ret = fun()
+                except psutil.Error:
+                    pass
+                else:
+                    check(ret)
+
+        # --- system APIs
+
+        ns = system_namespace()
+        for fun, name in ns.iter(ns.getters):
+            if name in {"win_service_iter", "win_service_get"}:
+                continue
+            with self.subTest(name=name):
+                try:
+                    ret = fun()
+                except psutil.AccessDenied:
+                    pass
+                else:
+                    check(ret)
+
+        # --- exception classes
+
+        b = pickle.loads(
+            pickle.dumps(
+                psutil.NoSuchProcess(pid=4567, name='name', msg='msg')
+            )
+        )
+        assert isinstance(b, psutil.NoSuchProcess)
+        assert b.pid == 4567
+        assert b.name == 'name'
+        assert b.msg == 'msg'
+
+        b = pickle.loads(
+            pickle.dumps(
+                psutil.ZombieProcess(pid=4567, name='name', ppid=42, msg='msg')
+            )
+        )
+        assert isinstance(b, psutil.ZombieProcess)
+        assert b.pid == 4567
+        assert b.ppid == 42
+        assert b.name == 'name'
+        assert b.msg == 'msg'
+
+        b = pickle.loads(
+            pickle.dumps(psutil.AccessDenied(pid=123, name='name', msg='msg'))
+        )
+        assert isinstance(b, psutil.AccessDenied)
+        assert b.pid == 123
+        assert b.name == 'name'
+        assert b.msg == 'msg'
+
+        b = pickle.loads(
+            pickle.dumps(
+                psutil.TimeoutExpired(seconds=33, pid=4567, name='name')
+            )
+        )
+        assert isinstance(b, psutil.TimeoutExpired)
+        assert b.seconds == 33
+        assert b.pid == 4567
+        assert b.name == 'name'
+
+    def test_sanity_version_check(self):
+        # see: https://github.com/giampaolo/psutil/issues/564
+        with mock.patch.object(_psutil, "version", return_value="0.0.0"):
+            with pytest.raises(ImportError) as cm:
+                reload_module(psutil)
+            assert "version conflict" in str(cm.value).lower()
+
+    def test_reload_keeps_all(self):
+        # A reload reuses the module dict, so the enum constants are
+        # already there and used to not make it back into __all__.
+        before = sorted(psutil.__all__)
+        reload_module(psutil)
+        assert sorted(psutil.__all__) == before
+
+
+# ===================================================================
+# --- C extension
+# ===================================================================
+
+
+class TestCExtension(PsutilTestCase):
+
+    def test_exceptions_survive_reimport(self):
+        # PEP 489 multi-phase init re-runs the C exec slot on re-import;
+        # the C exceptions are cached in process-global vars so their
+        # identity survives. Run in a subprocess: re-importing the
+        # module (del from sys.modules + import) mutates global state and
+        # would leak into other tests.
+        attrs = (
+            ["TimeoutExpired", "TimeoutAbandoned"]
+            if WINDOWS
+            else ["ZombieProcessError"]
+        )
+        code = textwrap.dedent(f"""
+            import importlib
+            import sys
+
+            from psutil import _psutil
+
+            attrs = {attrs!r}
+            before = {{a: getattr(_psutil, a) for a in attrs}}
+            del sys.modules[_psutil.__name__]
+            new = importlib.import_module(_psutil.__name__)
+            for a in attrs:
+                assert getattr(new, a) is before[a], a
+        """)
+        subprocess.check_output(
+            [sys.executable, "-c", code], stderr=subprocess.STDOUT
+        )
+
+
+# ===================================================================
+# --- psutil/_common.py utils
+# ===================================================================
+
+
+class TestCommonModule(PsutilTestCase):
+    def test_memoize_when_activated(self):
+        class Foo:
+            @memoize_when_activated
+            def foo(self):
+                calls.append(None)
+
+        f = Foo()
+        calls = []
+        f.foo()
+        f.foo()
+        assert len(calls) == 2
+
+        # activate
+        calls = []
+        f.foo.cache_activate(f)
+        f.foo()
+        f.foo()
+        assert len(calls) == 1
+
+        # deactivate
+        calls = []
+        f.foo.cache_deactivate(f)
+        f.foo()
+        f.foo()
+        assert len(calls) == 2
+
+    def test_parse_environ_block(self):
+        def k(s):
+            return s.upper() if WINDOWS else s
+
+        assert parse_environ_block("a=1\0") == {k("a"): "1"}
+        assert parse_environ_block("a=1\0b=2\0\0") == {
+            k("a"): "1",
+            k("b"): "2",
+        }
+        assert parse_environ_block("a=1\0b=\0\0") == {k("a"): "1", k("b"): ""}
+        # ignore everything after \0\0
+        assert parse_environ_block("a=1\0b=2\0\0c=3\0") == {
+            k("a"): "1",
+            k("b"): "2",
+        }
+        # ignore everything that is not an assignment
+        assert parse_environ_block("xxx\0a=1\0") == {k("a"): "1"}
+        assert parse_environ_block("a=1\0=b=2\0") == {k("a"): "1"}
+        # do not fail if the block is incomplete
+        assert parse_environ_block("a=1\0b=2") == {k("a"): "1"}
+
+    def test_supports_ipv6(self):
+        if supports_ipv6():
+            with mock.patch('psutil._common.socket') as s:
+                s.has_ipv6 = False
+                assert not supports_ipv6()
+
+            with mock.patch(
+                'psutil._common.socket.socket', side_effect=OSError
+            ) as s:
+                assert not supports_ipv6()
+                assert s.called
+
+            with mock.patch(
+                'psutil._common.socket.socket', side_effect=socket.gaierror
+            ) as s:
+                assert not supports_ipv6()
+                assert s.called
+
+            with mock.patch(
+                'psutil._common.socket.socket.bind',
+                side_effect=socket.gaierror,
+            ) as s:
+                assert not supports_ipv6()
+                assert s.called
+        else:
+            with pytest.raises(OSError):
+                sock = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
+                try:
+                    sock.bind(("::1", 0))
+                finally:
+                    sock.close()
+
+    def test_isfile_strict(self):
+        this_file = os.path.abspath(__file__)
+        assert isfile_strict(this_file)
+        assert not isfile_strict(os.path.dirname(this_file))
+        with mock.patch('psutil._common.os.stat', side_effect=PermissionError):
+            with pytest.raises(OSError):
+                isfile_strict(this_file)
+        with mock.patch(
+            'psutil._common.os.stat', side_effect=FileNotFoundError
+        ):
+            assert not isfile_strict(this_file)
+        with mock.patch('psutil._common.stat.S_ISREG', return_value=False):
+            assert not isfile_strict(this_file)
+
+    def test_debug(self):
+        with mock.patch.object(psutil._common, "PSUTIL_DEBUG", True):
+            with contextlib.redirect_stderr(io.StringIO()) as f:
+                debug("hello")
+                sys.stderr.flush()
+        msg = f.getvalue()
+        assert msg.startswith("psutil-debug"), msg
+        assert "hello" in msg
+        assert __file__.replace('.pyc', '.py') in msg
+
+        # supposed to use repr(exc)
+        with mock.patch.object(psutil._common, "PSUTIL_DEBUG", True):
+            with contextlib.redirect_stderr(io.StringIO()) as f:
+                debug(ValueError("this is an error"))
+        msg = f.getvalue()
+        assert "ignoring ValueError" in msg
+        assert "'this is an error'" in msg
+
+        # supposed to use str(exc), because of extra info about file name
+        with mock.patch.object(psutil._common, "PSUTIL_DEBUG", True):
+            with contextlib.redirect_stderr(io.StringIO()) as f:
+                exc = OSError(2, "no such file")
+                exc.filename = "/foo"
+                debug(exc)
+        msg = f.getvalue()
+        assert "no such file" in msg
+        assert "/foo" in msg
+
+    def test_warn(self):
+        with mock.patch.object(psutil._common, "PSUTIL_TESTING", True):
+            with pytest.raises(RuntimeError, match="CRITICAL: hello"):
+                warn("hello")
+
+        with mock.patch.object(psutil._common, "PSUTIL_TESTING", False):
+            with warnings.catch_warnings(record=True) as ws:
+                warnings.simplefilter("always")
+                warn("hello")
+        assert len(ws) == 1
+        assert ws[0].category is RuntimeWarning
+        assert "hello" in str(ws[0].message)
+        assert __file__.replace('.pyc', '.py') in str(ws[0].message)
+
+    def test_cat_bcat(self):
+        testfn = self.get_testfn()
+        with open(testfn, "w") as f:
+            f.write("foo")
+        assert cat(testfn) == "foo"
+        assert bcat(testfn) == b"foo"
+        with pytest.raises(FileNotFoundError):
+            cat(testfn + '-invalid')
+        with pytest.raises(FileNotFoundError):
+            bcat(testfn + '-invalid')
+        assert cat(testfn + '-invalid', fallback="bar") == "bar"
+        assert bcat(testfn + '-invalid', fallback="bar") == "bar"
+
+    def test_broadcast_addr(self):
+        def addr(address, netmask):
+            return snicaddr(socket.AF_INET, address, netmask, None, None)
+
+        assert (
+            broadcast_addr(addr("10.1.1.86", "255.255.255.0")) == "10.1.1.255"
+        )
+        assert (
+            broadcast_addr(addr("172.20.10.7", "255.255.255.240"))
+            == "172.20.10.15"
+        )
+
+    def test_broadcast_addr_single_host(self):
+        # A /32 is a single-host network, it has no broadcast address.
+        nt = snicaddr(
+            socket.AF_INET, "89.234.156.160", "255.255.255.255", None, None
+        )
+        assert broadcast_addr(nt) is None
+
+
+class TestBytes2Human(PsutilTestCase):
+
+    def test_basic(self):
+        assert psutil.bytes2human(0) == "0.0B"
+        assert psutil.bytes2human(1000) == "1000.0B"
+        assert psutil.bytes2human(10000) == "9.8K"
+        assert psutil.bytes2human(100001221) == "95.4M"
+        assert psutil.bytes2human(1099511627776) == "1.0T"
+
+
+# ===================================================================
+# --- Tests for wrap_numbers() function.
+# ===================================================================
+
+
+nt = collections.namedtuple('foo', 'a b c')
+
+
+class TestWrapNumbers(PsutilTestCase):
+    def setUp(self):
+        wrap_numbers.cache_clear()
+
+    tearDown = setUp
+
+    def test_first_call(self):
+        input = {'disk1': nt(5, 5, 5)}
+        assert wrap_numbers(input, 'disk_io') == input
+
+    def test_input_hasnt_changed(self):
+        input = {'disk1': nt(5, 5, 5)}
+        assert wrap_numbers(input, 'disk_io') == input
+        assert wrap_numbers(input, 'disk_io') == input
+
+    def test_increase_but_no_wrap(self):
+        input = {'disk1': nt(5, 5, 5)}
+        assert wrap_numbers(input, 'disk_io') == input
+        input = {'disk1': nt(10, 15, 20)}
+        assert wrap_numbers(input, 'disk_io') == input
+        input = {'disk1': nt(20, 25, 30)}
+        assert wrap_numbers(input, 'disk_io') == input
+        input = {'disk1': nt(20, 25, 30)}
+        assert wrap_numbers(input, 'disk_io') == input
+
+    def test_wrap(self):
+        # let's say 100 is the threshold
+        input = {'disk1': nt(100, 100, 100)}
+        assert wrap_numbers(input, 'disk_io') == input
+        # first wrap restarts from 10
+        input = {'disk1': nt(100, 100, 10)}
+        assert wrap_numbers(input, 'disk_io') == {'disk1': nt(100, 100, 110)}
+        # then it remains the same
+        input = {'disk1': nt(100, 100, 10)}
+        assert wrap_numbers(input, 'disk_io') == {'disk1': nt(100, 100, 110)}
+        # then it goes up
+        input = {'disk1': nt(100, 100, 90)}
+        assert wrap_numbers(input, 'disk_io') == {'disk1': nt(100, 100, 190)}
+        # then it wraps again
+        input = {'disk1': nt(100, 100, 20)}
+        assert wrap_numbers(input, 'disk_io') == {'disk1': nt(100, 100, 210)}
+        # and remains the same
+        input = {'disk1': nt(100, 100, 20)}
+        assert wrap_numbers(input, 'disk_io') == {'disk1': nt(100, 100, 210)}
+        # now wrap another num
+        input = {'disk1': nt(50, 100, 20)}
+        assert wrap_numbers(input, 'disk_io') == {'disk1': nt(150, 100, 210)}
+        # and again
+        input = {'disk1': nt(40, 100, 20)}
+        assert wrap_numbers(input, 'disk_io') == {'disk1': nt(190, 100, 210)}
+        # keep it the same
+        input = {'disk1': nt(40, 100, 20)}
+        assert wrap_numbers(input, 'disk_io') == {'disk1': nt(190, 100, 210)}
+
+    def test_changing_keys(self):
+        # Emulate a case where the second call to disk_io()
+        # (or whatever) provides a new disk, then the new disk
+        # disappears on the third call.
+        input = {'disk1': nt(5, 5, 5)}
+        assert wrap_numbers(input, 'disk_io') == input
+        input = {'disk1': nt(5, 5, 5), 'disk2': nt(7, 7, 7)}
+        assert wrap_numbers(input, 'disk_io') == input
+        input = {'disk1': nt(8, 8, 8)}
+        assert wrap_numbers(input, 'disk_io') == input
+
+    def test_changing_keys_w_wrap(self):
+        input = {'disk1': nt(50, 50, 50), 'disk2': nt(100, 100, 100)}
+        assert wrap_numbers(input, 'disk_io') == input
+        # disk 2 wraps
+        input = {'disk1': nt(50, 50, 50), 'disk2': nt(100, 100, 10)}
+        assert wrap_numbers(input, 'disk_io') == {
+            'disk1': nt(50, 50, 50),
+            'disk2': nt(100, 100, 110),
+        }
+        # disk 2 disappears
+        input = {'disk1': nt(50, 50, 50)}
+        assert wrap_numbers(input, 'disk_io') == input
+
+        # then it appears again; the old wrap is supposed to be
+        # gone.
+        input = {'disk1': nt(50, 50, 50), 'disk2': nt(100, 100, 100)}
+        assert wrap_numbers(input, 'disk_io') == input
+        # remains the same
+        input = {'disk1': nt(50, 50, 50), 'disk2': nt(100, 100, 100)}
+        assert wrap_numbers(input, 'disk_io') == input
+        # and then wraps again
+        input = {'disk1': nt(50, 50, 50), 'disk2': nt(100, 100, 10)}
+        assert wrap_numbers(input, 'disk_io') == {
+            'disk1': nt(50, 50, 50),
+            'disk2': nt(100, 100, 110),
+        }
+
+    def test_real_data(self):
+        d = {
+            'nvme0n1': (300, 508, 640, 1571, 5970, 1987, 2049, 451751, 47048),
+            'nvme0n1p1': (1171, 2, 5600256, 1024, 516, 0, 0, 0, 8),
+            'nvme0n1p2': (54, 54, 2396160, 5165056, 4, 24, 30, 1207, 28),
+            'nvme0n1p3': (2389, 4539, 5154, 150, 4828, 1844, 2019, 398, 348),
+        }
+        assert wrap_numbers(d, 'disk_io') == d
+        assert wrap_numbers(d, 'disk_io') == d
+        # decrease this   ↓
+        d = {
+            'nvme0n1': (100, 508, 640, 1571, 5970, 1987, 2049, 451751, 47048),
+            'nvme0n1p1': (1171, 2, 5600256, 1024, 516, 0, 0, 0, 8),
+            'nvme0n1p2': (54, 54, 2396160, 5165056, 4, 24, 30, 1207, 28),
+            'nvme0n1p3': (2389, 4539, 5154, 150, 4828, 1844, 2019, 398, 348),
+        }
+        out = wrap_numbers(d, 'disk_io')
+        assert out['nvme0n1'][0] == 400
+
+    # --- cache tests
+
+    def test_cache_first_call(self):
+        input = {'disk1': nt(5, 5, 5)}
+        wrap_numbers(input, 'disk_io')
+        cache = wrap_numbers.cache_info()
+        assert cache[0] == {'disk_io': input}
+        assert cache[1] == {'disk_io': {}}
+        assert cache[2] == {'disk_io': {}}
+
+    def test_cache_call_twice(self):
+        input = {'disk1': nt(5, 5, 5)}
+        wrap_numbers(input, 'disk_io')
+        input = {'disk1': nt(10, 10, 10)}
+        wrap_numbers(input, 'disk_io')
+        cache = wrap_numbers.cache_info()
+        assert cache[0] == {'disk_io': input}
+        assert cache[1] == {
+            'disk_io': {('disk1', 0): 0, ('disk1', 1): 0, ('disk1', 2): 0}
+        }
+        assert cache[2] == {'disk_io': {}}
+
+    def test_cache_wrap(self):
+        # let's say 100 is the threshold
+        input = {'disk1': nt(100, 100, 100)}
+        wrap_numbers(input, 'disk_io')
+
+        # first wrap restarts from 10
+        input = {'disk1': nt(100, 100, 10)}
+        wrap_numbers(input, 'disk_io')
+        cache = wrap_numbers.cache_info()
+        assert cache[0] == {'disk_io': input}
+        assert cache[1] == {
+            'disk_io': {('disk1', 0): 0, ('disk1', 1): 0, ('disk1', 2): 100}
+        }
+        assert cache[2] == {'disk_io': {'disk1': {('disk1', 2)}}}
+
+        def check_cache_info():
+            cache = wrap_numbers.cache_info()
+            assert cache[1] == {
+                'disk_io': {
+                    ('disk1', 0): 0,
+                    ('disk1', 1): 0,
+                    ('disk1', 2): 100,
+                }
+            }
+            assert cache[2] == {'disk_io': {'disk1': {('disk1', 2)}}}
+
+        # then it remains the same
+        input = {'disk1': nt(100, 100, 10)}
+        wrap_numbers(input, 'disk_io')
+        cache = wrap_numbers.cache_info()
+        assert cache[0] == {'disk_io': input}
+        check_cache_info()
+
+        # then it goes up
+        input = {'disk1': nt(100, 100, 90)}
+        wrap_numbers(input, 'disk_io')
+        cache = wrap_numbers.cache_info()
+        assert cache[0] == {'disk_io': input}
+        check_cache_info()
+
+        # then it wraps again
+        input = {'disk1': nt(100, 100, 20)}
+        wrap_numbers(input, 'disk_io')
+        cache = wrap_numbers.cache_info()
+        assert cache[0] == {'disk_io': input}
+        assert cache[1] == {
+            'disk_io': {('disk1', 0): 0, ('disk1', 1): 0, ('disk1', 2): 190}
+        }
+        assert cache[2] == {'disk_io': {'disk1': {('disk1', 2)}}}
+
+    def test_cache_changing_keys(self):
+        input = {'disk1': nt(5, 5, 5)}
+        wrap_numbers(input, 'disk_io')
+        input = {'disk1': nt(5, 5, 5), 'disk2': nt(7, 7, 7)}
+        wrap_numbers(input, 'disk_io')
+        cache = wrap_numbers.cache_info()
+        assert cache[0] == {'disk_io': input}
+        assert cache[1] == {
+            'disk_io': {('disk1', 0): 0, ('disk1', 1): 0, ('disk1', 2): 0}
+        }
+        assert cache[2] == {'disk_io': {}}
+
+    def test_cache_clear(self):
+        input = {'disk1': nt(5, 5, 5)}
+        wrap_numbers(input, 'disk_io')
+        wrap_numbers(input, 'disk_io')
+        wrap_numbers.cache_clear('disk_io')
+        assert wrap_numbers.cache_info() == ({}, {}, {})
+        wrap_numbers.cache_clear('disk_io')
+        wrap_numbers.cache_clear('?!?')
+
+    @skipif(not HAS_NET_IO_COUNTERS, reason="not supported")
+    def test_cache_clear_public_apis(self):
+        if not psutil.disk_io_counters() or not psutil.net_io_counters():
+            return pytest.skip("no disks or NICs available")
+        psutil.disk_io_counters()
+        psutil.net_io_counters()
+        caches = wrap_numbers.cache_info()
+        for cache in caches:
+            assert 'psutil.disk_io_counters' in cache
+            assert 'psutil.net_io_counters' in cache
+
+        psutil.disk_io_counters.cache_clear()
+        caches = wrap_numbers.cache_info()
+        for cache in caches:
+            assert 'psutil.net_io_counters' in cache
+            assert 'psutil.disk_io_counters' not in cache
+
+        psutil.net_io_counters.cache_clear()
+        caches = wrap_numbers.cache_info()
+        assert caches == ({}, {}, {})
+
+
+# ===================================================================
+# --- Test setup.py
+# ===================================================================
+
+
+@skipif(not POSIX, reason="POSIX only")
+class TestSetupPy(PsutilTestCase):
+    @staticmethod
+    def import_setup_py():
+        path = os.path.join(ROOT_DIR, "setup.py")
+        if not os.path.exists(path):
+            return pytest.skip("setup.py not available")
+        return import_module_by_path(path)
+
+    def test_num_cpus_env_var(self):
+        setup = self.import_setup_py()
+        with mock.patch.dict(os.environ, {"PSUTIL_BUILD_JOBS": "3"}):
+            assert setup.num_cpus() == 3
+        # Never return 0, else ThreadPoolExecutor() raises ValueError.
+        with mock.patch.dict(os.environ, {"PSUTIL_BUILD_JOBS": "0"}):
+            assert setup.num_cpus() == 1
+
+    def test_num_cpus_default(self):
+        setup = self.import_setup_py()
+        with mock.patch.dict(os.environ, clear=True):
+            assert setup.num_cpus() >= 1
+
+    def test_get_cc(self):
+        setup = self.import_setup_py()
+        with mock.patch.dict(os.environ, {"CC": "gcc -pthread"}):
+            assert setup.get_cc() == ["gcc", "-pthread"]
+
+    @staticmethod
+    def run_instructions(setup, **flags):
+        """Call print_install_instructions() and return what it wrote
+        to stderr.
+        """
+        with contextlib.ExitStack() as stack:
+            for name, value in flags.items():
+                stack.enter_context(mock.patch.object(setup, name, value))
+            f = stack.enter_context(contextlib.redirect_stderr(io.StringIO()))
+            setup.print_install_instructions()
+        return f.getvalue()
+
+    def test_instructions_are_silent_if_toolchain_is_ok(self):
+        # Else any unrelated build failure would wrongly blame the
+        # compiler or the headers.
+        setup = self.import_setup_py()
+        out = self.run_instructions(
+            setup, has_compiler=lambda: True, has_python_h=lambda: True
+        )
+        assert out == ""
+
+    def test_instructions_without_compiler(self):
+        setup = self.import_setup_py()
+        out = self.run_instructions(
+            setup,
+            has_compiler=lambda: False,
+            MACOS=False,
+            AIX=False,
+            PYPY=False,
+        )
+        assert "C compiler is not installed" in out
+        assert "install-sysdeps.sh" in out
+
+    def test_instructions_on_macos(self):
+        setup = self.import_setup_py()
+        out = self.run_instructions(
+            setup, has_compiler=lambda: False, MACOS=True
+        )
+        assert "xcode-select --install" in out
+        assert "install-sysdeps.sh" not in out
+
+    def test_instructions_without_headers(self):
+        # No command is suggested on platforms install-sysdeps.sh
+        # doesn't cover.
+        setup = self.import_setup_py()
+        out = self.run_instructions(
+            setup,
+            has_compiler=lambda: True,
+            has_python_h=lambda: False,
+            MACOS=False,
+            AIX=True,
+            PYPY=False,
+        )
+        assert "header files are not installed" in out
+        assert "Try running" not in out
+
+    def test_detection_without_compiler(self):
+        setup = self.import_setup_py()
+        with mock.patch.dict(os.environ, {"CC": "psutil-no-such-cc"}):
+            assert setup.has_compiler() is False
+            assert setup.has_python_h() is False
diff --git a/tests/test_osx.py b/tests/test_osx.py
new file mode 100755
index 0000000000..a354d2c311
--- /dev/null
+++ b/tests/test_osx.py
@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""macOS specific tests."""
+
+import re
+import time
+
+import psutil
+from psutil import MACOS
+from psutil import _psutil
+
+from . import AARCH64
+from . import HAS_BATTERY
+from . import TOLERANCE_DISK_USAGE
+from . import TOLERANCE_SYS_MEM
+from . import PsutilTestCase
+from . import retry_on_failure
+from . import sh
+from . import skipif
+from . import spawn_subproc
+from . import terminate
+
+
+def sysctl(cmdline):
+    """Expects a sysctl command with an argument and parse the result
+    returning only the value of interest.
+    """
+    out = sh(cmdline)
+    result = out.split()[1]
+    try:
+        return int(result)
+    except ValueError:
+        return result
+
+
+def vm_stat(field):
+    """Wrapper around 'vm_stat' cmdline utility."""
+    out = sh('vm_stat')
+    for line in out.split('\n'):
+        if field in line:
+            break
+    else:
+        raise ValueError("line not found")
+    return int(re.search(r'\d+', line).group(0)) * _psutil.getpagesize()
+
+
+@skipif(not MACOS, reason="MACOS only")
+class MacosTestCase(PsutilTestCase):
+    pass
+
+
+# =====================================================================
+# --- Process APIs (most are tested in test_posix.py)
+# =====================================================================
+
+
+class TestProcess(MacosTestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.pid = spawn_subproc().pid
+
+    @classmethod
+    def tearDownClass(cls):
+        terminate(cls.pid)
+
+    def test_create_time(self):
+        output = sh(f"ps -o lstart -p {self.pid}")
+        start_ps = output.replace('STARTED', '').strip()
+        hhmmss = start_ps.split(' ')[-2]
+        year = start_ps.split(' ')[-1]
+        start_psutil = psutil.Process(self.pid).create_time()
+        assert hhmmss == time.strftime(
+            "%H:%M:%S", time.localtime(start_psutil)
+        )
+        assert year == time.strftime("%Y", time.localtime(start_psutil))
+
+
+# =====================================================================
+# --- Test system APIs
+# =====================================================================
+
+
+class TestVirtualMemory(MacosTestCase):
+
+    def test_total(self):
+        sysctl_hwphymem = sysctl('sysctl hw.memsize')
+        assert sysctl_hwphymem == psutil.virtual_memory().total
+
+    @retry_on_failure
+    def test_free(self):
+        vmstat_val = vm_stat("free")
+        psutil_val = psutil.virtual_memory().free
+        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM * 5
+
+    @retry_on_failure
+    def test_active(self):
+        vmstat_val = vm_stat("active")
+        psutil_val = psutil.virtual_memory().active
+        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM * 5
+
+    @retry_on_failure
+    def test_inactive(self):
+        vmstat_val = vm_stat("inactive")
+        psutil_val = psutil.virtual_memory().inactive
+        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM * 5
+
+    @retry_on_failure
+    def test_wired(self):
+        vmstat_val = vm_stat("wired")
+        psutil_val = psutil.virtual_memory().wired
+        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM * 5
+
+
+class TestSwapMemory(MacosTestCase):
+
+    @staticmethod
+    def parse_swapusage(out):
+        # Parse 'sysctl vm.swapusage' output into bytes.
+        # E.g. 'total = 2.00G' -> 2147483648.
+        units = {"K": 1024, "M": 1024**2, "G": 1024**3}
+        ret = {}
+        for key in ("total", "used", "free"):
+            m = re.search(rf"{key}\s*=\s*([0-9.]+)([KMG])", out)
+            ret[key] = int(float(m.group(1)) * units[m.group(2)])
+        return ret
+
+    def test_total(self):
+        out = sh("sysctl vm.swapusage")
+        sysctl_val = self.parse_swapusage(out)["total"]
+        # 0.01M display precision = ~10KB rounding
+        assert abs(psutil.swap_memory().total - sysctl_val) < 100 * 1024
+
+    @retry_on_failure
+    def test_used(self):
+        out = sh("sysctl vm.swapusage")
+        sysctl_val = self.parse_swapusage(out)["used"]
+        assert abs(psutil.swap_memory().used - sysctl_val) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_free(self):
+        out = sh("sysctl vm.swapusage")
+        sysctl_val = self.parse_swapusage(out)["free"]
+        assert abs(psutil.swap_memory().free - sysctl_val) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_sin(self):
+        vmstat_val = vm_stat("Pageins")
+        psutil_val = psutil.swap_memory().sin
+        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM
+
+    @retry_on_failure
+    def test_sout(self):
+        vmstat_val = vm_stat("Pageout")
+        psutil_val = psutil.swap_memory().sout
+        assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM
+
+
+class TestCpuAPIs(MacosTestCase):
+
+    def test_cpu_count_logical(self):
+        num = sysctl("sysctl hw.logicalcpu")
+        assert num == psutil.cpu_count(logical=True)
+
+    def test_cpu_count_cores(self):
+        num = sysctl("sysctl hw.physicalcpu")
+        assert num == psutil.cpu_count(logical=False)
+
+    # On Apple Silicon cpu_freq() reads IOKit, and there's no sysctl
+    # (or any other CLI tool) to compare it against.
+    @skipif(AARCH64, reason="no hw.cpufrequency sysctl on Apple Silicon")
+    def test_cpu_freq(self):
+        freq = psutil.cpu_freq()
+        assert freq.current * 1000 * 1000 == sysctl("sysctl hw.cpufrequency")
+        assert freq.min * 1000 * 1000 == sysctl("sysctl hw.cpufrequency_min")
+        assert freq.max * 1000 * 1000 == sysctl("sysctl hw.cpufrequency_max")
+
+
+class TestDiskAPIs(MacosTestCase):
+
+    @retry_on_failure
+    def test_disk_partitions(self):
+        # test psutil.disk_usage() and psutil.disk_partitions()
+        # against "df -a"
+        def df(path):
+            out = sh(f'df -k "{path}"').strip()
+            lines = out.split('\n')
+            lines.pop(0)
+            line = lines.pop(0)
+            dev, total, used, free = line.split()[:4]
+            if dev == 'none':
+                dev = ''
+            total = int(total) * 1024
+            used = int(used) * 1024
+            free = int(free) * 1024
+            return dev, total, used, free
+
+        for part in psutil.disk_partitions(all=False):
+            usage = psutil.disk_usage(part.mountpoint)
+            dev, total, used, free = df(part.mountpoint)
+            assert part.device == dev
+            assert usage.total == total
+            assert abs(usage.free - free) < TOLERANCE_DISK_USAGE
+            assert abs(usage.used - used) < TOLERANCE_DISK_USAGE
+
+
+class TestNetAPIs(MacosTestCase):
+
+    def test_net_if_stats(self):
+        for name, stats in psutil.net_if_stats().items():
+            try:
+                out = sh(f"ifconfig {name}")
+            except RuntimeError:
+                pass
+            else:
+                assert stats.isup == ('RUNNING' in out), out
+                assert stats.mtu == int(re.findall(r'mtu (\d+)', out)[0])
+
+    @retry_on_failure
+    def test_net_io_counters(self):
+        out = sh("netstat -ib")
+        netstat = {}
+        for line in out.splitlines():
+            fields = line.split()
+            if len(fields) < 10 or "<Link#" not in fields[2]:
+                continue
+            name = fields[0].rstrip("*")
+            if len(fields) == 11:
+                ibytes, obytes = int(fields[6]), int(fields[9])
+            else:
+                ibytes, obytes = int(fields[5]), int(fields[8])
+            netstat[name] = (ibytes, obytes)
+        ps = psutil.net_io_counters(pernic=True)
+        tolerance = 1 * 1024 * 1024  # 1 MB
+        for name, (ibytes, obytes) in netstat.items():
+            if name not in ps:
+                continue
+            assert abs(ps[name].bytes_recv - ibytes) < tolerance
+            assert abs(ps[name].bytes_sent - obytes) < tolerance
+
+
+class TestSensorsAPIs(MacosTestCase):
+
+    @skipif(not HAS_BATTERY, reason="no battery")
+    def test_sensors_battery(self):
+        out = sh("pmset -g batt")
+        percent = re.search(r"(\d+)%", out).group(1)
+        drawing_from = re.search(r"Now drawing from '([^']+)'", out).group(1)
+        power_plugged = drawing_from == "AC Power"
+        psutil_result = psutil.sensors_battery()
+        assert psutil_result.power_plugged == power_plugged
+        assert psutil_result.percent == int(percent)
+
+
+class TestOtherSystemAPIs(MacosTestCase):
+
+    def test_boot_time(self):
+        out = sh('sysctl kern.boottime')
+        a = float(re.search(r"sec\s*=\s*(\d+)", out).groups(0)[0])
+        b = psutil.boot_time()
+        assert a == b
diff --git a/tests/test_posix.py b/tests/test_posix.py
new file mode 100755
index 0000000000..f1fd969f4e
--- /dev/null
+++ b/tests/test_posix.py
@@ -0,0 +1,590 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""POSIX specific tests."""
+
+import datetime
+import errno
+import os
+import re
+import subprocess
+import time
+from unittest import mock
+
+import psutil
+from psutil import AIX
+from psutil import BSD
+from psutil import LINUX
+from psutil import MACOS
+from psutil import OPENBSD
+from psutil import POSIX
+from psutil import SUNOS
+from psutil import _psposix
+from psutil import _psutil
+
+from . import AARCH64
+from . import HAS_NET_IO_COUNTERS
+from . import PYTHON_EXE
+from . import PsutilTestCase
+from . import is_busybox
+from . import isolated
+from . import pytest
+from . import requires_cli
+from . import retry_on_failure
+from . import sh
+from . import skip_on_access_denied
+from . import skipif
+from . import spawn_subproc
+from . import terminate
+
+if POSIX:
+    import mmap
+    import pty
+    import resource
+
+NO_UTMP = LINUX and not os.path.exists("/var/run/utmp")
+
+
+def ps(fmt, pid=None):
+    """Wrapper for calling the ps command with a little bit of cross-platform
+    support for a narrow range of features.
+    """
+    if is_busybox("ps"):
+        return pytest.skip("busybox ps lacks the needed options")
+
+    cmd = ['ps']
+
+    if LINUX:
+        cmd.append('--no-headers')
+
+    if pid is not None:
+        cmd.extend(['-p', str(pid)])
+    elif SUNOS or AIX:
+        cmd.append('-A')
+    else:
+        cmd.append('ax')
+
+    if SUNOS:
+        fmt = fmt.replace("start", "stime")
+
+    cmd.extend(['-o', fmt])
+
+    output = sh(cmd)
+
+    output = output.splitlines() if LINUX else output.splitlines()[1:]
+
+    all_output = []
+    for line in output:
+        line = line.strip()
+
+        try:
+            line = int(line)
+        except ValueError:
+            pass
+
+        all_output.append(line)
+
+    if pid is None:
+        return all_output
+    else:
+        return all_output[0]
+
+
+# ps "-o" field names differ wildly between platforms.
+# "comm" means "only executable name" but is not available on BSD platforms.
+# "args" means "command with all its arguments", and is also not available
+# on BSD platforms.
+# "command" is like "args" on most platforms, but like "comm" on AIX,
+# and not available on SUNOS.
+# so for the executable name we can use "comm" on Solaris and split "command"
+# on other platforms.
+# to get the cmdline (with args) we have to use "args" on AIX and
+# Solaris, and can use "command" on all others.
+
+
+def ps_name(pid):
+    field = "command"
+    if SUNOS:
+        field = "comm"
+    command = ps(field, pid).split()
+    return command[0]
+
+
+def ps_args(pid):
+    field = "command"
+    if AIX or SUNOS:
+        field = "args"
+    out = ps(field, pid)
+    # observed on BSD + Github CI: '/usr/local/bin/python3 -E -O (python3.9)'
+    out = re.sub(r"\(python.*?\)$", "", out)
+    return out.strip()
+
+
+def ps_rss(pid):
+    field = "rss"
+    if AIX:
+        field = "rssize"
+    return ps(field, pid)
+
+
+def ps_vsz(pid):
+    field = "vsz"
+    if AIX:
+        field = "vsize"
+    return ps(field, pid)
+
+
+def df(device):
+    try:
+        out = sh(f"df -k {device}").strip()
+    except RuntimeError as err:
+        if "device busy" in str(err).lower():
+            return pytest.skip("df returned EBUSY")
+        raise
+    line = out.split('\n')[1]
+    fields = line.split()
+    sys_total = int(fields[1]) * 1024
+    sys_used = int(fields[2]) * 1024
+    sys_free = int(fields[3]) * 1024
+    sys_percent = float(fields[4].replace('%', ''))
+    return (sys_total, sys_used, sys_free, sys_percent)
+
+
+@skipif(not POSIX, reason="POSIX only")
+class PosixTestCase(PsutilTestCase):
+    pass
+
+
+class TestProcess(PosixTestCase):
+    """Compare psutil results against 'ps' command line utility (mainly)."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.pid = spawn_subproc(
+            [PYTHON_EXE, "-E", "-O"], stdin=subprocess.PIPE
+        ).pid
+
+    @classmethod
+    def tearDownClass(cls):
+        terminate(cls.pid)
+
+    def test_ppid(self):
+        ppid_ps = ps('ppid', self.pid)
+        ppid_psutil = psutil.Process(self.pid).ppid()
+        assert ppid_ps == ppid_psutil
+
+    def test_uid(self):
+        uid_ps = ps('uid', self.pid)
+        uid_psutil = psutil.Process(self.pid).uids().real
+        assert uid_ps == uid_psutil
+
+    def test_gid(self):
+        gid_ps = ps('rgid', self.pid)
+        gid_psutil = psutil.Process(self.pid).gids().real
+        assert gid_ps == gid_psutil
+
+    def test_username(self):
+        username_ps = ps('user', self.pid)
+        username_psutil = psutil.Process(self.pid).username()
+        assert username_ps == username_psutil
+
+    def test_username_no_resolution(self):
+        # Emulate a case where the system can't resolve the uid to
+        # a username in which case psutil is supposed to return
+        # the stringified uid.
+        p = psutil.Process()
+        with mock.patch("psutil.pwd.getpwuid", side_effect=KeyError) as fun:
+            assert p.username() == str(p.uids().real)
+            assert fun.called
+
+    @skip_on_access_denied
+    @retry_on_failure
+    def test_rss_memory(self):
+        # give python interpreter some time to properly initialize
+        # so that the results are the same
+        time.sleep(0.1)
+        rss_ps = ps_rss(self.pid)
+        rss_psutil = psutil.Process(self.pid).memory_info()[0] / 1024
+        assert rss_ps == rss_psutil
+
+    @skip_on_access_denied
+    @retry_on_failure
+    def test_vsz_memory(self):
+        # give python interpreter some time to properly initialize
+        # so that the results are the same
+        time.sleep(0.1)
+        vsz_ps = ps_vsz(self.pid)
+        vsz_psutil = psutil.Process(self.pid).memory_info()[1] / 1024
+        assert vsz_ps == vsz_psutil
+
+    def test_name(self):
+        name_ps = ps_name(self.pid)
+        # remove path if there is any, from the command
+        name_ps = os.path.basename(name_ps).lower()
+        name_psutil = psutil.Process(self.pid).name().lower()
+        # ...because of how we calculate PYTHON_EXE; on MACOS this may
+        # be "pythonX.Y".
+        name_ps = re.sub(r"\d.\d", "", name_ps)
+        name_psutil = re.sub(r"\d.\d", "", name_psutil)
+        # ...may also be "python.X"
+        name_ps = re.sub(r"\d", "", name_ps)
+        name_psutil = re.sub(r"\d", "", name_psutil)
+        assert name_ps == name_psutil
+
+    def test_name_long(self):
+        # On UNIX the kernel truncates the name to the first 15
+        # characters. In such a case psutil tries to determine the
+        # full name from the cmdline.
+        name = "long-program-name"
+        cmdline = ["long-program-name-extended", "foo", "bar"]
+        with mock.patch("psutil._psplatform.Process.name", return_value=name):
+            with mock.patch(
+                "psutil._psplatform.Process.cmdline", return_value=cmdline
+            ):
+                p = psutil.Process()
+                assert p.name() == "long-program-name-extended"
+
+    def test_name_long_cmdline_ad_exc(self):
+        # Same as above but emulates a case where cmdline() raises
+        # AccessDenied in which case psutil is supposed to return
+        # the truncated name instead of crashing.
+        name = "long-program-name"
+        with mock.patch("psutil._psplatform.Process.name", return_value=name):
+            with mock.patch(
+                "psutil._psplatform.Process.cmdline",
+                side_effect=psutil.AccessDenied(0, ""),
+            ):
+                p = psutil.Process()
+                assert p.name() == "long-program-name"
+
+    def test_name_long_cmdline_nsp_exc(self):
+        # Same as above but emulates a case where cmdline() raises NSP
+        # which is supposed to propagate.
+        name = "long-program-name"
+        with mock.patch("psutil._psplatform.Process.name", return_value=name):
+            with mock.patch(
+                "psutil._psplatform.Process.cmdline",
+                side_effect=psutil.NoSuchProcess(0, ""),
+            ):
+                p = psutil.Process()
+                with pytest.raises(psutil.NoSuchProcess):
+                    p.name()
+
+    @skipif(MACOS or BSD, reason="ps -o start not available")
+    def test_create_time(self):
+        time_ps = ps('start', self.pid)
+        time_psutil = psutil.Process(self.pid).create_time()
+        time_psutil_tstamp = datetime.datetime.fromtimestamp(
+            time_psutil
+        ).strftime("%H:%M:%S")
+        # sometimes ps shows the time rounded up instead of down, so we check
+        # for both possible values
+        round_time_psutil = round(time_psutil)
+        round_time_psutil_tstamp = datetime.datetime.fromtimestamp(
+            round_time_psutil
+        ).strftime("%H:%M:%S")
+        assert time_ps in {time_psutil_tstamp, round_time_psutil_tstamp}
+
+    def test_exe(self):
+        ps_pathname = ps_name(self.pid)
+        psutil_pathname = psutil.Process(self.pid).exe()
+        try:
+            assert ps_pathname == psutil_pathname
+        except AssertionError:
+            # certain platforms such as BSD are more accurate returning:
+            # "/usr/local/bin/python3.7"
+            # ...instead of:
+            # "/usr/local/bin/python"
+            # We do not want to consider this difference in accuracy
+            # an error.
+            adjusted_ps_pathname = ps_pathname[: len(ps_pathname)]
+            assert ps_pathname == adjusted_ps_pathname
+
+    # On macOS the official python installer exposes a python wrapper that
+    # executes a python executable hidden inside an application bundle inside
+    # the Python framework.
+    # There's a race condition between the ps call & the psutil call below
+    # depending on the completion of the execve call so let's retry on failure
+    @retry_on_failure
+    def test_cmdline(self):
+        ps_cmdline = ps_args(self.pid)
+        psutil_cmdline = " ".join(psutil.Process(self.pid).cmdline())
+        if AARCH64 and len(ps_cmdline) < len(psutil_cmdline):
+            assert psutil_cmdline.startswith(ps_cmdline)
+        else:
+            assert ps_cmdline == psutil_cmdline
+
+    # On SUNOS "ps" reads niceness /proc/pid/psinfo which returns an
+    # incorrect value (20); the real deal is getpriority(2) which
+    # returns 0; psutil relies on it, see:
+    # https://github.com/giampaolo/psutil/issues/1082
+    # AIX has the same issue
+    @skipif(SUNOS, reason="not reliable on SUNOS")
+    @skipif(AIX, reason="not reliable on AIX")
+    def test_nice(self):
+        ps_nice = ps('nice', self.pid)
+        psutil_nice = psutil.Process().nice()
+        assert ps_nice == psutil_nice
+
+    @isolated
+    @retry_on_failure
+    def test_num_ctx_switches(self):
+        # getrusage() keeps counting threads which already exited, and
+        # /proc/pid/status only sees the live ones, so the totals drift
+        # apart for good. Compare how much each grows instead.
+        p = psutil.Process()
+        ru1 = resource.getrusage(resource.RUSAGE_SELF)
+        cws1 = p.num_ctx_switches()
+        for _ in range(100):
+            time.sleep(0.001)  # each sleep blocks, hence a switch
+        ru2 = resource.getrusage(resource.RUSAGE_SELF)
+        cws2 = p.num_ctx_switches()
+
+        tol = 50
+        if MACOS:
+            psutil_delta = (cws2.voluntary + cws2.involuntary) - (
+                cws1.voluntary + cws1.involuntary
+            )
+            ru_delta = (ru2.ru_nvcsw + ru2.ru_nivcsw) - (
+                ru1.ru_nvcsw + ru1.ru_nivcsw
+            )
+            assert psutil_delta == pytest.approx(ru_delta, abs=tol * 2)
+        else:
+            assert cws2.voluntary - cws1.voluntary == pytest.approx(
+                ru2.ru_nvcsw - ru1.ru_nvcsw, abs=tol
+            )
+            assert cws2.involuntary - cws1.involuntary == pytest.approx(
+                ru2.ru_nivcsw - ru1.ru_nivcsw, abs=tol
+            )
+
+    @retry_on_failure
+    def test_cpu_times(self):
+        ru = resource.getrusage(resource.RUSAGE_SELF)
+        cws = psutil.Process().cpu_times()
+        assert cws.user == pytest.approx(ru.ru_utime, abs=0.3)
+        assert cws.system == pytest.approx(ru.ru_stime, abs=0.3)
+
+    @retry_on_failure
+    @isolated
+    def test_page_faults(self):
+        ru = resource.getrusage(resource.RUSAGE_SELF)
+        pf = psutil.Process().page_faults()
+        # Minor faults may change between reads, and the kernel
+        # counters are not updated atomically, so allow some slack.
+        # Seen ~50 apart on OpenBSD.
+        assert pf.minor == pytest.approx(ru.ru_minflt, abs=100)
+        assert pf.major == pytest.approx(ru.ru_majflt, abs=5)
+
+    @skipif(not LINUX and not MACOS, reason="Linux, macOS only")
+    def test_page_faults_minor_increase(self):
+        # Access 200 new anonymous pages; each first access triggers a
+        # minor fault.
+        p = psutil.Process()
+        pf_before = p.page_faults()
+        with mmap.mmap(-1, 200 * mmap.PAGESIZE) as m:
+            for i in range(0, 200 * mmap.PAGESIZE, mmap.PAGESIZE):
+                m[i : i + 1] = b'\x00'
+        pf_after = p.page_faults()
+        assert pf_after.minor > pf_before.minor
+
+    def test_memory_peak_rss(self):
+        p = psutil.Process()
+        if LINUX:
+            rss = p.memory_info().rss
+            mem = p.memory_extras()
+        else:
+            mem = p.memory_info()
+            rss = mem.rss
+        if not hasattr(mem, "peak_rss"):
+            return pytest.skip("not supported")
+        assert mem.peak_rss >= rss
+        ru = resource.getrusage(resource.RUSAGE_SELF)
+        if LINUX:
+            # ru_maxrss is computed from the per-CPU RSS counters, which
+            # lag behind the exact value exposed as VmHWM. The gap is
+            # absolute (tens of MBs) and grows with the number of CPUs,
+            # so only compare the order of magnitude.
+            assert mem.peak_rss == pytest.approx(ru.ru_maxrss * 1024, rel=1)
+        else:
+            # ru_maxrss is in bytes on macOS, in KB everywhere else.
+            maxrss = ru.ru_maxrss if MACOS else ru.ru_maxrss * 1024
+            rss_diff = abs(mem.peak_rss - maxrss)
+            assert rss_diff <= mem.peak_rss * 0.05
+
+
+class TestSystemAPIs(PosixTestCase):
+    """Test some system APIs."""
+
+    @retry_on_failure
+    def test_pids(self):
+        # Note: this test might fail if the OS is starting/killing
+        # other processes in the meantime
+        pids_ps = sorted(ps("pid"))
+        pids_psutil = psutil.pids()
+
+        # on MACOS and OPENBSD ps doesn't show pid 0
+        if MACOS or (OPENBSD and 0 not in pids_ps):
+            pids_ps.insert(0, 0)
+
+        # There will often be one more process in pids_ps for ps itself
+        if len(pids_ps) - len(pids_psutil) > 1:
+            difference = [x for x in pids_psutil if x not in pids_ps] + [
+                x for x in pids_ps if x not in pids_psutil
+            ]
+            return pytest.fail("difference: " + str(difference))
+
+    # for some reason ifconfig -a does not report all interfaces
+    # returned by psutil
+    @skipif(SUNOS, reason="unreliable on SUNOS")
+    @requires_cli("ifconfig")
+    @skipif(not HAS_NET_IO_COUNTERS, reason="not supported")
+    def test_nic_names(self):
+        output = sh("ifconfig -a")
+        for nic in psutil.net_io_counters(pernic=True):
+            for line in output.split():
+                if line.startswith(nic):
+                    break
+            else:
+                return pytest.fail(
+                    f"couldn't find {nic} nic in 'ifconfig -a'"
+                    f" output\n{output}"
+                )
+
+    @skipif(is_busybox("who"), reason="busybox who has no -u option")
+    @skipif(NO_UTMP, reason="no /var/run/utmp file")
+    @retry_on_failure
+    def test_users(self):
+        out = sh("who -u")
+        if not out.strip():
+            return pytest.skip("no users on this system")
+
+        susers = []
+        for line in out.splitlines():
+            user = line.split()[0]
+            terminal = line.split()[1]
+            if LINUX or MACOS:
+                pid = next(
+                    int(x) for x in reversed(line.split()) if x.isdigit()
+                )
+                susers.append((user, terminal, pid))
+            else:
+                susers.append((user, terminal))
+
+        if LINUX or MACOS:
+            pusers = [(u.name, u.terminal, u.pid) for u in psutil.users()]
+        else:
+            pusers = [(u.name, u.terminal) for u in psutil.users()]
+
+        assert len(susers) == len(pusers)
+        assert sorted(susers) == sorted(pusers)
+
+        for user in psutil.users():
+            if user.pid is not None:
+                assert user.pid > 0
+
+    @skipif(is_busybox("who"), reason="busybox who has no -u option")
+    @retry_on_failure
+    def test_users_started(self):
+        out = sh("who -u")
+        if not out.strip():
+            return pytest.skip("no users on this system")
+        tstamp = None
+        # '2023-04-11 09:31' (Linux)
+        started = re.findall(r"\d\d\d\d-\d\d-\d\d \d\d:\d\d", out)
+        if started:
+            tstamp = "%Y-%m-%d %H:%M"
+        else:
+            # 'Apr 10 22:27' (macOS)
+            started = re.findall(r"[A-Z][a-z][a-z] \d\d \d\d:\d\d", out)
+            if started:
+                tstamp = "%b %d %H:%M"
+            else:
+                # 'Apr 10'
+                started = re.findall(r"[A-Z][a-z][a-z] \d\d", out)
+                if started:
+                    tstamp = "%b %d"
+                else:
+                    # 'apr 10' (sunOS)
+                    started = re.findall(r"[a-z][a-z][a-z] \d\d", out)
+                    if started:
+                        tstamp = "%b %d"
+                        started = [x.capitalize() for x in started]
+
+        if not tstamp:
+            return pytest.skip(f"cannot interpret tstamp in who output\n{out}")
+
+        for idx, u in enumerate(psutil.users()):
+            psutil_value = datetime.datetime.fromtimestamp(u.started).strftime(
+                tstamp
+            )
+            assert psutil_value == started[idx]
+
+    def test_pid_exists_let_raise(self):
+        # According to "man 2 kill" possible error values for kill
+        # are (EINVAL, EPERM, ESRCH). Test that any other errno
+        # results in an exception.
+        with mock.patch(
+            "psutil._psposix.os.kill", side_effect=OSError(errno.EBADF, "")
+        ) as m:
+            with pytest.raises(OSError):
+                psutil._psposix.pid_exists(os.getpid())
+            assert m.called
+
+    # AIX can return '-' in df output instead of numbers, e.g. for /proc
+    @skipif(AIX, reason="unreliable on AIX")
+    @retry_on_failure
+    def test_disk_usage(self):
+        tolerance = 4 * 1024 * 1024  # 4MB
+        for part in psutil.disk_partitions(all=False):
+            usage = psutil.disk_usage(part.mountpoint)
+            try:
+                sys_total, sys_used, sys_free, sys_percent = df(
+                    part.mountpoint
+                )
+            except RuntimeError as err:
+                # see:
+                # https://travis-ci.org/giampaolo/psutil/jobs/138338464
+                # https://travis-ci.org/giampaolo/psutil/jobs/138343361
+                err = str(err).lower()
+                if (
+                    "no such file or directory" in err
+                    or "raw devices not supported" in err
+                    or "permission denied" in err
+                ):
+                    continue
+                raise
+            else:
+                assert abs(usage.total - sys_total) < tolerance
+                assert abs(usage.used - sys_used) < tolerance
+                assert abs(usage.free - sys_free) < tolerance
+                assert abs(usage.percent - sys_percent) <= 1
+
+    def test_terminal_pty_opened_later(self):
+        # A PTY opened after the map was cached must still resolve.
+        # See: https://github.com/giampaolo/psutil/issues/2830
+        _psposix._get_terminal_map()  # prime the cache
+        master, slave = pty.openpty()
+        self.addCleanup(os.close, master)
+        self.addCleanup(os.close, slave)
+        path = os.ttyname(slave)
+        assert _psposix.get_terminal(os.stat(path).st_rdev) == path
+
+    def test_terminal_skip_map(self):
+        # setsid() leaves the child without a controlling terminal.
+        # Such a process must not reach get_terminal().
+        p = self.spawn_psproc(start_new_session=True)
+        assert p.terminal() is None
+        with mock.patch.object(_psposix, "get_terminal") as m:
+            p.terminal()
+            assert not m.called
+
+
+class TestMisc(PosixTestCase):
+    def test_getpagesize(self):
+        pagesize = _psutil.getpagesize()
+        assert pagesize > 0
+        assert pagesize == resource.getpagesize()
+        assert pagesize == mmap.PAGESIZE
diff --git a/tests/test_process.py b/tests/test_process.py
new file mode 100755
index 0000000000..aa9fe1c03d
--- /dev/null
+++ b/tests/test_process.py
@@ -0,0 +1,1998 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Tests for psutil.Process class."""
+
+import collections
+import contextlib
+import enum
+import errno
+import getpass
+import io
+import itertools
+import os
+import random
+import select
+import signal
+import socket
+import stat
+import string
+import subprocess
+import sys
+import time
+from unittest import mock
+
+import psutil
+from psutil import AIX
+from psutil import BSD
+from psutil import FREEBSD
+from psutil import LINUX
+from psutil import MACOS
+from psutil import NETBSD
+from psutil import OPENBSD
+from psutil import OSX
+from psutil import POSIX
+from psutil import SUNOS
+from psutil import WINDOWS
+from psutil import _psutil
+from psutil._common import open_text
+
+from . import CI_TESTING
+from . import GITHUB_ACTIONS
+from . import GLOBAL_TIMEOUT
+from . import HAS_PROC_CPU_AFFINITY
+from . import HAS_PROC_CPU_NUM
+from . import HAS_PROC_ENVIRON
+from . import HAS_PROC_IO_COUNTERS
+from . import HAS_PROC_IONICE
+from . import HAS_PROC_MEMORY_EXTRAS
+from . import HAS_PROC_MEMORY_FOOTPRINT
+from . import HAS_PROC_MEMORY_MAPS
+from . import HAS_PROC_OPEN_FILES_PATH
+from . import HAS_PROC_RLIMIT
+from . import HAS_PROC_THREADS
+from . import PYPY
+from . import PYTHON_EXE
+from . import PYTHON_EXE_ENV
+from . import PsutilTestCase
+from . import ThreadTask
+from . import call_until
+from . import copyload_shared_lib
+from . import create_py_exe
+from . import filter_alien_children
+from . import isolated
+from . import process_namespace
+from . import pytest
+from . import reap_children
+from . import retry_on_failure
+from . import sh
+from . import skip_on_access_denied
+from . import skip_on_not_implemented
+from . import skipif
+from . import wait_for_file
+
+# ===================================================================
+# --- psutil.Process class tests
+# ===================================================================
+
+
+class TestProcess(PsutilTestCase):
+    """Tests for psutil.Process class."""
+
+    def test_pid(self):
+        p = psutil.Process()
+        assert p.pid == os.getpid()
+        with pytest.raises(AttributeError):
+            p.pid = 33
+
+    def test_kill(self):
+        p = self.spawn_psproc()
+        p.kill()
+        code = p.wait()
+        if WINDOWS:
+            assert code == signal.SIGTERM
+        else:
+            assert code == -signal.SIGKILL
+        self.assert_proc_gone(p)
+
+    def test_terminate(self):
+        p = self.spawn_psproc()
+        p.terminate()
+        code = p.wait()
+        if WINDOWS:
+            assert code == signal.SIGTERM
+        else:
+            assert code == -signal.SIGTERM
+        self.assert_proc_gone(p)
+
+    def test_send_signal(self):
+        sig = signal.SIGKILL if POSIX else signal.SIGTERM
+        p = self.spawn_psproc()
+        p.send_signal(sig)
+        code = p.wait()
+        if WINDOWS:
+            assert code == sig
+        else:
+            assert code == -sig
+        self.assert_proc_gone(p)
+
+    @skipif(not POSIX, reason="not POSIX")
+    def test_send_signal_mocked(self):
+        sig = signal.SIGTERM
+        p = self.spawn_psproc()
+        with mock.patch('psutil.os.kill', side_effect=ProcessLookupError):
+            with pytest.raises(psutil.NoSuchProcess):
+                p.send_signal(sig)
+
+        p = self.spawn_psproc()
+        with mock.patch('psutil.os.kill', side_effect=PermissionError):
+            with pytest.raises(psutil.AccessDenied):
+                p.send_signal(sig)
+
+    def test_cpu_percent(self):
+        p = psutil.Process()
+        p.cpu_percent(interval=0.001)
+        p.cpu_percent(interval=0.001)
+        for _ in range(100):
+            percent = p.cpu_percent(interval=None)
+            assert isinstance(percent, float)
+            assert percent >= 0.0
+        with pytest.raises(ValueError):
+            p.cpu_percent(interval=-1)
+
+    def test_cpu_percent_numcpus_none(self):
+        # See: https://github.com/giampaolo/psutil/issues/1087
+        with mock.patch('psutil.cpu_count', return_value=None) as m:
+            psutil.Process().cpu_percent()
+            assert m.called
+
+    def test_cpu_times(self):
+        times = psutil.Process().cpu_times()
+        assert times.user >= 0.0, times
+        assert times.system >= 0.0, times
+        assert times.children_user >= 0.0, times
+        assert times.children_system >= 0.0, times
+        if LINUX:
+            assert times.iowait >= 0.0, times
+        # make sure returned values can be pretty printed with strftime
+        for name in times._fields:
+            time.strftime("%H:%M:%S", time.localtime(getattr(times, name)))
+
+    @skipif(not HAS_PROC_CPU_NUM, reason="not supported")
+    def test_cpu_num(self):
+        p = psutil.Process()
+        num = p.cpu_num()
+        assert num >= 0
+        if psutil.cpu_count() == 1:
+            assert num == 0
+        assert p.cpu_num() in range(psutil.cpu_count())
+
+    def test_create_time(self):
+        p = self.spawn_psproc()
+        now = time.time()
+        # Fail if the difference with current time is > 2s.
+        assert abs(p.create_time() - now) < 2
+        # make sure returned value can be pretty printed with strftime
+        time.strftime("%Y %m %d %H:%M:%S", time.localtime(p.create_time()))
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_terminal(self):
+        terminal = psutil.Process().terminal()
+        if terminal is not None:
+            try:
+                tty = os.path.realpath(sh('tty'))
+            except RuntimeError:
+                # Note: happens if pytest is run without the `-s` opt.
+                return pytest.skip("can't rely on `tty` CLI")
+            else:
+                assert terminal == tty
+
+    @skipif(not HAS_PROC_IO_COUNTERS, reason="not supported")
+    @skip_on_not_implemented(only_if=LINUX)
+    def test_io_counters(self):
+        p = psutil.Process()
+        # test reads
+        io1 = p.io_counters()
+        with open(PYTHON_EXE, 'rb') as f:
+            f.read()
+        io2 = p.io_counters()
+        if not BSD and not AIX:
+            assert io2.read_count > io1.read_count
+            assert io2.write_count == io1.write_count
+            if LINUX:
+                assert io2.read_chars > io1.read_chars
+                assert io2.write_chars == io1.write_chars
+        else:
+            assert io2.read_bytes >= io1.read_bytes
+            assert io2.write_bytes >= io1.write_bytes
+
+        # test writes
+        io1 = p.io_counters()
+        with open(self.get_testfn(), 'wb') as f:
+            f.write(bytes("x" * 1000000, 'ascii'))
+        io2 = p.io_counters()
+        assert io2.write_count >= io1.write_count
+        assert io2.write_bytes >= io1.write_bytes
+        assert io2.read_count >= io1.read_count
+        assert io2.read_bytes >= io1.read_bytes
+        if LINUX:
+            assert io2.write_chars > io1.write_chars
+            assert io2.read_chars >= io1.read_chars
+
+        # sanity check
+        for i in range(len(io2)):
+            if BSD and i >= 2:
+                # On BSD read_bytes and write_bytes are always set to -1.
+                continue
+            assert io2[i] >= 0
+            assert io2[i] >= 0
+
+    @skipif(not HAS_PROC_IONICE, reason="not supported")
+    @skipif(not LINUX, reason="linux only")
+    def test_ionice_linux(self):
+        def cleanup(init):
+            ioclass, value = init
+            if ioclass == psutil.IOPRIO_CLASS_NONE:
+                value = 0
+            p.ionice(ioclass, value)
+
+        p = psutil.Process()
+        if not CI_TESTING:
+            assert p.ionice()[0] == psutil.IOPRIO_CLASS_NONE
+        assert psutil.IOPRIO_CLASS_NONE == 0
+        assert psutil.IOPRIO_CLASS_RT == 1  # high
+        assert psutil.IOPRIO_CLASS_BE == 2  # normal
+        assert psutil.IOPRIO_CLASS_IDLE == 3  # low
+        init = p.ionice()
+        self.addCleanup(cleanup, init)
+
+        # low
+        p.ionice(psutil.IOPRIO_CLASS_IDLE)
+        assert tuple(p.ionice()) == (psutil.IOPRIO_CLASS_IDLE, 0)
+        with pytest.raises(ValueError):  # accepts no value
+            p.ionice(psutil.IOPRIO_CLASS_IDLE, value=7)
+        # normal
+        p.ionice(psutil.IOPRIO_CLASS_BE)
+        assert tuple(p.ionice()) == (psutil.IOPRIO_CLASS_BE, 0)
+        p.ionice(psutil.IOPRIO_CLASS_BE, value=7)
+        assert tuple(p.ionice()) == (psutil.IOPRIO_CLASS_BE, 7)
+        with pytest.raises(ValueError):
+            p.ionice(psutil.IOPRIO_CLASS_BE, value=8)
+        try:
+            p.ionice(psutil.IOPRIO_CLASS_RT, value=7)
+        except psutil.AccessDenied:
+            pass
+        # errs
+        with pytest.raises(ValueError, match="ioclass accepts no value"):
+            p.ionice(psutil.IOPRIO_CLASS_NONE, 1)
+        with pytest.raises(ValueError, match="ioclass accepts no value"):
+            p.ionice(psutil.IOPRIO_CLASS_IDLE, 1)
+        with pytest.raises(
+            ValueError, match="'ioclass' argument must be specified"
+        ):
+            p.ionice(value=1)
+
+    @skipif(not HAS_PROC_IONICE, reason="not supported")
+    @skipif(not WINDOWS, reason="not supported on this win version")
+    def test_ionice_win(self):
+        p = psutil.Process()
+        if not CI_TESTING:
+            assert p.ionice() == psutil.IOPRIO_NORMAL
+        init = p.ionice()
+        self.addCleanup(p.ionice, init)
+
+        # base
+        p.ionice(psutil.IOPRIO_VERYLOW)
+        assert p.ionice() == psutil.IOPRIO_VERYLOW
+        p.ionice(psutil.IOPRIO_LOW)
+        assert p.ionice() == psutil.IOPRIO_LOW
+        try:
+            p.ionice(psutil.IOPRIO_HIGH)
+        except psutil.AccessDenied:
+            pass
+        else:
+            assert p.ionice() == psutil.IOPRIO_HIGH
+        # errs
+        with pytest.raises(
+            TypeError, match="value argument not accepted on Windows"
+        ):
+            p.ionice(psutil.IOPRIO_NORMAL, value=1)
+        with pytest.raises(ValueError, match="is not a valid priority"):
+            p.ionice(psutil.IOPRIO_HIGH + 1)
+
+    @skipif(not HAS_PROC_RLIMIT, reason="not supported")
+    def test_rlimit_get(self):
+        import resource
+
+        p = psutil.Process(os.getpid())
+        names = [x for x in dir(psutil) if x.startswith('RLIMIT')]
+        assert names, names
+        for name in names:
+            value = getattr(psutil, name)
+            assert value >= 0
+            if name in dir(resource):
+                assert value == getattr(resource, name)
+                # XXX - On PyPy RLIMIT_INFINITY returned by
+                # resource.getrlimit() is reported as a very big long
+                # number instead of -1. It looks like a bug with PyPy.
+                if PYPY:
+                    continue
+                assert p.rlimit(value) == resource.getrlimit(value)
+            else:
+                ret = p.rlimit(value)
+                assert len(ret) == 2
+                assert ret[0] >= -1
+                assert ret[1] >= -1
+
+    @skipif(not HAS_PROC_RLIMIT, reason="not supported")
+    def test_rlimit_set(self):
+        p = self.spawn_psproc()
+        p.rlimit(psutil.RLIMIT_NOFILE, (5, 5))
+        assert p.rlimit(psutil.RLIMIT_NOFILE) == (5, 5)
+        # If pid is 0 prlimit() applies to the calling process and
+        # we don't want that.
+        if LINUX:
+            with pytest.raises(ValueError, match="can't use prlimit"):
+                psutil._psplatform.Process(0).rlimit(0)
+        with pytest.raises(ValueError):
+            p.rlimit(psutil.RLIMIT_NOFILE, (5, 5, 5))
+
+    @skipif(not HAS_PROC_RLIMIT, reason="not supported")
+    def test_rlimit(self):
+        p = psutil.Process()
+        testfn = self.get_testfn()
+        soft, hard = p.rlimit(psutil.RLIMIT_FSIZE)
+        try:
+            p.rlimit(psutil.RLIMIT_FSIZE, (1024, hard))
+            with open(testfn, "wb") as f:
+                f.write(b"X" * 1024)
+            # write() or flush() doesn't always cause the exception
+            # but close() will.
+            with pytest.raises(OSError) as exc:
+                with open(testfn, "wb") as f:
+                    f.write(b"X" * 1025)
+            assert exc.value.errno == errno.EFBIG
+        finally:
+            p.rlimit(psutil.RLIMIT_FSIZE, (soft, hard))
+            assert p.rlimit(psutil.RLIMIT_FSIZE) == (soft, hard)
+
+    @skipif(not HAS_PROC_RLIMIT, reason="not supported")
+    def test_rlimit_infinity(self):
+        # First set a limit, then re-set it by specifying INFINITY
+        # and assume we overridden the previous limit.
+        p = psutil.Process()
+        soft, hard = p.rlimit(psutil.RLIMIT_FSIZE)
+        try:
+            p.rlimit(psutil.RLIMIT_FSIZE, (1024, hard))
+            p.rlimit(psutil.RLIMIT_FSIZE, (psutil.RLIM_INFINITY, hard))
+            with open(self.get_testfn(), "wb") as f:
+                f.write(b"X" * 2048)
+        finally:
+            p.rlimit(psutil.RLIMIT_FSIZE, (soft, hard))
+            assert p.rlimit(psutil.RLIMIT_FSIZE) == (soft, hard)
+
+    @skipif(not HAS_PROC_RLIMIT, reason="not supported")
+    def test_rlimit_infinity_value(self):
+        # RLIMIT_FSIZE should be RLIM_INFINITY, which will be a really
+        # big number on a platform with large file support.  On these
+        # platforms we need to test that the get/setrlimit functions
+        # properly convert the number to a C long long and that the
+        # conversion doesn't raise an error.
+        p = psutil.Process()
+        soft, hard = p.rlimit(psutil.RLIMIT_FSIZE)
+        assert hard == psutil.RLIM_INFINITY
+        p.rlimit(psutil.RLIMIT_FSIZE, (soft, hard))
+
+    @isolated
+    def test_num_threads(self):
+        # on certain platforms such as Linux we might test for exact
+        # thread number, since we always have with 1 thread per process,
+        # but this does not apply across all platforms (MACOS, Windows)
+        p = psutil.Process()
+        if OPENBSD:
+            try:
+                step1 = p.num_threads()
+            except psutil.AccessDenied:
+                return pytest.skip("on OpenBSD this requires root access")
+        else:
+            step1 = p.num_threads()
+
+        with ThreadTask():
+            step2 = p.num_threads()
+            assert step2 == step1 + 1
+
+    @skipif(not WINDOWS, reason="WINDOWS only")
+    def test_num_handles(self):
+        # a better test is done later into test/_windows.py
+        p = psutil.Process()
+        assert p.num_handles() > 0
+
+    @skipif(not HAS_PROC_THREADS, reason="not supported")
+    @isolated
+    def test_threads(self):
+        p = psutil.Process()
+        if OPENBSD:
+            try:
+                step1 = p.threads()
+            except psutil.AccessDenied:
+                return pytest.skip("on OpenBSD this requires root access")
+        else:
+            step1 = p.threads()
+
+        with ThreadTask():
+            step2 = p.threads()
+            assert len(step2) == len(step1) + 1
+            athread = step2[0]
+            # test named tuple
+            assert athread.id == athread[0]
+            assert athread.user_time == athread[1]
+            assert athread.system_time == athread[2]
+
+    @retry_on_failure
+    @skip_on_access_denied(only_if=MACOS)
+    @skipif(not HAS_PROC_THREADS, reason="not supported")
+    def test_threads_2(self):
+        p = self.spawn_psproc()
+        if OPENBSD:
+            try:
+                p.threads()
+            except psutil.AccessDenied:
+                return pytest.skip("on OpenBSD this requires root access")
+        assert (
+            abs(p.cpu_times().user - sum(x.user_time for x in p.threads()))
+            < 0.1
+        )
+        assert (
+            abs(p.cpu_times().system - sum(x.system_time for x in p.threads()))
+            < 0.1
+        )
+
+    @retry_on_failure
+    def test_memory_info(self):
+        p = psutil.Process()
+        self.check_proc_memory(p.memory_info())
+
+        # step 1 - get a base value to compare our results
+        rss1, vms1 = p.memory_info()[:2]
+        percent1 = p.memory_percent()
+        assert rss1 > 0
+        assert vms1 > 0
+
+        # step 2 - allocate some memory
+        memarr = [None] * 1500000
+
+        rss2, vms2 = p.memory_info()[:2]
+        percent2 = p.memory_percent()
+
+        # step 3 - make sure that the memory usage bumped up
+        assert rss2 > rss1
+        assert vms2 >= vms1  # vms might be equal
+        assert percent2 > percent1
+        del memarr
+
+    @skipif(not HAS_PROC_MEMORY_EXTRAS, reason="not supported")
+    def test_memory_extras(self):
+        p = psutil.Process()
+        info = p.memory_info()
+        mem = p.memory_extras()
+        self.check_proc_memory(mem)
+        if LINUX:
+            assert mem.peak_rss >= info.rss
+            assert mem.peak_vms >= info.vms
+        elif MACOS:
+            # peak_footprint is 0 on macOS < 10.13 (no RUSAGE_INFO_V4)
+            if mem.peak_footprint != 0:
+                assert mem.peak_footprint >= mem.phys_footprint
+        elif WINDOWS:
+            assert mem.peak_virtual >= mem.virtual
+            assert mem.peak_paged_pool >= mem.paged_pool
+            assert mem.peak_nonpaged_pool >= mem.nonpaged_pool
+
+    @skipif(not HAS_PROC_MEMORY_EXTRAS, reason="not supported")
+    def test_memory_extras_fields_order(self):
+        mem = psutil.Process().memory_extras()
+        if LINUX:
+            assert mem._fields == (
+                "peak_rss",
+                "peak_vms",
+                "rss_anon",
+                "rss_file",
+                "rss_shmem",
+                "swap_anon",
+                "hugetlb",
+            )
+        elif MACOS:
+            assert mem._fields == ("phys_footprint", "peak_footprint")
+        elif WINDOWS:
+            assert mem._fields == (
+                "virtual",
+                "peak_virtual",
+                "paged_pool",
+                "nonpaged_pool",
+                "peak_paged_pool",
+                "peak_nonpaged_pool",
+            )
+
+    @skipif(not HAS_PROC_MEMORY_FOOTPRINT, reason="not supported")
+    def test_memory_footprint(self):
+        p = psutil.Process()
+        mem = p.memory_footprint()
+        self.check_proc_memory(mem)
+
+    def test_memory_full_info(self):
+        p = psutil.Process()
+        with pytest.warns(DeprecationWarning):
+            mem = p.memory_full_info()
+        # not returned by default
+        assert 'memory_full_info' not in p.as_dict()
+        # but explicitly requesting it should work
+        with pytest.warns(DeprecationWarning):
+            d = p.as_dict(attrs=['memory_full_info'])
+        assert 'memory_full_info' in d
+        # fields should be memory_info() + memory_footprint() (if avail)
+        expected = p.memory_info()._fields
+        if HAS_PROC_MEMORY_FOOTPRINT:
+            expected += p.memory_footprint()._fields
+        assert mem._fields == expected
+
+    @skipif(not HAS_PROC_MEMORY_MAPS, reason="not supported")
+    def test_memory_maps(self):
+        p = psutil.Process()
+        maps = p.memory_maps()
+        assert len(maps) == len(set(maps))
+        ext_maps = p.memory_maps(grouped=False)
+
+        for nt in maps:
+            if nt.path.startswith('['):
+                continue
+            if BSD and nt.path == "pvclock":
+                continue
+            assert os.path.isabs(nt.path), nt.path
+
+            if POSIX:
+                try:
+                    assert os.path.exists(nt.path) or os.path.islink(
+                        nt.path
+                    ), nt.path
+                except AssertionError:
+                    if not LINUX:
+                        raise
+                    # https://github.com/giampaolo/psutil/issues/759
+                    with open_text('/proc/self/smaps') as f:
+                        data = f.read()
+                    if f"{nt.path} (deleted)" not in data:
+                        raise
+            elif '64' not in os.path.basename(nt.path):
+                # XXX - On Windows we have this strange behavior with
+                # 64 bit dlls: they are visible via explorer but cannot
+                # be accessed via os.stat() (wtf?).
+                try:
+                    st = os.stat(nt.path)
+                except FileNotFoundError:
+                    pass
+                else:
+                    assert stat.S_ISREG(st.st_mode), nt.path
+
+        for nt in ext_maps:
+            for fname in nt._fields:
+                value = getattr(nt, fname)
+                if fname == 'path':
+                    continue
+                if fname in {'addr', 'perms'}:
+                    assert value, value
+                else:
+                    assert isinstance(value, int)
+                    assert value >= 0, value
+
+    @skipif(not HAS_PROC_MEMORY_MAPS, reason="not supported")
+    def test_memory_maps_lists_lib(self):
+        # Make sure a newly loaded shared lib is listed.
+        p = psutil.Process()
+        with copyload_shared_lib() as path:
+
+            def normpath(p):
+                return os.path.realpath(os.path.normcase(p))
+
+            libpaths = [normpath(x.path) for x in p.memory_maps()]
+            assert normpath(path) in libpaths
+
+    def test_memory_percent(self):
+        p = psutil.Process()
+        assert p.memory_percent() >= 0
+        with pytest.raises(ValueError):
+            p.memory_percent(memtype="?!?")
+        if HAS_PROC_MEMORY_FOOTPRINT:
+            assert p.memory_percent(memtype='uss') >= 0
+
+    def test_page_faults(self):
+        p = psutil.Process()
+        pfaults = p.page_faults()
+        assert pfaults.minor > 0
+        assert pfaults.major >= 0
+
+    def test_is_running(self):
+        p = self.spawn_psproc()
+        assert p.is_running()
+        assert p.is_running()
+        p.kill()
+        p.wait()
+        assert not p.is_running()
+        assert not p.is_running()
+
+    def test_exe(self):
+        p = self.spawn_psproc()
+        exe = p.exe()
+        try:
+            assert exe == PYTHON_EXE
+        except AssertionError:
+            if WINDOWS and len(exe) == len(PYTHON_EXE):
+                # on Windows we don't care about case sensitivity
+                normcase = os.path.normcase
+                assert normcase(exe) == normcase(PYTHON_EXE)
+            else:
+                # certain platforms such as BSD are more accurate returning:
+                # "/usr/local/bin/python3.7"
+                # ...instead of:
+                # "/usr/local/bin/python"
+                # We do not want to consider this difference in accuracy
+                # an error.
+                ver = f"{sys.version_info[0]}.{sys.version_info[1]}"
+                try:
+                    assert exe.replace(ver, '') == PYTHON_EXE.replace(ver, '')
+                except AssertionError:
+                    # Typically MACOS. Really not sure what to do here.
+                    pass
+
+        out = sh([exe, "-c", "import os; print('hey')"])
+        assert out == 'hey'
+
+    def test_cmdline(self):
+        testfn = self.get_testfn()
+        pyline = (
+            f"import time; open(r'{testfn}', 'w').close(); "
+            "[time.sleep(0.1) for x in range(100)]"
+        )
+        cmdline = [PYTHON_EXE, "-c", pyline]
+        p = self.spawn_psproc(cmdline)
+        wait_for_file(testfn, delete=True, empty=True)
+
+        if NETBSD and p.cmdline() == []:
+            # https://github.com/giampaolo/psutil/issues/2250
+            return pytest.skip("OPENBSD: returned EBUSY")
+
+        # XXX - most of the times the underlying sysctl() call on Net
+        # and Open BSD returns a truncated string.
+        # Also /proc/pid/cmdline behaves the same so it looks
+        # like this is a kernel bug.
+        # XXX - AIX truncates long arguments in /proc/pid/cmdline
+        if NETBSD or OPENBSD or AIX:
+            assert p.cmdline()[0] == PYTHON_EXE
+        else:
+            if MACOS and CI_TESTING:
+                pyexe = p.cmdline()[0]
+                if pyexe != PYTHON_EXE:
+                    assert ' '.join(p.cmdline()[1:]) == ' '.join(cmdline[1:])
+                    return None
+            assert ' '.join(p.cmdline()) == ' '.join(cmdline)
+
+    def test_name(self):
+        p = self.spawn_psproc()
+        name = p.name().lower()
+        if name.endswith("t"):  # in the free-threaded build
+            name = name[:-1]
+        pyexe = os.path.basename(os.path.realpath(sys.executable)).lower()
+        assert pyexe.startswith(name), (pyexe, name)
+
+    @retry_on_failure
+    def test_long_name(self):
+        pyexe = create_py_exe(self.get_testfn(suffix=string.digits * 2))
+        cmdline = [
+            pyexe,
+            "-c",
+            "import time; [time.sleep(0.1) for x in range(100)]",
+        ]
+        p = self.spawn_psproc(cmdline)
+        if OPENBSD:
+            # XXX: for some reason the test process may turn into a
+            # zombie (don't know why). Because the name() is long, all
+            # UNIX kernels truncate it to 15 chars, so internally psutil
+            # tries to guess the full name() from the cmdline(). But the
+            # cmdline() of a zombie on OpenBSD fails (internally), so we
+            # just compare the first 15 chars. Full explanation:
+            # https://github.com/giampaolo/psutil/issues/2239
+            try:
+                assert p.name() == os.path.basename(pyexe)
+            except AssertionError:
+                if p.status() == psutil.STATUS_ZOMBIE:
+                    assert os.path.basename(pyexe).startswith(p.name())
+                else:
+                    raise
+        else:
+            assert p.name() == os.path.basename(pyexe)
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_uids(self):
+        p = psutil.Process()
+        real, effective, _saved = p.uids()
+        # os.getuid() refers to "real" uid
+        assert real == os.getuid()
+        # os.geteuid() refers to "effective" uid
+        assert effective == os.geteuid()
+        # No such thing as os.getsuid() ("saved" uid), but we have
+        # os.getresuid() which returns all of them.
+        if hasattr(os, "getresuid"):
+            assert os.getresuid() == p.uids()
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_gids(self):
+        p = psutil.Process()
+        real, effective, _saved = p.gids()
+        # os.getuid() refers to "real" uid
+        assert real == os.getgid()
+        # os.geteuid() refers to "effective" uid
+        assert effective == os.getegid()
+        # No such thing as os.getsgid() ("saved" gid), but we have
+        # os.getresgid() which returns all of them.
+        if hasattr(os, "getresuid"):
+            assert os.getresgid() == p.gids()
+
+    def test_nice(self):
+        def cleanup(init):
+            try:
+                p.nice(init)
+            except psutil.AccessDenied:
+                pass
+
+        p = psutil.Process()
+        with pytest.raises(TypeError):
+            p.nice("str")
+        init = p.nice()
+        self.addCleanup(cleanup, init)
+
+        if WINDOWS:
+            highest_prio = None
+            for prio in [
+                psutil.IDLE_PRIORITY_CLASS,
+                psutil.BELOW_NORMAL_PRIORITY_CLASS,
+                psutil.NORMAL_PRIORITY_CLASS,
+                psutil.ABOVE_NORMAL_PRIORITY_CLASS,
+                psutil.HIGH_PRIORITY_CLASS,
+                psutil.REALTIME_PRIORITY_CLASS,
+            ]:
+                with self.subTest(prio=prio):
+                    try:
+                        p.nice(prio)
+                    except psutil.AccessDenied:
+                        pass
+                    else:
+                        new_prio = p.nice()
+                        # The OS may limit our maximum priority,
+                        # even if the function succeeds. For higher
+                        # priorities, we match either the expected
+                        # value or the highest so far.
+                        if prio in {
+                            psutil.ABOVE_NORMAL_PRIORITY_CLASS,
+                            psutil.HIGH_PRIORITY_CLASS,
+                            psutil.REALTIME_PRIORITY_CLASS,
+                        }:
+                            if new_prio == prio or highest_prio is None:
+                                highest_prio = prio
+                                assert new_prio == highest_prio
+                        else:
+                            assert new_prio == prio
+        else:
+            try:
+                if hasattr(os, "getpriority"):
+                    assert (
+                        os.getpriority(os.PRIO_PROCESS, os.getpid())
+                        == p.nice()
+                    )
+                p.nice(1)
+                assert p.nice() == 1
+                if hasattr(os, "getpriority"):
+                    assert (
+                        os.getpriority(os.PRIO_PROCESS, os.getpid())
+                        == p.nice()
+                    )
+                # XXX - going back to previous nice value raises
+                # AccessDenied on MACOS
+                if not MACOS:
+                    p.nice(0)
+                    assert p.nice() == 0
+            except psutil.AccessDenied:
+                pass
+
+    def test_status(self):
+        p = psutil.Process()
+        assert p.status() == psutil.STATUS_RUNNING
+
+    def test_username(self):
+        p = self.spawn_psproc()
+        username = p.username()
+        if WINDOWS:
+            domain, username = username.split('\\')
+            getpass_user = getpass.getuser()
+            if getpass_user.endswith('$'):
+                # When running as a service account (most likely to be
+                # NetworkService), these user name calculations don't produce
+                # the same result, causing the test to fail.
+                return pytest.skip('running as service account')
+            assert username == getpass_user
+            # For local accounts the domain is the computer name,
+            # which may differ from USERDOMAIN (e.g. "WORKGROUP").
+            expected = {
+                os.environ.get('USERDOMAIN'),
+                os.environ.get('COMPUTERNAME'),
+            }
+            expected = {x.upper() for x in expected if x}
+            if expected:
+                assert domain.upper() in expected
+        else:
+            assert username == getpass.getuser()
+
+    def test_cwd(self):
+        p = self.spawn_psproc()
+        assert p.cwd() == os.getcwd()
+
+    def test_cwd_2(self):
+        cmd = [
+            PYTHON_EXE,
+            "-c",
+            (
+                "import os, time; os.chdir('..'); [time.sleep(0.1) for x in"
+                " range(100)]"
+            ),
+        ]
+        p = self.spawn_psproc(cmd)
+        call_until(lambda: p.cwd() == os.path.dirname(os.getcwd()))
+
+    @skipif(not HAS_PROC_CPU_AFFINITY, reason="not supported")
+    def test_cpu_affinity(self):
+        p = psutil.Process()
+        initial = p.cpu_affinity()
+        assert initial, initial
+        self.addCleanup(p.cpu_affinity, initial)
+
+        if hasattr(os, "sched_getaffinity"):
+            assert initial == list(os.sched_getaffinity(p.pid))
+        assert len(initial) == len(set(initial))
+
+        all_cpus = list(range(len(psutil.cpu_percent(percpu=True))))
+        for n in all_cpus:
+            p.cpu_affinity([n])
+            assert p.cpu_affinity() == [n]
+            if hasattr(os, "sched_getaffinity"):
+                assert p.cpu_affinity() == list(os.sched_getaffinity(p.pid))
+            # also test num_cpu()
+            if hasattr(p, "num_cpu"):
+                assert p.cpu_affinity()[0] == p.num_cpu()
+
+        # [] is an alias for "all eligible CPUs"; on Linux this may
+        # not be equal to all available CPUs, see:
+        # https://github.com/giampaolo/psutil/issues/956
+        p.cpu_affinity([])
+        if LINUX:
+            assert p.cpu_affinity() == p._proc._get_eligible_cpus()
+        else:
+            assert p.cpu_affinity() == all_cpus
+        if hasattr(os, "sched_getaffinity"):
+            assert p.cpu_affinity() == list(os.sched_getaffinity(p.pid))
+
+        with pytest.raises(TypeError):
+            p.cpu_affinity(1)
+        p.cpu_affinity(initial)
+        # it should work with all iterables, not only lists
+        p.cpu_affinity(set(all_cpus))
+        p.cpu_affinity(tuple(all_cpus))
+
+    @skipif(not HAS_PROC_CPU_AFFINITY, reason="not supported")
+    def test_cpu_affinity_errs(self):
+        p = self.spawn_psproc()
+        invalid_cpu = [len(psutil.cpu_times(percpu=True)) + 10]
+        with pytest.raises(ValueError):
+            p.cpu_affinity(invalid_cpu)
+        with pytest.raises(ValueError):
+            p.cpu_affinity(range(10000, 11000))
+        with pytest.raises((TypeError, ValueError)):
+            p.cpu_affinity([0, "1"])
+        with pytest.raises(ValueError):
+            p.cpu_affinity([0, -1])
+
+    @skipif(not HAS_PROC_CPU_AFFINITY, reason="not supported")
+    def test_cpu_affinity_all_combinations(self):
+        p = psutil.Process()
+        initial = p.cpu_affinity()
+        assert initial, initial
+        self.addCleanup(p.cpu_affinity, initial)
+
+        # All possible CPU set combinations.
+        if len(initial) > 12:
+            initial = initial[:12]  # ...otherwise it will take forever
+        combos = []
+        for i in range(len(initial) + 1):
+            combos.extend(
+                list(subset)
+                for subset in itertools.combinations(initial, i)
+                if subset
+            )
+
+        for combo in combos:
+            p.cpu_affinity(combo)
+            assert sorted(p.cpu_affinity()) == sorted(combo)
+
+    def test_open_files(self):
+        p = psutil.Process()
+        testfn = self.get_testfn()
+        files = p.open_files()
+        assert testfn not in files
+        with open(testfn, 'wb') as f:
+            f.write(b'x' * 1024)
+            f.flush()
+            # give the kernel some time to see the new file
+            call_until(lambda: len(p.open_files()) != len(files))
+            files = p.open_files()
+            if HAS_PROC_OPEN_FILES_PATH:
+                filenames = [os.path.normcase(x.path) for x in files]
+                if FREEBSD and os.path.normcase(testfn) not in filenames:
+                    # FreeBSD may return an empty path, see #595
+                    assert f.fileno() in [x.fd for x in files]
+                    return pytest.skip("kernel didn't provide the path")
+                assert os.path.normcase(testfn) in filenames
+            if LINUX:
+                for file in files:
+                    if file.path == testfn:
+                        assert file.position == 1024
+        if HAS_PROC_OPEN_FILES_PATH:
+            for file in files:
+                if FREEBSD and not file.path:
+                    continue  # can be empty, see #595
+                assert os.path.isfile(file.path), file
+
+        # Another process. It lives long enough for the polling loop
+        # below to see the file appear.
+        cmdline = (
+            f"import time; f = open(r'{testfn}', 'r'); [time.sleep(0.1) for x"
+            " in range(600)];"
+        )
+        p = self.spawn_psproc([PYTHON_EXE, "-c", cmdline])
+
+        if HAS_PROC_OPEN_FILES_PATH:
+            for x in range(100):
+                filenames = [os.path.normcase(x.path) for x in p.open_files()]
+                if testfn in filenames:
+                    break
+                time.sleep(0.01)
+            else:
+                if FREEBSD and "" in filenames:
+                    # FreeBSD may return an empty path, see #595
+                    return pytest.skip("kernel didn't provide the path")
+                assert os.path.normcase(testfn) in filenames
+            for file in filenames:
+                if FREEBSD and not file:
+                    continue  # can be empty, see #595
+                assert os.path.isfile(file), file
+
+    def test_open_files_2(self):
+        # test fd and path fields
+        p = psutil.Process()
+        normcase = os.path.normcase
+        testfn = self.get_testfn()
+        with open(testfn, 'w') as fileobj:
+            for file in p.open_files():
+                if (
+                    normcase(file.path) == normcase(fileobj.name)
+                    or file.fd == fileobj.fileno()
+                ):
+                    break
+            else:
+                return pytest.fail(f"no file found; files={p.open_files()!r}")
+            if HAS_PROC_OPEN_FILES_PATH:
+                if FREEBSD and not file.path:
+                    # can be empty, see #595
+                    pass
+                else:
+                    assert normcase(file.path) == normcase(fileobj.name)
+            if WINDOWS:
+                assert file.fd == -1
+            else:
+                assert file.fd == fileobj.fileno()
+            # test positions
+            ntuple = p.open_files()[0]
+            assert ntuple[0] == ntuple.path
+            assert ntuple[1] == ntuple.fd
+            # test file is gone
+            assert fileobj.name not in p.open_files()
+
+    @isolated
+    @skipif(not POSIX, reason="POSIX only")
+    @retry_on_failure  # can wobble on CI
+    def test_num_fds(self):
+        p = psutil.Process()
+        testfn = self.get_testfn()
+        start = p.num_fds()
+        with open(testfn, 'w'):
+            assert p.num_fds() == start + 1
+            with socket.socket():
+                assert p.num_fds() == start + 2
+        assert p.num_fds() == start
+
+    @skip_on_not_implemented(only_if=LINUX)
+    def test_num_ctx_switches(self):
+        p = psutil.Process()
+        before = sum(p.num_ctx_switches())
+        for _ in range(2):
+            time.sleep(0.05)  # this shall ensure a context switch happens
+            after = sum(p.num_ctx_switches())
+            if after > before:
+                return None
+        return pytest.fail(
+            "num ctx switches still the same after 2 iterations"
+        )
+
+    def test_ppid(self):
+        p = psutil.Process()
+        if hasattr(os, 'getppid'):
+            assert p.ppid() == os.getppid()
+        p = self.spawn_psproc()
+        assert p.ppid() == os.getpid()
+
+    def test_parent(self):
+        p = self.spawn_psproc()
+        assert p.parent().pid == os.getpid()
+
+        lowest_pid = psutil.pids()[0]
+        assert psutil.Process(lowest_pid).parent() is None
+
+    def test_parent_mocked_ctime(self):
+        # Make sure we get a fresh copy of the ctime before processing
+        # parent().We make the assumption that the parent pid MUST have
+        # a creation time < than the child. If system clock is updated
+        # this assumption was broken.
+        # https://github.com/giampaolo/psutil/issues/2542
+        p = self.spawn_psproc()
+        p.create_time()  # trigger cache
+        assert p._create_time
+        p._create_time = 1
+        assert p.parent().pid == os.getpid()
+
+    def test_parent_multi(self):
+        parent = psutil.Process()
+        child, grandchild = self.spawn_children_pair()
+        assert grandchild.parent() == child
+        assert child.parent() == parent
+
+    @retry_on_failure
+    def test_parents(self):
+        parent = psutil.Process()
+        assert parent.parents()
+        child, grandchild = self.spawn_children_pair()
+        assert child.parents()[0] == parent
+        assert grandchild.parents()[0] == child
+        assert grandchild.parents()[1] == parent
+
+    def test_children(self):
+        parent = psutil.Process()
+        assert not filter_alien_children(parent.children())
+        assert not filter_alien_children(parent.children(recursive=True))
+        # On Windows we set the flag to 0 in order to cancel out the
+        # CREATE_NO_WINDOW flag (enabled by default) which creates
+        # an extra "conhost.exe" child.
+        child = self.spawn_psproc(creationflags=0)
+        children1 = filter_alien_children(parent.children())
+        children2 = filter_alien_children(parent.children(recursive=True))
+        for children in (children1, children2):
+            assert len(children) == 1
+            assert children[0].pid == child.pid
+            assert children[0].ppid() == parent.pid
+
+    def test_children_mocked_ctime(self):
+        # Make sure we get a fresh copy of the ctime before processing
+        # children(). We make the assumption that process children MUST
+        # have a creation time > than the parent. If system clock is
+        # updated this assumption was broken.
+        # https://github.com/giampaolo/psutil/issues/2542
+        parent = psutil.Process()
+        parent.create_time()  # trigger cache
+        assert parent._create_time
+        parent._create_time += 100000
+
+        assert not filter_alien_children(parent.children())
+        assert not filter_alien_children(parent.children(recursive=True))
+        # On Windows we set the flag to 0 in order to cancel out the
+        # CREATE_NO_WINDOW flag (enabled by default) which creates
+        # an extra "conhost.exe" child.
+        child = self.spawn_psproc(creationflags=0)
+        children1 = filter_alien_children(parent.children())
+        children2 = filter_alien_children(parent.children(recursive=True))
+        for children in (children1, children2):
+            assert len(children) == 1
+            assert children[0].pid == child.pid
+            assert children[0].ppid() == parent.pid
+
+    def test_children_recursive(self):
+        # Test children() against two sub processes, p1 and p2, where
+        # p1 (our child) spawned p2 (our grandchild).
+        parent = psutil.Process()
+        child, grandchild = self.spawn_children_pair()
+        assert parent.children() == [child]
+        assert parent.children(recursive=True) == [child, grandchild]
+        # If the intermediate process is gone there's no way for
+        # children() to recursively find it.
+        child.terminate()
+        child.wait()
+        assert not parent.children(recursive=True)
+
+    def test_children_duplicates(self):
+        # find the process which has the highest number of children
+        table = collections.defaultdict(int)
+        for p in psutil.process_iter():
+            try:
+                table[p.ppid()] += 1
+            except psutil.Error:
+                pass
+        # this is the one, now let's make sure there are no duplicates
+        pid = max(table.items(), key=lambda x: x[1])[0]
+        if LINUX and pid == 0:
+            return pytest.skip("PID 0")
+        p = psutil.Process(pid)
+        try:
+            c = p.children(recursive=True)
+        except psutil.AccessDenied:  # windows
+            pass
+        else:
+            assert len(c) == len(set(c))
+
+    def test_parents_and_children(self):
+        parent = psutil.Process()
+        child, grandchild = self.spawn_children_pair()
+        # forward
+        children = filter_alien_children(parent.children(recursive=True))
+        assert len(children) == 2
+        assert children[0] == child
+        assert children[1] == grandchild
+        # backward
+        parents = grandchild.parents()
+        assert parents[0] == child
+        assert parents[1] == parent
+
+    def test_suspend_resume(self):
+        p = self.spawn_psproc()
+        p.suspend()
+        for _ in range(100):
+            if p.status() == psutil.STATUS_STOPPED:
+                break
+            time.sleep(0.01)
+        p.resume()
+        assert p.status() != psutil.STATUS_STOPPED
+
+    def test_invalid_pid(self):
+        with pytest.raises(TypeError):
+            psutil.Process("1")
+        with pytest.raises(ValueError):
+            psutil.Process(-1)
+
+    def test_as_dict(self):
+        p = psutil.Process()
+        d = p.as_dict(attrs=['exe', 'name'])
+        assert sorted(d.keys()) == ['exe', 'name']
+
+        p = psutil.Process(min(psutil.pids()))
+        d = p.as_dict(attrs=['net_connections'], ad_value='foo')
+        if not isinstance(d['net_connections'], list):
+            assert d['net_connections'] == 'foo'
+
+        # Test ad_value is set on AccessDenied.
+        with mock.patch(
+            'psutil.Process.nice', create=True, side_effect=psutil.AccessDenied
+        ):
+            assert p.as_dict(attrs=["nice"], ad_value=1) == {"nice": 1}
+
+        # Test that NoSuchProcess bubbles up.
+        with mock.patch(
+            'psutil.Process.nice',
+            create=True,
+            side_effect=psutil.NoSuchProcess(p.pid, "name"),
+        ):
+            with pytest.raises(psutil.NoSuchProcess):
+                p.as_dict(attrs=["nice"])
+
+        # Test that ZombieProcess is swallowed.
+        with mock.patch(
+            'psutil.Process.nice',
+            create=True,
+            side_effect=psutil.ZombieProcess(p.pid, "name"),
+        ):
+            assert p.as_dict(attrs=["nice"], ad_value="foo") == {"nice": "foo"}
+
+        # By default APIs raising NotImplementedError are
+        # supposed to be skipped.
+        with mock.patch(
+            'psutil.Process.nice', create=True, side_effect=NotImplementedError
+        ):
+            d = p.as_dict()
+            assert 'nice' not in list(d.keys())
+            # ...unless the user explicitly asked for some attr.
+            with pytest.raises(NotImplementedError):
+                p.as_dict(attrs=["nice"])
+
+        # errors
+        with pytest.raises(TypeError):
+            p.as_dict('name')
+        with pytest.raises(ValueError):
+            p.as_dict(['foo'])
+        with pytest.raises(ValueError):
+            p.as_dict(['foo', 'bar'])
+
+    def test_attrs(self):
+        # The `Process.attrs` attribute to use with `as_dict()`.
+        p = psutil.Process()
+        assert p.as_dict().keys() == p.attrs
+
+        for g in process_namespace.getters:
+            name = g[0]
+            if name != 'rlimit':
+                assert name in p.attrs
+
+        for g in process_namespace.ignored + process_namespace.killers:
+            name = g[0]
+            if name != 'pid':
+                assert name not in p.attrs
+
+        # test excluded attrs
+        assert "net_connections" in list(p.as_dict(p.attrs))
+        assert "net_connections" not in list(
+            p.as_dict(p.attrs - {"net_connections"})
+        )
+
+    def test_oneshot(self):
+        p = psutil.Process()
+        with mock.patch("psutil._psplatform.Process.cpu_times") as m:
+            with p.oneshot():
+                p.cpu_times()
+                p.cpu_times()
+            assert m.call_count == 1
+
+        with mock.patch("psutil._psplatform.Process.cpu_times") as m:
+            p.cpu_times()
+            p.cpu_times()
+        assert m.call_count == 2
+
+    def test_oneshot_twice(self):
+        # Test the case where the ctx manager is __enter__ed twice.
+        # The second __enter__ is supposed to result in a NOOP.
+        p = psutil.Process()
+        with mock.patch("psutil._psplatform.Process.cpu_times") as m1:
+            with mock.patch("psutil._psplatform.Process.oneshot_enter") as m2:
+                with p.oneshot():
+                    p.cpu_times()
+                    p.cpu_times()
+                    with p.oneshot():
+                        p.cpu_times()
+                        p.cpu_times()
+                assert m1.call_count == 1
+                assert m2.call_count == 1
+
+        with mock.patch("psutil._psplatform.Process.cpu_times") as m:
+            p.cpu_times()
+            p.cpu_times()
+        assert m.call_count == 2
+
+    def test_oneshot_cache(self):
+        # Make sure oneshot() cache is nonglobal. Instead it's
+        # supposed to be bound to the Process instance, see:
+        # https://github.com/giampaolo/psutil/issues/1373
+        p1, p2 = self.spawn_children_pair()
+        p1_ppid = p1.ppid()
+        p2_ppid = p2.ppid()
+        assert p1_ppid != p2_ppid
+        with p1.oneshot():
+            assert p1.ppid() == p1_ppid
+            assert p2.ppid() == p2_ppid
+        with p2.oneshot():
+            assert p1.ppid() == p1_ppid
+            assert p2.ppid() == p2_ppid
+
+    def test_halfway_terminated_process(self):
+        # Test that NoSuchProcess exception gets raised in case the
+        # process dies after we create the Process object.
+        # Example:
+        # >>> proc = Process(1234)
+        # >>> time.sleep(2)  # time-consuming task, process dies in meantime
+        # >>> proc.name()
+        # Refers to Issue #15
+        def assert_raises_nsp(fun, fun_name):
+            try:
+                ret = fun()
+            except psutil.ZombieProcess:  # differentiate from NSP
+                raise
+            except psutil.NoSuchProcess:
+                pass
+            except psutil.AccessDenied:
+                if OPENBSD and fun_name in {'threads', 'num_threads'}:
+                    return None
+                raise
+            else:
+                # NtQuerySystemInformation succeeds even if process is gone.
+                if WINDOWS and fun_name in {'exe', 'name'}:
+                    return None
+                return pytest.fail(
+                    f"{fun!r} didn't raise NSP and returned {ret!r} instead"
+                )
+
+        p = self.spawn_psproc()
+        p.terminate()
+        p.wait()
+        if WINDOWS:  # XXX
+            call_until(lambda: p.pid not in psutil.pids())
+        self.assert_proc_gone(p)
+
+        ns = process_namespace(p)
+        for fun, name in ns.iter(ns.all):
+            assert_raises_nsp(fun, name)
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_zombie_process(self):
+        parent, zombie = self.spawn_zombie()
+        self.assert_proc_zombie(zombie)
+        if hasattr(_psutil, "proc_is_zombie"):
+            assert not _psutil.proc_is_zombie(os.getpid())
+            assert _psutil.proc_is_zombie(zombie.pid)
+        parent.terminate()
+        parent.wait()
+        zombie.wait()
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_zombie_process_is_running_w_exc(self):
+        # Emulate a case where internally is_running() raises
+        # ZombieProcess.
+        p = psutil.Process()
+        with mock.patch(
+            "psutil.Process", side_effect=psutil.ZombieProcess(0)
+        ) as m:
+            assert p.is_running()
+            assert m.called
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_zombie_process_status_w_exc(self):
+        # Emulate a case where internally status() raises
+        # ZombieProcess.
+        p = psutil.Process()
+        with mock.patch(
+            "psutil._psplatform.Process.status",
+            side_effect=psutil.ZombieProcess(0),
+        ) as m:
+            assert p.status() == psutil.STATUS_ZOMBIE
+            assert m.called
+
+    def test_pid_0(self):
+        # Process(0) is supposed to work on all platforms except Linux
+        if 0 not in psutil.pids():
+            with pytest.raises(psutil.NoSuchProcess):
+                psutil.Process(0)
+            # These 2 are a contradiction, but "ps" says PID 1's parent
+            # is PID 0.
+            assert not psutil.pid_exists(0)
+            assert psutil.Process(1).ppid() == 0
+            return
+
+        p = psutil.Process(0)
+        exc = psutil.AccessDenied if WINDOWS else ValueError
+        with pytest.raises(ValueError):
+            p.wait()
+        with pytest.raises(exc):
+            p.terminate()
+        with pytest.raises(exc):
+            p.suspend()
+        with pytest.raises(exc):
+            p.resume()
+        with pytest.raises(exc):
+            p.kill()
+        with pytest.raises(exc):
+            p.send_signal(signal.SIGTERM)
+
+        # test all methods
+        ns = process_namespace(p)
+        for fun, name in ns.iter(ns.getters + ns.setters):
+            try:
+                ret = fun()
+            except psutil.AccessDenied:
+                pass
+            else:
+                if name in {"uids", "gids"}:
+                    assert ret.real == 0
+                elif name == "username":
+                    user = 'NT AUTHORITY\\SYSTEM' if WINDOWS else 'root'
+                    assert p.username() == user
+                elif name == "name":
+                    assert name, name
+
+        if not OPENBSD:
+            assert 0 in psutil.pids()
+            assert psutil.pid_exists(0)
+
+    @skipif(not HAS_PROC_ENVIRON, reason="not supported")
+    def test_environ(self):
+        def clean_dict(d):
+            exclude = {"PLAT", "HOME"}
+            if MACOS:
+                exclude.update([
+                    "__CF_USER_TEXT_ENCODING",
+                    "VERSIONER_PYTHON_PREFER_32_BIT",
+                    "VERSIONER_PYTHON_VERSION",
+                ])
+            for name in list(d.keys()):
+                if name in exclude or name.startswith("PYTEST_"):
+                    d.pop(name)
+            return {
+                k.replace("\r", "").replace("\n", ""): (
+                    v.replace("\r", "").replace("\n", "")
+                )
+                for k, v in d.items()
+            }
+
+        self.maxDiff = None
+        p = psutil.Process()
+        d1 = clean_dict(p.environ())
+        d2 = clean_dict(os.environ.copy())
+        if not OSX and GITHUB_ACTIONS:
+            assert d1 == d2
+
+
+# ===================================================================
+# --- PID reuse detection and process identity
+# ===================================================================
+
+
+class TestProcessPidReuse(PsutilTestCase):
+    """Tests for PID reuse detection and process identity
+    (__eq__, __ne__, __hash__).
+    """
+
+    def test_ident(self):
+        p = psutil.Process()
+        assert p._ident[0] == p.pid
+        if FREEBSD or OPENBSD or SUNOS or AIX:
+            # PID reuse detection is disabled on these platforms, see
+            # Process._get_ident().
+            assert p._ident[1] is None
+        else:
+            assert p._ident[1] is not None
+
+    def test_eq(self):
+        def proc(pid, ctime):
+            p = psutil.Process()
+            p._ident = (pid, ctime)
+            p._hash = None
+            return p
+
+        # same pid, same ctime
+        assert proc(100, 50.0) == proc(100, 50.0)
+        # same pid, different ctime: the PID has been reused
+        assert proc(100, 50.0) != proc(100, 60.0)
+        # different pid always means different process
+        assert proc(100, 50.0) != proc(101, 50.0)
+        assert proc(100, None) != proc(101, None)
+        assert proc(100, 0.0) != proc(101, 0.0)
+        # a null ctime on either side means identity is unknown,
+        # which is not proof of a different process
+        for null_value in (0.0, None):
+            assert proc(100, 50.0) == proc(100, null_value)
+            assert proc(100, null_value) == proc(100, 50.0)
+            assert proc(100, null_value) == proc(100, null_value)
+        # comparison with a non-Process object
+        assert proc(100, 50.0) != "foo"
+
+    def test_hash(self):
+        def proc(pid, ctime):
+            p = psutil.Process()
+            p._ident = (pid, ctime)
+            p._hash = None
+            return p
+
+        # a == b implies hash(a) == hash(b)
+        pairs = [
+            (proc(100, 50.0), proc(100, 50.0)),
+            (proc(100, 50.0), proc(100, None)),
+            (proc(100, 50.0), proc(100, 0.0)),
+            (proc(100, None), proc(100, 0.0)),
+        ]
+        for a, b in pairs:
+            assert a == b
+            assert hash(a) == hash(b)
+            assert len({a, b}) == 1
+            assert {a: "x"}[b] == "x"
+        # same pid but different ctime (PID reuse): unequal, and a set
+        # must keep both
+        a, b = proc(100, 50.0), proc(100, 60.0)
+        assert a != b
+        assert len({a, b}) == 2
+        # sanity check against the real world
+        p1 = psutil.Process()
+        p2 = psutil.Process(p1.pid)
+        assert p1 == p2
+        assert hash(p1) == hash(p2)
+        assert len({p1, p2}) == 1
+
+    @skipif(
+        FREEBSD or OPENBSD or SUNOS or AIX,
+        reason="PID reuse detection disabled on this platform",
+    )
+    def test_reused_pid(self):
+        # Emulate a case where PID has been reused by another process.
+        subp = self.spawn_subproc()
+        p = psutil.Process(subp.pid)
+        p._ident = (p.pid, p.create_time() + 100)
+
+        list(psutil.process_iter())
+        assert p.pid in psutil._pmap
+        assert not p.is_running()
+
+        # make sure is_running() removed PID from process_iter()
+        # internal cache
+        with mock.patch.object(psutil._common, "PSUTIL_DEBUG", True):
+            with contextlib.redirect_stderr(io.StringIO()) as f:
+                list(psutil.process_iter())
+        assert (
+            f"refreshing Process instance for reused PID {p.pid}"
+            in f.getvalue()
+        )
+        assert p.pid not in psutil._pmap
+
+        assert p != psutil.Process(subp.pid)
+        msg = "process no longer exists and its PID has been reused"
+        ns = process_namespace(p)
+        for fun, name in ns.iter(ns.setters + ns.killers, clear_cache=False):
+            with self.subTest(name=name):
+                with pytest.raises(psutil.NoSuchProcess, match=msg):
+                    fun()
+
+        assert "terminated + PID reused" in str(p)
+        assert "terminated + PID reused" in repr(p)
+
+        with pytest.raises(psutil.NoSuchProcess, match=msg):
+            p.ppid()
+        with pytest.raises(psutil.NoSuchProcess, match=msg):
+            p.parent()
+        with pytest.raises(psutil.NoSuchProcess, match=msg):
+            p.parents()
+        with pytest.raises(psutil.NoSuchProcess, match=msg):
+            p.children()
+
+    def test_reused_pid_with_null_ctime(self):
+        # A null create time on either side must not count as PID
+        # reuse, see: https://github.com/giampaolo/psutil/issues/2895.
+        subp = self.spawn_subproc()
+        p = psutil.Process(subp.pid)
+
+        for null_value in (0.0, None):
+            p._ident = (p.pid, null_value)
+            assert p.is_running()
+            assert not p._pid_reused
+
+        for null_value in (0.0, None):
+            p = psutil.Process(subp.pid)
+            with mock.patch.object(
+                psutil.Process,
+                "_get_ident",
+                return_value=(subp.pid, null_value),
+            ):
+                assert p.is_running()
+            assert not p._pid_reused
+
+    def test_ad_on_process_creation(self):
+        # We are supposed to be able to instantiate Process also in case
+        # of zombie processes or access denied.
+        with mock.patch.object(
+            psutil.Process, '_get_ident', side_effect=psutil.AccessDenied
+        ) as meth:
+            psutil.Process()
+            assert meth.called
+
+        with mock.patch.object(
+            psutil.Process, '_get_ident', side_effect=psutil.ZombieProcess(1)
+        ) as meth:
+            psutil.Process()
+            assert meth.called
+
+        with mock.patch.object(
+            psutil.Process, '_get_ident', side_effect=ValueError
+        ) as meth:
+            with pytest.raises(ValueError):
+                psutil.Process()
+            assert meth.called
+
+        with mock.patch.object(
+            psutil.Process, '_get_ident', side_effect=psutil.NoSuchProcess(1)
+        ) as meth:
+            with pytest.raises(psutil.NoSuchProcess):
+                psutil.Process()
+            assert meth.called
+
+
+# ===================================================================
+# --- psutil.Process.wait tests
+# ===================================================================
+
+
+class TestProcessWait(PsutilTestCase):
+
+    def test_wait_exited(self):
+        # Test waitpid() + WIFEXITED -> WEXITSTATUS.
+        # normal return, same as exit(0)
+        cmd = [PYTHON_EXE, "-c", "pass"]
+        p = self.spawn_psproc(cmd)
+        code = p.wait()
+        assert code == 0
+        self.assert_proc_gone(p)
+        # exit(1), implicit in case of error
+        cmd = [PYTHON_EXE, "-c", "1 / 0"]
+        p = self.spawn_psproc(cmd, stderr=subprocess.PIPE)
+        code = p.wait()
+        assert code == 1
+        self.assert_proc_gone(p)
+        # via sys.exit()
+        cmd = [PYTHON_EXE, "-c", "import sys; sys.exit(5);"]
+        p = self.spawn_psproc(cmd)
+        code = p.wait()
+        assert code == 5
+        self.assert_proc_gone(p)
+        # via os._exit()
+        cmd = [PYTHON_EXE, "-c", "import os; os._exit(5);"]
+        p = self.spawn_psproc(cmd)
+        code = p.wait()
+        assert code == 5
+        self.assert_proc_gone(p)
+
+    @skipif(not POSIX, reason="not POSIX")
+    def test_wait_signaled(self):
+        p = psutil.Process(self.spawn_subproc().pid)
+        p.terminate()
+        code = p.wait()
+        assert code == -signal.SIGTERM
+        assert isinstance(code, enum.IntEnum)
+        # second call is cached
+        assert code == -signal.SIGTERM
+        # Call the underlying implementation. Done to exercise the
+        # poll/kqueue machinery on a gone PID. Also, waitpid() is
+        # supposed to fail with ESRCH.
+        assert p._proc.wait() is None
+
+    def test_wait_stopped(self):
+        p = self.spawn_psproc()
+        if POSIX:
+            # Test waitpid() + WIFSTOPPED and WIFCONTINUED.
+            # Note: if a process is stopped it ignores SIGTERM.
+            p.send_signal(signal.SIGSTOP)
+            with pytest.raises(psutil.TimeoutExpired):
+                p.wait(timeout=0.001)
+            p.send_signal(signal.SIGCONT)
+            with pytest.raises(psutil.TimeoutExpired):
+                p.wait(timeout=0.001)
+            p.send_signal(signal.SIGTERM)
+            assert p.wait() == -signal.SIGTERM
+            assert p.wait() == -signal.SIGTERM
+        else:
+            p.suspend()
+            with pytest.raises(psutil.TimeoutExpired):
+                p.wait(timeout=0.001)
+            p.resume()
+            with pytest.raises(psutil.TimeoutExpired):
+                p.wait(timeout=0.001)
+            p.terminate()
+            assert p.wait() == signal.SIGTERM
+            assert p.wait() == signal.SIGTERM
+
+    def test_wait_non_children(self):
+        # Test wait() against a process which is not our direct
+        # child.
+        child, grandchild = self.spawn_children_pair()
+        with pytest.raises(psutil.TimeoutExpired):
+            child.wait(0.01)
+        with pytest.raises(psutil.TimeoutExpired):
+            grandchild.wait(0.01)
+        # We also terminate the direct child otherwise the
+        # grandchild will hang until the parent is gone.
+        child.terminate()
+        grandchild.terminate()
+        child_ret = child.wait()
+        grandchild_ret = grandchild.wait()
+        if POSIX:
+            assert child_ret == -signal.SIGTERM
+            # For processes which are not our children we're supposed
+            # to get None.
+            assert grandchild_ret is None
+        else:
+            assert child_ret == signal.SIGTERM
+            assert child_ret == signal.SIGTERM
+
+    def test_wait_timeout(self):
+        p = self.spawn_psproc()
+        p.name()
+        with pytest.raises(psutil.TimeoutExpired):
+            p.wait(0.01)
+        with pytest.raises(psutil.TimeoutExpired):
+            p.wait(0)
+
+    def test_wait_timeout_nonblocking(self):
+        p = self.spawn_psproc()
+        with pytest.raises(psutil.TimeoutExpired):
+            p.wait(0)
+        p.kill()
+        stop_at = time.monotonic() + GLOBAL_TIMEOUT
+        while time.monotonic() < stop_at:
+            try:
+                code = p.wait(0)
+                break
+            except psutil.TimeoutExpired:
+                pass
+        else:
+            return pytest.fail('timeout')
+        if POSIX:
+            assert code == -signal.SIGKILL
+        else:
+            assert code == signal.SIGTERM
+        self.assert_proc_gone(p)
+
+    def test_wait_errors(self):
+        p = psutil.Process()
+        with pytest.raises(TypeError, match="must be an int or float"):
+            p.wait("foo")
+        with pytest.raises(ValueError, match="must be positive or zero"):
+            p.wait(-1)
+        p._pid = 0
+        with pytest.raises(ValueError, match="can't wait for PID 0"):
+            p.wait()
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_wait_zombie(self):
+        parent, zombie = self.spawn_zombie()
+        with pytest.raises(psutil.TimeoutExpired):
+            zombie.wait(0.001)
+        parent.terminate()
+        parent.wait()
+        zombie.wait()
+
+    # --- tests for wait_pid_posix()
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_os_waitpid_error(self):
+        # os.waitpid() is supposed to catch ECHILD only.
+        # Test that any other errno results in an exception.
+        with mock.patch(
+            "os.waitpid", side_effect=OSError(errno.EBADF, "")
+        ) as m:
+            with pytest.raises(OSError):
+                psutil._psposix.wait_pid_posix(os.getpid())
+            assert m.called
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_os_waitpid_bad_ret_status(self):
+        # Simulate os.waitpid() returning a bad status.
+        with mock.patch("os.waitpid", return_value=(1, -1)) as m:
+            with pytest.raises(ValueError):
+                psutil._psposix.wait_pid_posix(os.getpid())
+            assert m.called
+
+    # --- tests for pidfd_open() and kqueue()
+
+    def assert_wait_pid_errors(self, patch_target, wait_func, errors):
+        # Test that all errors are caught and wait_pid_posix()
+        # fallback is used.
+        sproc = self.spawn_subproc()
+        sproc.terminate()
+
+        errors = list(errors)
+        random.shuffle(errors)
+        for idx, err in enumerate(errors):
+            with mock.patch(
+                patch_target,
+                side_effect=OSError(err, os.strerror(err)),
+            ) as m:
+                # the second time waitpid() does not return the exit code
+                code = -signal.SIGTERM if idx == 0 else None
+                assert wait_func(sproc.pid) == code
+            assert m.called
+
+    @skipif(
+        not hasattr(os, "pidfd_open"),
+        reason="LINUX only" if not LINUX else "not supported",
+    )
+    def test_pidfd_open_errors(self):
+        from psutil._psposix import wait_pid_pidfd_open
+
+        self.assert_wait_pid_errors(
+            "os.pidfd_open",
+            wait_pid_pidfd_open,
+            [errno.ESRCH, errno.EMFILE, errno.ENFILE, errno.EBADF],
+        )
+
+    @skipif(not hasattr(select, "kqueue"), reason="MACOS and BSD only")
+    def test_kqueue_errors(self):
+        from psutil._psposix import wait_pid_kqueue
+
+        self.assert_wait_pid_errors(
+            "select.kqueue",
+            wait_pid_kqueue,
+            [errno.EMFILE, errno.ENFILE, errno.EBADF],
+        )
+
+    def assert_wait_pid_race(self, patch_target, real_func):
+        # Kill process after patch_target succeeds but before wait()
+        # completes, then verify Process.wait() still works.
+        sproc = self.spawn_subproc()
+        psproc = psutil.Process(sproc.pid)
+
+        def wrapper(*args, **kwargs):
+            ret = real_func(*args, **kwargs)
+            sproc.terminate()
+            sproc.wait()
+            return ret
+
+        with mock.patch(patch_target, side_effect=wrapper) as m:
+            psproc.wait()
+        assert m.called
+
+    @skipif(
+        not hasattr(os, "pidfd_open"),
+        reason="LINUX only" if not LINUX else "not supported",
+    )
+    def test_pidfd_open_race(self):
+        self.assert_wait_pid_race("os.pidfd_open", os.pidfd_open)
+
+    @skipif(not hasattr(select, "kqueue"), reason="MACOS and BSD only")
+    def test_kqueue_race(self):
+        self.assert_wait_pid_race("select.kqueue", select.kqueue)
+
+    @skipif(not hasattr(select, "kqueue"), reason="MACOS and BSD only")
+    def test_kqueue_control_errors(self):
+        # Test that kqueue.control() errors are caught and fallback is used.
+        from psutil._psposix import wait_pid_kqueue
+
+        sproc = self.spawn_subproc()
+        sproc.terminate()
+
+        errors = [errno.EACCES, errno.EPERM, errno.ESRCH]
+        random.shuffle(errors)
+        for idx, err in enumerate(errors):
+            kq_mock = mock.Mock()
+            kq_mock.control.side_effect = OSError(err, os.strerror(err))
+            kq_mock.close = mock.Mock()
+
+            with mock.patch("select.kqueue", return_value=kq_mock):
+                # the second time waitpid() does not return the exit code
+                code = -signal.SIGTERM if idx == 0 else None
+                assert wait_pid_kqueue(sproc.pid) == code
+            assert kq_mock.control.called
+
+        # illegitimate error
+        kq_mock = mock.Mock()
+        kq_mock.control.side_effect = OSError(
+            errno.EBADF, os.strerror(errno.EBADF)
+        )
+        kq_mock.close = mock.Mock()
+        with mock.patch("select.kqueue", return_value=kq_mock):
+            with pytest.raises(OSError):
+                wait_pid_kqueue(sproc.pid)
+
+
+# ===================================================================
+# --- psutil.Popen tests
+# ===================================================================
+
+
+class TestPopen(PsutilTestCase):
+    """Tests for psutil.Popen class."""
+
+    @classmethod
+    def tearDownClass(cls):
+        reap_children()
+
+    def test_misc(self):
+        # XXX this test causes a ResourceWarning because
+        # psutil.__subproc instance doesn't get properly freed.
+        # Not sure what to do though.
+        cmd = [
+            PYTHON_EXE,
+            "-c",
+            (
+                "print('ready', flush=True);"
+                "import time; [time.sleep(0.1) for x in range(100)];"
+            ),
+        ]
+        with psutil.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=PYTHON_EXE_ENV,
+        ) as proc:
+            proc.name()
+            proc.cpu_times()
+            proc.stdin  # noqa: B018
+            assert dir(proc)
+            with pytest.raises(AttributeError):
+                proc.foo  # noqa: B018
+
+            assert proc.stdout.readline().strip() == b"ready"
+            proc.terminate()
+
+            expected = -signal.SIGTERM if POSIX else signal.SIGTERM
+            # Wait longer than the child sleeps (10 secs). If SIGTERM
+            # gets lost (seen on NetBSD) we want the child to run to
+            # completion, so that wait() returns and we can print the
+            # evidence below, instead of just timing out.
+            status = ""
+            try:
+                ret = proc.wait(20)
+            except psutil.TimeoutExpired:
+                ret = "<timeout>"
+                with contextlib.suppress(psutil.Error):
+                    status = f" child status: {proc.status()};"
+            if ret != expected:
+                return pytest.fail(
+                    f"wait() returned {ret} instead of {expected};"
+                    f"{status}"
+                    f" child stderr: {proc.stderr.read()}"
+                )
+
+    def test_ctx_manager(self):
+        with psutil.Popen(
+            [PYTHON_EXE, "-V"],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            env=PYTHON_EXE_ENV,
+        ) as proc:
+            proc.communicate()
+        assert proc.stdout.closed
+        assert proc.stderr.closed
+        assert proc.stdin.closed
+        assert proc.returncode == 0
+
+    def test_kill_terminate(self):
+        # subprocess.Popen()'s terminate(), kill() and send_signal() do
+        # not raise exception after the process is gone. psutil.Popen
+        # diverges from that.
+        cmd = [
+            PYTHON_EXE,
+            "-c",
+            "import time; [time.sleep(0.1) for x in range(100)];",
+        ]
+        with psutil.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=PYTHON_EXE_ENV,
+        ) as proc:
+            proc.terminate()
+            proc.wait()
+            with pytest.raises(psutil.NoSuchProcess):
+                proc.terminate()
+            with pytest.raises(psutil.NoSuchProcess):
+                proc.kill()
+            with pytest.raises(psutil.NoSuchProcess):
+                proc.send_signal(signal.SIGTERM)
+            if WINDOWS:
+                with pytest.raises(psutil.NoSuchProcess):
+                    proc.send_signal(signal.CTRL_C_EVENT)
+                with pytest.raises(psutil.NoSuchProcess):
+                    proc.send_signal(signal.CTRL_BREAK_EVENT)
+
+    def test__getattribute__(self):
+        cmd = [
+            PYTHON_EXE,
+            "-c",
+            "import time; [time.sleep(0.1) for x in range(100)];",
+        ]
+        with psutil.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=PYTHON_EXE_ENV,
+        ) as proc:
+            proc.terminate()
+            proc.wait()
+            with pytest.raises(AttributeError):
+                proc.foo  # noqa: B018
diff --git a/tests/test_process_all.py b/tests/test_process_all.py
new file mode 100755
index 0000000000..f72d1afa1b
--- /dev/null
+++ b/tests/test_process_all.py
@@ -0,0 +1,614 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Iterate over all process PIDs and for each one of them invoke and
+test all psutil.Process() methods.
+"""
+
+import collections
+import enum
+import errno
+import os
+import stat
+import time
+import traceback
+
+import pytest
+
+import psutil
+from psutil import AIX
+from psutil import BSD
+from psutil import FREEBSD
+from psutil import LINUX
+from psutil import MACOS
+from psutil import NETBSD
+from psutil import OPENBSD
+from psutil import POSIX
+from psutil import WINDOWS
+
+from . import CI_TESTING
+from . import VALID_PROC_STATUSES
+from . import PsutilTestCase
+from . import check_connection_ntuple
+from . import check_fun_type_hints
+from . import check_ntuple_type_hints
+from . import is_namedtuple
+from . import is_win_secure_system_proc
+from . import process_namespace
+
+API_DURATIONS = collections.Counter()
+PF_KTHREAD = 0x00200000  # include/linux/sched.h
+
+
+@pytest.hookimpl(wrapper=True)
+def pytest_runtest_makereport(item, call):
+    # Attach the timings to test_all's report, so they survive the
+    # trip from the xdist worker to the master.
+    report = yield
+    if call.when == "call" and item.nodeid.endswith("::test_all"):
+        if API_DURATIONS:
+            report.user_properties.append(
+                ("api_durations", API_DURATIONS.most_common())
+            )
+    return report
+
+
+def pytest_terminal_summary(terminalreporter):
+    """Show top slowest APIs in pytest summary."""
+    top_slowest = terminalreporter.config.getoption("durations")
+    if top_slowest is None:
+        # show them only if --durations was passed
+        return
+    for reports in terminalreporter.stats.values():
+        for report in reports:
+            for key, value in getattr(report, "user_properties", []):
+                if key == "api_durations":
+                    terminalreporter.write_sep(
+                        "=",
+                        f"test_all: slowest {top_slowest} APIs (cumulative)",
+                    )
+                    for fun_name, secs in value[:top_slowest]:
+                        line = f"{secs:.2f}s call     {fun_name}()"
+                        terminalreporter.write_line(line)
+
+
+class ProcInfo:
+    def __init__(self, pid):
+        self.pid = pid
+        self.proc = None
+        self.name = None
+        self.ppid = None
+        self.tcase = PsutilTestCase()
+
+    def is_kernel_thread(self):
+        # The kernel renames these continuously, e.g. "kworker/1:0-events"
+        # -> "kworker/1:0+events" -> "kworker/1:0-kblockd", so their name
+        # says nothing about whether it's still the same process.
+        if not LINUX:
+            return False
+        try:
+            with open(f"{psutil.PROCFS_PATH}/{self.pid}/stat", "rb") as f:
+                data = f.read()
+        except OSError:
+            return False  # process is gone; caller handles that
+        fields = data[data.rfind(b")") + 2 :].split()
+        return bool(int(fields[6]) & PF_KTHREAD)
+
+    def check_exception(self, exc):
+        assert exc.pid == self.pid
+        if (
+            exc.name is not None
+            and exc.name != self.name
+            and not self.is_kernel_thread()
+        ):
+            # The process may have renamed itself in the meantime.
+            try:
+                curname = psutil.Process(self.pid).name()
+            except psutil.Error:
+                curname = None
+            # if the name did not change then something else is wrong
+            assert curname != self.name
+        if isinstance(exc, psutil.ZombieProcess):
+            try:
+                self.tcase.assert_proc_zombie(self.proc)
+            except (psutil.NoSuchProcess, AssertionError):
+                # Prevent race conditions: if zombie disappears while
+                # assert_proc_zombie analyzes it we fail only if its
+                # PID still exists.
+                if self.pid in psutil.pids():
+                    raise
+
+            if exc.ppid is not None:
+                assert exc.ppid >= 0
+                assert exc.ppid == self.ppid
+        elif isinstance(exc, psutil.NoSuchProcess):
+            self.tcase.assert_proc_gone(self.proc)
+        str(exc)
+        repr(exc)
+
+    def safe_repr(self):
+        # repr() calls name() and status(), which may fail themselves.
+        if self.proc is None:
+            return f"pid {self.pid}"
+        try:
+            return repr(self.proc)
+        except Exception as exc:  # noqa: BLE001
+            return f"psutil.Process(pid={self.pid}, repr_error={exc!r})"
+
+    def check_wait(self):
+        if self.pid != 0:
+            try:
+                self.proc.wait(0)
+            except psutil.Error as exc:
+                self.check_exception(exc)
+
+    def call_getters(self):
+        info = {'pid': self.pid}
+        durations = {}
+        ns = process_namespace(self.proc)
+        # We don't use oneshot() because in order not to fool
+        # check_exception() in case of NSP.
+        for fun, fun_name in ns.iter(ns.getters, clear_cache=False):
+            t = time.perf_counter()
+            try:
+                ret = fun()
+            except psutil.Error as exc:
+                self.check_exception(exc)
+                continue
+            else:
+                check_fun_type_hints(fun, ret)
+                if is_namedtuple(ret):
+                    check_ntuple_type_hints(ret)
+                info[fun_name] = ret
+            finally:
+                durations[fun_name] = time.perf_counter() - t
+        info["_durations"] = durations
+        info["_repr"] = self.safe_repr()
+        return info
+
+    def run(self):
+        try:
+            self.proc = psutil.Process(self.pid)
+        except psutil.NoSuchProcess:
+            self.tcase.assert_pid_gone(self.pid)
+            return {}
+
+        try:
+            d = self.proc.as_dict(['ppid', 'name'])
+        except psutil.NoSuchProcess:
+            self.tcase.assert_proc_gone(self.proc)
+            return {}
+
+        self.name, self.ppid = d['name'], d['ppid']
+        info = self.call_getters()
+        self.check_wait()
+        return info
+
+
+def proc_info(pid):
+    obj = ProcInfo(pid)
+    try:
+        return obj.run()
+    except Exception as exc:
+        # Attach the process repr (name + status) to any unexpected
+        # error, no matter which part of the collection raised it.
+        msg = f"proc: {obj.safe_repr()}"
+        if hasattr(exc, "add_note"):  # python 3.11+
+            exc.add_note(msg)
+            raise
+        raise RuntimeError(msg) from exc
+
+
+class TestFetchAllProcesses(PsutilTestCase):
+    """Test which iterates over all running processes and performs
+    some sanity checks against Process API's returned values.
+    Uses a process pool to get info about all processes.
+    """
+
+    def setUp(self):
+        psutil._set_debug(False)
+        if POSIX:
+            self.parent, self.zombie = self.spawn_zombie()
+
+    def tearDown(self):
+        if POSIX:
+            self.parent.terminate()
+            self.parent.wait()
+            self.zombie.wait()
+        psutil._set_debug(True)
+
+    def iter_proc_info(self):
+        ls = [proc_info(pid) for pid in psutil.pids()]
+        return ls
+
+    def test_all(self):
+        failures = []
+        durations = collections.Counter()
+        for info in self.iter_proc_info():
+            durations.update(info.pop("_durations", {}))
+            proc_repr = info.pop("_repr", None)
+            for name, value in info.items():
+                meth = getattr(self, name)
+                try:
+                    meth(value, info)
+                except Exception:  # noqa: BLE001
+                    s = '\n' + '=' * 70 + '\n'
+                    s += "FAIL: name=test_{}, pid={}, ret={}\n\n".format(
+                        name,
+                        info['pid'],
+                        repr(value),
+                    )
+                    s += f"proc={proc_repr}\n\n"
+                    s += '-' * 70
+                    s += f"\n{traceback.format_exc()}"
+                    s = "\n".join((" " * 4) + i for i in s.splitlines()) + "\n"
+                    failures.append(s)
+                else:
+                    if value not in (0, 0.0, [], None, '', {}):
+                        assert value, value
+
+        API_DURATIONS.update(durations)
+        if failures:
+            return pytest.fail(''.join(failures))
+
+    def cmdline(self, ret, info):
+        assert isinstance(ret, list)
+        for part in ret:
+            assert isinstance(part, str)
+
+    def exe(self, ret, info):
+        assert isinstance(ret, str)
+        assert ret.strip() == ret
+        if ret:
+            if WINDOWS and not ret.endswith('.exe'):
+                return  # May be "Registry", "MemCompression", ...
+            assert os.path.isabs(ret), ret
+            # Note: os.stat() may return False even if the file is there
+            # hence we skip the test, see:
+            # http://stackoverflow.com/questions/3112546/os-path-exists-lies
+            if POSIX and os.path.isfile(ret):
+                if hasattr(os, 'access') and hasattr(os, "X_OK"):
+                    # XXX: may fail on MACOS
+                    try:
+                        assert os.access(ret, os.X_OK)
+                    except AssertionError:
+                        if os.path.exists(ret) and not CI_TESTING:
+                            raise
+
+    def pid(self, ret, info):
+        assert isinstance(ret, int)
+        assert ret >= 0
+
+    def ppid(self, ret, info):
+        assert isinstance(ret, int)
+        assert ret >= 0
+        proc_info(ret)
+
+    def name(self, ret, info):
+        assert isinstance(ret, str)
+        if WINDOWS and not ret and is_win_secure_system_proc(info['pid']):
+            # https://github.com/giampaolo/psutil/issues/2338
+            return
+        # on AIX, "<exiting>" processes don't have names
+        if not AIX:
+            assert ret, repr(ret)
+
+    def create_time(self, ret, info):
+        assert isinstance(ret, float)
+        try:
+            assert ret >= 0
+        except AssertionError:
+            # XXX
+            if OPENBSD and info['status'] == psutil.STATUS_ZOMBIE:
+                pass
+            else:
+                raise
+        # this can't be taken for granted on all platforms
+        # assert ret >= psutil.boot_time())
+        # make sure returned value can be pretty printed
+        # with strftime
+        time.strftime("%Y %m %d %H:%M:%S", time.localtime(ret))
+
+    def uids(self, ret, info):
+        for uid in ret:
+            assert isinstance(uid, int)
+            assert uid >= 0
+
+    def gids(self, ret, info):
+        # note: testing all gids as above seems not to be reliable for
+        # gid == 30 (nodoby); not sure why.
+        for gid in ret:
+            assert isinstance(gid, int)
+            if not MACOS and not NETBSD:
+                assert gid >= 0
+
+    def username(self, ret, info):
+        assert isinstance(ret, str)
+        assert ret.strip() == ret
+        assert ret.strip()
+
+    def status(self, ret, info):
+        assert isinstance(ret, str)
+        assert ret, ret
+        assert ret != '?'  # XXX
+        assert ret in VALID_PROC_STATUSES
+
+    def io_counters(self, ret, info):
+        for field in ret:
+            assert isinstance(field, int)
+            if field != -1:
+                assert field >= 0
+
+    def ionice(self, ret, info):
+        if LINUX:
+            assert isinstance(ret.ioclass, int)
+            assert isinstance(ret.value, int)
+            assert ret.ioclass >= 0
+            assert ret.value >= 0
+        else:  # Windows, Cygwin
+            choices = [
+                psutil.IOPRIO_VERYLOW,
+                psutil.IOPRIO_LOW,
+                psutil.IOPRIO_NORMAL,
+                psutil.IOPRIO_HIGH,
+            ]
+            assert isinstance(ret, int)
+            assert ret >= 0
+            assert ret in choices
+
+    def num_threads(self, ret, info):
+        assert isinstance(ret, int)
+        if WINDOWS and ret == 0 and is_win_secure_system_proc(info['pid']):
+            # https://github.com/giampaolo/psutil/issues/2338
+            return
+        if POSIX and ret == 0 and info['pid'] == self.zombie.pid:
+            return
+        assert ret >= 1
+
+    def threads(self, ret, info):
+        assert isinstance(ret, list)
+        for t in ret:
+            assert t.id >= 0
+            assert t.user_time >= 0
+            assert t.system_time >= 0
+            for field in t:
+                assert isinstance(field, (int, float))
+
+    def cpu_times(self, ret, info):
+        for n in ret:
+            assert isinstance(n, float)
+            assert n >= 0
+        # TODO: check ntuple fields
+
+    def cpu_num(self, ret, info):
+        assert isinstance(ret, int)
+        if FREEBSD and ret == -1:
+            return
+        assert ret >= 0
+        if psutil.cpu_count() == 1:
+            assert ret == 0
+        assert ret in list(range(psutil.cpu_count()))
+
+    def memory_info(self, ret, info):
+        self.check_proc_memory(ret)
+
+    def memory_extras(self, ret, info):
+        self.check_proc_memory(ret)
+
+    def memory_footprint(self, ret, info):
+        for name in ret._fields:
+            value = getattr(ret, name)
+            assert isinstance(value, int)
+            assert value >= 0
+
+    def open_files(self, ret, info):
+        assert isinstance(ret, list)
+        for f in ret:
+            assert isinstance(f.fd, int)
+            assert isinstance(f.path, str)
+            assert f.path.strip() == f.path
+            if WINDOWS:
+                assert f.fd == -1
+            elif LINUX:
+                assert isinstance(f.position, int)
+                assert isinstance(f.mode, str)
+                assert isinstance(f.flags, int)
+                assert f.position >= 0
+                assert f.mode in {'r', 'w', 'a', 'r+', 'a+'}
+                assert f.flags > 0
+            elif BSD and not f.path:
+                # XXX see: https://github.com/giampaolo/psutil/issues/595
+                continue
+            assert os.path.isabs(f.path), f
+            try:
+                st = os.stat(f.path)
+            except FileNotFoundError:
+                pass
+            else:
+                assert stat.S_ISREG(st.st_mode), f
+
+    def num_fds(self, ret, info):
+        assert isinstance(ret, int)
+        assert ret >= 0
+
+    def net_connections(self, ret, info):
+        assert len(ret) == len(set(ret))
+        for conn in ret:
+            check_connection_ntuple(conn)
+
+    def cwd(self, ret, info):
+        assert isinstance(ret, str)
+        assert ret.strip() == ret
+        if ret:
+            assert os.path.isabs(ret), ret
+            try:
+                st = os.stat(ret)
+            except OSError as err:
+                if WINDOWS and psutil._psplatform.is_permission_err(err):
+                    pass
+                # directory has been removed in mean time
+                elif err.errno != errno.ENOENT:
+                    raise
+            else:
+                assert stat.S_ISDIR(st.st_mode)
+
+    def cpu_affinity(self, ret, info):
+        assert isinstance(ret, list)
+        assert ret != []
+        cpus = list(range(psutil.cpu_count()))
+        for n in ret:
+            assert isinstance(n, int)
+            assert n in cpus
+
+    def terminal(self, ret, info):
+        assert isinstance(ret, (str, type(None)))
+        if ret is not None:
+            assert os.path.isabs(ret), ret
+            assert os.path.exists(ret), ret
+
+    def memory_maps(self, ret, info):
+        for nt in ret:
+            if hasattr(nt, "addr"):
+                assert isinstance(nt.addr, str)
+            if hasattr(nt, "perms"):
+                assert isinstance(nt.perms, str)
+            assert isinstance(nt.path, str)
+            for fname in nt._fields:
+                value = getattr(nt, fname)
+                if fname == 'path':
+                    if value.startswith(("[", "anon_inode:")):  # linux
+                        continue
+                    if BSD and value == "pvclock":  # seen on FreeBSD
+                        continue
+                    assert os.path.isabs(nt.path), nt.path
+                    # commented as on Linux we might get
+                    # '/foo/bar (deleted)'
+                    # assert os.path.exists(nt.path), nt.path
+                elif fname == 'addr':
+                    assert value, repr(value)
+                elif fname == 'perms':
+                    if not WINDOWS:
+                        assert value, repr(value)
+                else:
+                    assert isinstance(value, int)
+                    assert value >= 0
+
+    def num_handles(self, ret, info):
+        assert isinstance(ret, int)
+        assert ret >= 0
+
+    def page_faults(self, ret, info):
+        assert isinstance(ret.minor, int)
+        assert isinstance(ret.major, int)
+        assert ret.minor >= 0
+        assert ret.major >= 0
+
+    def nice(self, ret, info):
+        assert isinstance(ret, int)
+        if POSIX:
+            assert -20 <= ret <= 20, ret
+        else:
+            priorities = [
+                getattr(psutil, x)
+                for x in dir(psutil)
+                if x.endswith('_PRIORITY_CLASS')
+            ]
+            assert ret in priorities
+            assert isinstance(ret, enum.IntEnum)
+
+    def num_ctx_switches(self, ret, info):
+        for value in ret:
+            assert isinstance(value, int)
+            assert value >= 0
+
+    def rlimit(self, ret, info):
+        assert isinstance(ret, tuple)
+        assert len(ret) == 2
+        assert ret[0] >= -1
+        assert ret[1] >= -1
+
+    def environ(self, ret, info):
+        assert isinstance(ret, dict)
+        for k, v in ret.items():
+            assert isinstance(k, str)
+            assert isinstance(v, str)
+
+
+class TestPidsRange(PsutilTestCase):
+    """Given pid_exists() return value for a range of PIDs which may or
+    may not exist, make sure that psutil.Process() and psutil.pids()
+    agree with pid_exists(). This guarantees that the 3 APIs are all
+    consistent with each other. See:
+    https://github.com/giampaolo/psutil/issues/2359
+
+    XXX - Note about Windows: it turns out there are some "hidden" PIDs
+    which are not returned by psutil.pids() and are also not revealed
+    by taskmgr.exe and ProcessHacker, still they can be instantiated by
+    psutil.Process() and queried. One of such PIDs is "conhost.exe".
+    Running as_dict() for it reveals that some Process() APIs
+    erroneously raise NoSuchProcess, so we know we have problem there.
+    Let's ignore this for now, since it's quite a corner case (who even
+    imagined hidden PIDs existed on Windows?).
+    """
+
+    def setUp(self):
+        psutil._set_debug(False)
+
+    def tearDown(self):
+        psutil._set_debug(True)
+
+    def test_it(self):
+        def is_linux_tid(pid):
+            try:
+                f = open(f"/proc/{pid}/status", "rb")  # noqa: SIM115
+            except FileNotFoundError:
+                return False
+            else:
+                with f:
+                    for line in f:
+                        if line.startswith(b"Tgid:"):
+                            tgid = int(line.split()[1])
+                            # If tgid and pid are different then we're
+                            # dealing with a process TID.
+                            return tgid != pid
+                    raise ValueError("'Tgid' line not found")
+
+        def check(pid):
+            # In case of failure retry up to 3 times in order to avoid
+            # race conditions, especially when running in a CI
+            # environment where PIDs may appear and disappear at any
+            # time.
+            x = 3
+            while True:
+                exists = psutil.pid_exists(pid)
+                try:
+                    if exists:
+                        psutil.Process(pid)
+                        if not WINDOWS:  # see docstring
+                            assert pid in psutil.pids()
+                    else:
+                        # On OpenBSD thread IDs can be instantiated,
+                        # and oneshot() succeeds, but other APIs fail
+                        # with EINVAL.
+                        if not OPENBSD:
+                            with pytest.raises(psutil.NoSuchProcess):
+                                psutil.Process(pid)
+                        if not WINDOWS:  # see docstring
+                            assert pid not in psutil.pids()
+                except (psutil.Error, AssertionError):
+                    x -= 1
+                    if x == 0:
+                        raise
+                else:
+                    return
+
+        for pid in range(1, 3000):
+            if LINUX and is_linux_tid(pid):
+                # On Linux a TID (thread ID) can be passed to the
+                # Process class and is querable like a PID (process
+                # ID). Skip it.
+                continue
+            check(pid)
diff --git a/tests/test_scripts.py b/tests/test_scripts.py
new file mode 100755
index 0000000000..da9e7eac5b
--- /dev/null
+++ b/tests/test_scripts.py
@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Test various scripts."""
+
+import ast
+import os
+import pathlib
+import stat
+
+import pytest
+
+from psutil import LINUX
+from psutil import POSIX
+
+from . import CI_TESTING
+from . import HAS_BATTERY
+from . import HAS_PROC_MEMORY_FOOTPRINT
+from . import HAS_PROC_MEMORY_MAPS
+from . import HAS_SENSORS_BATTERY
+from . import HAS_SENSORS_FANS
+from . import HAS_SENSORS_TEMPERATURES
+from . import PYTHON_EXE
+from . import PYTHON_EXE_ENV
+from . import ROOT_DIR
+from . import PsutilTestCase
+from . import import_module_by_path
+from . import psutil
+from . import sh
+from . import skipif
+
+SCRIPTS_DIR = pathlib.Path(ROOT_DIR) / "scripts"
+INTERNAL_SCRIPTS_DIR = SCRIPTS_DIR / "internal"
+
+
+class ScriptsTestCase(PsutilTestCase):
+    scripts_dir = SCRIPTS_DIR
+
+    def assert_stdout(self, exe, *args):
+        """Execute the script, make sure it doesn't crash and prints
+        something.
+        """
+        exe = os.path.join(self.scripts_dir, exe)
+        env = PYTHON_EXE_ENV.copy()
+        env.pop("PSUTIL_DEBUG", None)  # avoid spamming to stderr
+        cmd = [PYTHON_EXE, exe, *args]
+        try:
+            out = sh(cmd, env=env).strip()
+        except RuntimeError as err:
+            if 'AccessDenied' in str(err):
+                return str(err)
+            else:
+                raise
+        assert out, out
+        return out
+
+    def assert_syntax(self, exe):
+        """Check script's syntax without executing it."""
+        exe = os.path.join(self.scripts_dir, exe)
+        with open(exe, encoding="utf8") as f:
+            src = f.read()
+        ast.parse(src)
+
+
+# ===================================================================
+# --- Tests scripts in scripts/ directory
+# ===================================================================
+
+
+@skipif(
+    CI_TESTING and not os.path.exists(SCRIPTS_DIR),
+    reason="can't find scripts/ directory",
+)
+class TestExampleScripts(ScriptsTestCase):
+
+    def test_coverage(self):
+        # make sure all example scripts have a test method defined
+        meths = dir(self)
+        for name in os.listdir(SCRIPTS_DIR):
+            if name.endswith('.py') and not name.startswith("_"):
+                if 'test_' + os.path.splitext(name)[0] not in meths:
+                    # self.assert_stdout(name)
+                    return pytest.fail(
+                        "no test defined for"
+                        f" {os.path.join(SCRIPTS_DIR, name)!r} script"
+                    )
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_executable(self):
+        for root, dirs, files in os.walk(SCRIPTS_DIR):
+            for file in files:
+                if file.endswith('.py'):
+                    path = os.path.join(root, file)
+                    if not stat.S_IXUSR & os.stat(path)[stat.ST_MODE]:
+                        return pytest.fail(f"{path!r} is not executable")
+
+    def test_disk_usage(self):
+        self.assert_stdout('disk_usage.py')
+
+    def test_free(self):
+        self.assert_stdout('free.py')
+
+    def test_meminfo(self):
+        self.assert_stdout('meminfo.py')
+
+    def test_procinfo(self):
+        self.assert_stdout('procinfo.py', str(os.getpid()))
+
+    def test_who(self):
+        if not psutil.users():
+            return pytest.skip("no users logged in")
+        self.assert_stdout('who.py')
+
+    def test_ps(self):
+        self.assert_stdout('ps.py')
+
+    def test_pstree(self):
+        self.assert_stdout('pstree.py')
+
+    def test_netstat(self):
+        self.assert_stdout('netstat.py')
+
+    def test_ifconfig(self):
+        self.assert_stdout('ifconfig.py')
+
+    @skipif(not HAS_PROC_MEMORY_MAPS, reason="not supported")
+    def test_pmap(self):
+        self.assert_stdout('pmap.py', str(os.getpid()))
+
+    @skipif(not HAS_PROC_MEMORY_FOOTPRINT, reason="not supported")
+    def test_procsmem(self):
+        self.assert_syntax('procsmem.py')  # slow
+
+    def test_killall(self):
+        self.assert_syntax('killall.py')
+
+    def test_nettop(self):
+        self.assert_syntax('nettop.py')
+
+    def test_top(self):
+        self.assert_syntax('top.py')
+
+    def test_iotop(self):
+        self.assert_syntax('iotop.py')
+
+    def test_pidof(self):
+        output = self.assert_stdout('pidof.py', psutil.Process().name())
+        assert str(os.getpid()) in output
+
+    def test_winservices(self):
+        # Running it iterates over all services, which sporadically
+        # takes longer than GLOBAL_TIMEOUT on CI.
+        self.assert_syntax('winservices.py')
+
+    def test_cpu_distribution(self):
+        self.assert_syntax('cpu_distribution.py')
+
+    @skipif(not HAS_SENSORS_TEMPERATURES, reason="not supported")
+    def test_temperatures(self):
+        if not psutil.sensors_temperatures():
+            return pytest.skip("no temperatures")
+        self.assert_stdout('temperatures.py')
+
+    @skipif(not HAS_SENSORS_FANS, reason="not supported")
+    def test_fans(self):
+        if not psutil.sensors_fans():
+            return pytest.skip("no fans")
+        self.assert_stdout('fans.py')
+
+    @skipif(not HAS_SENSORS_BATTERY, reason="not supported")
+    @skipif(not HAS_BATTERY, reason="no battery")
+    def test_battery(self):
+        self.assert_stdout('battery.py')
+
+    @skipif(not HAS_SENSORS_BATTERY, reason="not supported")
+    @skipif(not HAS_BATTERY, reason="no battery")
+    def test_sensors(self):
+        self.assert_stdout('sensors.py')
+
+
+# ===================================================================
+# --- Tests scripts in scripts/internal/ directory
+# ===================================================================
+
+
+@skipif(
+    CI_TESTING and not os.path.exists(INTERNAL_SCRIPTS_DIR),
+    reason="can't find scripts/internal/ directory",
+)
+class TestInternalScripts(ScriptsTestCase):
+    scripts_dir = INTERNAL_SCRIPTS_DIR
+
+    @staticmethod
+    def ls():
+        for root, dirs, files in os.walk(INTERNAL_SCRIPTS_DIR):
+            for file in files:
+                if file.endswith(".py"):
+                    yield os.path.join(root, file)
+
+    def test_syntax_all(self):
+        for path in self.ls():
+            with open(path, encoding="utf8") as f:
+                data = f.read()
+            ast.parse(data)
+
+    # don't care about other platforms, this is really just for myself
+    @skipif(not LINUX, reason="not on LINUX")
+    @skipif(CI_TESTING, reason="not on CI")
+    def test_import_all(self):
+        for path in self.ls():
+            try:
+                import_module_by_path(path)
+            except SystemExit:
+                pass
+            except ImportError as err:
+                if "pyperf" in str(err) or "requests" in str(err):
+                    continue
+                raise
+
+    def test_print_api_speed(self):
+        self.assert_stdout("print_api_speed.py", "-t", "2")
+
+    def test_print_sysinfo(self):
+        self.assert_stdout("print_sysinfo.py")
diff --git a/tests/test_sudo.py b/tests/test_sudo.py
new file mode 100755
index 0000000000..aa80539a05
--- /dev/null
+++ b/tests/test_sudo.py
@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Tests which are meant to be run as root.
+
+NOTE: keep this module compatible with unittest: we want to run this
+file with the unittest runner, since pytest may not be installed for
+the root user.
+"""
+
+import datetime
+import time
+import unittest
+
+import psutil
+from psutil import FREEBSD
+from psutil import LINUX
+from psutil import OPENBSD
+from psutil import WINDOWS
+
+from . import CI_TESTING
+from . import PsutilTestCase
+from . import isolated
+
+
+def get_systime():
+    if hasattr(time, "clock_gettime") and hasattr(time, "CLOCK_REALTIME"):
+        return time.clock_gettime(time.CLOCK_REALTIME)
+    return time.time()
+
+
+def set_systime(secs):  # secs since the epoch
+    if hasattr(time, "clock_settime") and hasattr(time, "CLOCK_REALTIME"):
+        try:
+            time.clock_settime(time.CLOCK_REALTIME, secs)
+        except PermissionError:
+            raise unittest.SkipTest("needs root")
+    elif WINDOWS:
+        import pywintypes
+        import win32api
+
+        dt = datetime.datetime.fromtimestamp(secs, datetime.timezone.utc)
+        try:
+            win32api.SetSystemTime(
+                dt.year,
+                dt.month,
+                dt.isoweekday() % 7,
+                dt.day,
+                dt.hour,
+                dt.minute,
+                dt.second,
+                int(dt.microsecond / 1000),
+            )
+        except pywintypes.error as err:
+            if err.winerror == 1314:
+                raise unittest.SkipTest("needs Administrator user")
+            raise
+    else:
+        raise unittest.SkipTest("setting systime not supported")
+
+
+@isolated
+class TestUpdatedSystemTime(PsutilTestCase):
+    """Tests which update the system clock."""
+
+    def setUp(self):
+        self.time_updated = False
+        self.orig_time = get_systime()
+        self.time_started = time.monotonic()
+
+    def tearDown(self):
+        if self.time_updated:
+            extra_t = time.monotonic() - self.time_started
+            set_systime(self.orig_time + extra_t)
+
+    def update_systime(self):
+        # set system time 1 hour later
+        set_systime(self.orig_time + 3600)
+        self.time_updated = True
+
+    def test_boot_time(self):
+        # Test that boot_time() reflects system clock updates.
+        t1 = psutil.boot_time()
+        self.update_systime()
+        t2 = psutil.boot_time()
+        self.assertGreater(t2, t1)
+        diff = int(t2 - t1)
+        self.assertAlmostEqual(diff, 3600, delta=1)
+
+    @unittest.skipIf(WINDOWS, "broken on WINDOWS")  # TODO: fix it
+    def test_proc_create_time(self):
+        # Test that Process.create_time() reflects system clock
+        # updates. On systems such as Linux this is added on top of the
+        # process monotonic time returned by the kernel.
+        t1 = psutil.Process().create_time()
+        self.update_systime()
+        t2 = psutil.Process().create_time()
+        diff = int(t2 - t1)
+        self.assertAlmostEqual(diff, 3600, delta=1)
+
+    @unittest.skipIf(CI_TESTING, "skipped on CI for now")  # TODO: fix it
+    @unittest.skipIf(OPENBSD, "broken on OPENBSD")  # TODO: fix it
+    @unittest.skipIf(FREEBSD, "broken on FREEBSD")  # TODO: fix it
+    def test_proc_ident(self):
+        p1 = psutil.Process()
+        self.update_systime()
+        p2 = psutil.Process()
+        self.assertEqual(p1._get_ident(), p2._get_ident())
+        self.assertEqual(p1, p2)
+
+    @unittest.skipIf(not LINUX, "LINUX only")
+    def test_linux_monotonic_proc_time(self):
+        t1 = psutil.Process()._proc.create_time(monotonic=True)
+        self.update_systime()
+        time.sleep(0.05)
+        t2 = psutil.Process()._proc.create_time(monotonic=True)
+        self.assertEqual(t1, t2)
diff --git a/tests/test_sunos.py b/tests/test_sunos.py
new file mode 100755
index 0000000000..2af3965646
--- /dev/null
+++ b/tests/test_sunos.py
@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Sun OS specific tests."""
+
+import os
+
+import psutil
+from psutil import SUNOS
+
+from . import PsutilTestCase
+from . import sh
+from . import skipif
+
+
+@skipif(not SUNOS, reason="SUNOS only")
+class SunOSSpecificTestCase(PsutilTestCase):
+    def test_swap_memory(self):
+        out = sh(f"env PATH=/usr/sbin:/sbin:{os.environ['PATH']} swap -l")
+        lines = out.strip().split('\n')[1:]
+        if not lines:
+            raise ValueError('no swap device(s) configured')
+        total = free = 0
+        for line in lines:
+            fields = line.split()
+            total = int(fields[3]) * 512
+            free = int(fields[4]) * 512
+        used = total - free
+
+        psutil_swap = psutil.swap_memory()
+        assert psutil_swap.total == total
+        assert psutil_swap.used == used
+        assert psutil_swap.free == free
+
+    def test_cpu_count(self):
+        out = sh("/usr/sbin/psrinfo")
+        assert psutil.cpu_count() == len(out.split('\n'))
diff --git a/tests/test_system.py b/tests/test_system.py
new file mode 100755
index 0000000000..bfba8f622e
--- /dev/null
+++ b/tests/test_system.py
@@ -0,0 +1,1158 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Tests for system APIS."""
+
+import datetime
+import enum
+import errno
+import os
+import pprint
+import shutil
+import signal
+import socket
+import sys
+import time
+import warnings
+from unittest import mock
+
+import psutil
+from psutil import AIX
+from psutil import BSD
+from psutil import FREEBSD
+from psutil import LINUX
+from psutil import MACOS
+from psutil import NETBSD
+from psutil import OPENBSD
+from psutil import POSIX
+from psutil import SUNOS
+from psutil import WINDOWS
+from psutil import _psutil
+from psutil._common import broadcast_addr
+
+from . import AARCH64
+from . import ASCII_FS
+from . import CI_TESTING
+from . import FREE_THREADED
+from . import GITHUB_ACTIONS
+from . import GLOBAL_TIMEOUT
+from . import HAS_BATTERY
+from . import HAS_CPU_FREQ
+from . import HAS_HEAP_INFO
+from . import HAS_NET_IO_COUNTERS
+from . import HAS_SENSORS_BATTERY
+from . import HAS_SENSORS_FANS
+from . import HAS_SENSORS_TEMPERATURES
+from . import MACOS_12PLUS
+from . import UNICODE_SUFFIX
+from . import PsutilTestCase
+from . import check_net_address
+from . import pytest
+from . import retry_on_failure
+from . import skipif
+
+# ===================================================================
+# --- System-related API tests
+# ===================================================================
+
+
+class TestProcessIter(PsutilTestCase):
+    def test_pid_presence(self):
+        assert os.getpid() in [x.pid for x in psutil.process_iter()]
+        sproc = self.spawn_subproc()
+        assert sproc.pid in [x.pid for x in psutil.process_iter()]
+        p = psutil.Process(sproc.pid)
+        p.kill()
+        p.wait()
+        assert sproc.pid not in [x.pid for x in psutil.process_iter()]
+
+    def test_no_duplicates(self):
+        ls = list(psutil.process_iter())
+        assert sorted(ls, key=lambda x: x.pid) == sorted(
+            set(ls), key=lambda x: x.pid
+        )
+
+    def test_emulate_nsp(self):
+        list(psutil.process_iter())  # populate cache
+        for x in range(2):
+            with mock.patch(
+                'psutil.Process.as_dict',
+                side_effect=psutil.NoSuchProcess(os.getpid()),
+            ):
+                assert not list(psutil.process_iter(attrs=["cpu_times"]))
+            psutil.process_iter.cache_clear()  # repeat test without cache
+
+    def test_emulate_access_denied(self):
+        list(psutil.process_iter())  # populate cache
+        for x in range(2):
+            with mock.patch(
+                'psutil.Process.as_dict',
+                side_effect=psutil.AccessDenied(os.getpid()),
+            ):
+                with pytest.raises(psutil.AccessDenied):
+                    list(psutil.process_iter(attrs=["cpu_times"]))
+            psutil.process_iter.cache_clear()  # repeat test without cache
+
+    def test_attrs(self):
+        for p in psutil.process_iter(attrs=['pid']):
+            assert list(p._prefetch.keys()) == ['pid']
+        # yield again
+        for p in psutil.process_iter(attrs=['pid']):
+            assert list(p._prefetch.keys()) == ['pid']
+        with pytest.raises(ValueError):
+            list(psutil.process_iter(attrs=['foo']))
+        with mock.patch(
+            "psutil._psplatform.Process.cpu_times",
+            side_effect=psutil.AccessDenied(0, ""),
+        ) as m:
+            for p in psutil.process_iter(attrs=["pid", "cpu_times"]):
+                assert p._prefetch['cpu_times'] is None
+                assert p._prefetch['pid'] >= 0
+            assert m.called
+        with mock.patch(
+            "psutil._psplatform.Process.cpu_times",
+            side_effect=psutil.AccessDenied(0, ""),
+        ) as m:
+            flag = object()
+            for p in psutil.process_iter(
+                attrs=["pid", "cpu_times"], ad_value=flag
+            ):
+                assert p._prefetch['cpu_times'] is flag
+                assert p._prefetch['pid'] >= 0
+            assert m.called
+
+    def test_prefetch(self):
+        for p in psutil.process_iter(attrs=["name", "status"]):
+            assert p.name() == p._prefetch["name"]
+            assert p.status() == p._prefetch["status"]
+
+    def test_prefetch_memory_percent(self):
+        # It used to skip its own cached value, run the body, and
+        # crash on memory_info()'s ad_value.
+        with mock.patch(
+            "psutil._psplatform.Process.memory_info",
+            side_effect=psutil.AccessDenied(0, ""),
+        ):
+            for p in psutil.process_iter(attrs=["memory_percent"]):
+                assert p.memory_percent() is None
+
+    def test_prefetch_derived_methods(self):
+        # The derived method is not in attrs, so its body runs and
+        # reads the denied one's ad_value.
+        with mock.patch(
+            "psutil._psplatform.Process.memory_info",
+            side_effect=psutil.AccessDenied(0, ""),
+        ):
+            for p in psutil.process_iter(attrs=["memory_info"]):
+                assert p.memory_percent() is None
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_prefetch_derived_username(self):
+        # username() derives from uids(), which is POSIX only.
+        with mock.patch(
+            "psutil._psplatform.Process.uids",
+            side_effect=psutil.AccessDenied(0, ""),
+        ):
+            for p in psutil.process_iter(attrs=["uids"]):
+                assert p.username() is None
+
+    def test_prefetch_ad_value_is_not_none(self):
+        # ad_value can be any object, not just None.
+        flag = object()
+        with mock.patch(
+            "psutil._psplatform.Process.memory_info",
+            side_effect=psutil.AccessDenied(0, ""),
+        ):
+            for p in psutil.process_iter(attrs=["memory_info"], ad_value=flag):
+                assert p.memory_percent() is flag
+
+    def test_info_deprecation(self):
+        for p in psutil.process_iter(attrs=["name"]):
+            with warnings.catch_warnings(record=True) as ws:
+                warnings.simplefilter("always")
+                p.info  # noqa: B018
+                assert len(ws) == 1
+                assert issubclass(ws[0].category, DeprecationWarning)
+                assert "deprecated" in str(ws[0].message)
+            break
+
+    def test_prefetch_ad_value(self):
+        with mock.patch(
+            "psutil._psplatform.Process.cpu_times",
+            side_effect=psutil.AccessDenied(0, ""),
+        ):
+            for p in psutil.process_iter(attrs=["cpu_times"]):
+                assert p.cpu_times() is None
+
+    def test_prefetch_cleared(self):
+        # Prefetch cache is cleared when attrs is not specified.
+        for p in psutil.process_iter(attrs=["name"]):
+            assert p._prefetch
+        for p in psutil.process_iter():
+            assert not p._prefetch
+
+    def test_prefetch_with_args_bypasses_cache(self):
+        # Methods called with args should bypass the prefetch cache
+        # (e.g. nice(10) is a setter, not a getter).
+        p = psutil.Process()
+        p._prefetch["nice"] = -999
+        # Without args: returns cached value.
+        assert p.nice() == -999
+        # With args: bypasses cache, calls real method.
+        real_nice = psutil.Process().nice()
+        assert p.nice(real_nice) is None
+        assert p.nice() == -999
+
+    def test_prefetch_double_call(self):
+        # Multiple calls should return the same cached value.
+        for p in psutil.process_iter(attrs=["name"]):
+            name1 = p.name()
+            name2 = p.name()
+            assert name1 == name2
+            assert name1 == p._prefetch["name"]
+            break
+
+    def test_deprecated_prefetch_empty_attrs(self):
+        # attrs=[] should prefetch all methods.
+        with pytest.warns(DeprecationWarning):
+            for p in psutil.process_iter(attrs=[]):
+                break
+        assert p._prefetch.keys() == psutil.Process.attrs
+
+    def test_prefetch_with_non_prefetched(self):
+        # A method not in attrs should still do a live syscall.
+        for p in psutil.process_iter(attrs=["name"]):
+            assert "status" not in p._prefetch
+            # status() should still work via syscall
+            assert p.status()
+            break
+
+    def test_zombie_process_is_not_skipped(self):
+        # ZombieProcess is a subclass of NoSuchProcess; make sure
+        # process_iter() yields the process rather than removing it from
+        # the cache as if it had disappeared.
+        list(psutil.process_iter())  # populate the pmap cache
+        p = psutil._pmap[os.getpid()]
+        with mock.patch.object(
+            p, "as_dict", side_effect=psutil.ZombieProcess(p.pid)
+        ):
+            pids = [x.pid for x in psutil.process_iter(attrs=["name"])]
+        assert p.pid in pids
+
+    def test_cache_clear(self):
+        list(psutil.process_iter())  # populate cache
+        assert psutil._pmap
+        psutil.process_iter.cache_clear()
+        assert not psutil._pmap
+
+
+class TestProcessAPIs(PsutilTestCase):
+    def test_wait_procs(self):
+        def callback(p):
+            pids.append(p.pid)
+
+        pids = []
+        sproc1 = self.spawn_subproc()
+        sproc2 = self.spawn_subproc()
+        sproc3 = self.spawn_subproc()
+        procs = [psutil.Process(x.pid) for x in (sproc1, sproc2, sproc3)]
+        with pytest.raises(ValueError):
+            psutil.wait_procs(procs, timeout=-1)
+        with pytest.raises(TypeError):
+            psutil.wait_procs(procs, callback=1)
+        t = time.monotonic()
+        gone, alive = psutil.wait_procs(procs, timeout=0.01, callback=callback)
+
+        assert time.monotonic() - t < 0.5
+        assert not gone
+        assert len(alive) == 3
+        assert not pids
+        for p in alive:
+            assert not hasattr(p, 'returncode')
+
+        @retry_on_failure(30)
+        def test_1(procs, callback):
+            gone, alive = psutil.wait_procs(
+                procs, timeout=0.03, callback=callback
+            )
+            assert len(gone) == 1
+            assert len(alive) == 2
+            return gone, alive
+
+        sproc3.terminate()
+        gone, alive = test_1(procs, callback)
+        assert sproc3.pid in [x.pid for x in gone]
+        if POSIX:
+            assert gone.pop().returncode == -signal.SIGTERM
+        else:
+            assert gone.pop().returncode == 1
+        assert pids == [sproc3.pid]
+        for p in alive:
+            assert not hasattr(p, 'returncode')
+
+        @retry_on_failure(30)
+        def test_2(procs, callback):
+            gone, alive = psutil.wait_procs(
+                procs, timeout=0.03, callback=callback
+            )
+            assert len(gone) == 3
+            assert len(alive) == 0
+            return gone, alive
+
+        sproc1.terminate()
+        sproc2.terminate()
+        gone, alive = test_2(procs, callback)
+        assert set(pids) == {sproc1.pid, sproc2.pid, sproc3.pid}
+        for p in gone:
+            assert hasattr(p, 'returncode')
+
+    def test_wait_procs_no_timeout(self):
+        sproc1 = self.spawn_subproc()
+        sproc2 = self.spawn_subproc()
+        sproc3 = self.spawn_subproc()
+        procs = [psutil.Process(x.pid) for x in (sproc1, sproc2, sproc3)]
+        for p in procs:
+            p.terminate()
+        psutil.wait_procs(procs)
+
+    def test_pid_exists(self):
+        sproc = self.spawn_subproc()
+        assert psutil.pid_exists(sproc.pid)
+        p = psutil.Process(sproc.pid)
+        p.kill()
+        p.wait()
+        assert not psutil.pid_exists(sproc.pid)
+        assert not psutil.pid_exists(-1)
+        assert psutil.pid_exists(0) == (0 in psutil.pids())
+
+    def test_pid_exists_2(self):
+        pids = psutil.pids()
+        for pid in pids:
+            try:
+                assert psutil.pid_exists(pid)
+            except AssertionError:
+                # in case the process disappeared in meantime fail only
+                # if it is no longer in psutil.pids()
+                time.sleep(0.1)
+                assert pid not in psutil.pids()
+        pids = range(max(pids) + 15000, max(pids) + 16000)
+        for pid in pids:
+            assert not psutil.pid_exists(pid)
+
+
+class TestMiscAPIs(PsutilTestCase):
+    def test_boot_time(self):
+        bt = psutil.boot_time()
+        assert isinstance(bt, float)
+        assert bt > 0
+        assert bt < time.time()
+
+    def test_users(self):
+        if not psutil.users():
+            return pytest.skip("no users logged in")
+        users = psutil.users()
+        assert users
+        for user in users:
+            with self.subTest(user=str(user)):
+                assert user.name
+                assert isinstance(user.name, str)
+                assert isinstance(user.terminal, (str, type(None)))
+                if user.host is not None:
+                    assert isinstance(user.host, (str, type(None)))
+                user.terminal  # noqa: B018
+                user.host  # noqa: B018
+                assert user.started > 0.0
+                datetime.datetime.fromtimestamp(user.started)
+                if WINDOWS or OPENBSD:
+                    assert user.pid is None
+                else:
+                    psutil.Process(user.pid)
+
+    @skipif(not HAS_HEAP_INFO, reason="not supported")
+    def test_heap_info(self):
+        m = psutil.heap_info()
+        assert m.heap_used > 0
+        if MACOS or FREE_THREADED:
+            # macOS doesn't support it. Free-threaded builds allocate via
+            # mimalloc, so glibc's malloc arena stays mostly unused.
+            assert m.mmap_used == 0
+        else:
+            assert m.mmap_used > 0
+        if WINDOWS:
+            assert m.heap_count >= 0
+
+    @skipif(not HAS_HEAP_INFO, reason="not supported")
+    def test_heap_trim(self):
+        psutil.heap_trim()
+
+    def test_os_constants(self):
+        names = [
+            "POSIX",
+            "WINDOWS",
+            "LINUX",
+            "MACOS",
+            "FREEBSD",
+            "OPENBSD",
+            "NETBSD",
+            "BSD",
+            "SUNOS",
+        ]
+        for name in names:
+            assert isinstance(getattr(psutil, name), bool), name
+
+        if os.name == 'posix':
+            assert psutil.POSIX
+            assert not psutil.WINDOWS
+            names.remove("POSIX")
+            if "linux" in sys.platform.lower():
+                assert psutil.LINUX
+                names.remove("LINUX")
+            elif "bsd" in sys.platform.lower():
+                assert psutil.BSD
+                assert [psutil.FREEBSD, psutil.OPENBSD, psutil.NETBSD].count(
+                    True
+                ) == 1
+                names.remove("BSD")
+                names.remove("FREEBSD")
+                names.remove("OPENBSD")
+                names.remove("NETBSD")
+            elif (
+                "sunos" in sys.platform.lower()
+                or "solaris" in sys.platform.lower()
+            ):
+                assert psutil.SUNOS
+                names.remove("SUNOS")
+            elif "darwin" in sys.platform.lower():
+                assert psutil.MACOS
+                names.remove("MACOS")
+        else:
+            assert psutil.WINDOWS
+            assert not psutil.POSIX
+            names.remove("WINDOWS")
+
+        # assert all other constants are set to False
+        for name in names:
+            assert not getattr(psutil, name), name
+
+
+class TestMemoryAPIs(PsutilTestCase):
+    def test_virtual_memory(self):
+        mem = psutil.virtual_memory()
+        assert mem.total > 0, mem
+        assert mem.available > 0, mem
+        assert 0 <= mem.percent <= 100, mem
+        assert mem.used > 0, mem
+        assert mem.free >= 0, mem
+        for name in mem._fields:
+            value = getattr(mem, name)
+            if name != 'percent':
+                assert isinstance(value, int)
+            if name != 'total':
+                if not value >= 0:
+                    return pytest.fail(f"{name!r} < 0 ({value})")
+                if value > mem.total:
+                    return pytest.fail(
+                        f"{name!r} > total (total={mem.total}, {name}={value})"
+                    )
+
+    def test_virtual_memory_fields_order(self):
+        mem = psutil.virtual_memory()
+        common = ("total", "available", "percent", "used", "free")
+        assert mem._fields[:5] == common
+        if LINUX:
+            assert mem._fields[5:] == (
+                "active",
+                "inactive",
+                "buffers",
+                "cached",
+                "shared",
+                "slab",
+            )
+        elif MACOS:
+            assert mem._fields[5:] == (
+                "active",
+                "inactive",
+                "wired",
+            )
+        elif BSD:
+            assert mem._fields[5:] == (
+                "active",
+                "inactive",
+                "buffers",
+                "cached",
+                "shared",
+                "wired",
+            )
+        elif WINDOWS:
+            assert mem._fields[5:] == (
+                "cached",
+                "wired",
+            )
+        elif SUNOS or AIX:
+            assert mem._fields[5:] == ()
+
+    def test_swap_memory(self):
+        mem = psutil.swap_memory()
+        assert mem._fields == (
+            'total',
+            'used',
+            'free',
+            'percent',
+            'sin',
+            'sout',
+        )
+
+        assert mem.total >= 0, mem
+        assert mem.used >= 0, mem
+        if mem.total > 0:
+            # free can be 0 if swap is entirely in use
+            assert mem.free >= 0, mem
+        else:
+            # likely a system with no swap partition
+            assert mem.free == 0, mem
+        assert 0 <= mem.percent <= 100, mem
+        assert mem.sin >= 0, mem
+        assert mem.sout >= 0, mem
+
+
+class TestCpuAPIs(PsutilTestCase):
+    def test_cpu_count_logical(self):
+        logical = psutil.cpu_count()
+        assert logical is not None
+        assert logical == len(psutil.cpu_times(percpu=True))
+        assert logical >= 1
+
+        if os.path.exists("/proc/cpuinfo"):
+            with open("/proc/cpuinfo") as fd:
+                cpuinfo_data = fd.read()
+            if "physical id" not in cpuinfo_data:
+                return pytest.skip("cpuinfo doesn't include physical id")
+
+    def test_cpu_count_cores(self):
+        logical = psutil.cpu_count()
+        cores = psutil.cpu_count(logical=False)
+        if cores is None:
+            return pytest.skip("cpu_count_cores() is None")
+        if WINDOWS and sys.getwindowsversion()[:2] <= (6, 1):  # <= Vista
+            assert cores is None
+        else:
+            assert cores >= 1
+            assert logical >= cores
+
+    def test_cpu_count_none(self):
+        # https://github.com/giampaolo/psutil/issues/1085
+        for val in (-1, 0, None):
+            with mock.patch(
+                'psutil._psplatform.cpu_count_logical', return_value=val
+            ) as m:
+                assert psutil.cpu_count() is None
+                assert m.called
+            with mock.patch(
+                'psutil._psplatform.cpu_count_cores', return_value=val
+            ) as m:
+                assert psutil.cpu_count(logical=False) is None
+                assert m.called
+
+    def test_cpu_times(self):
+        # Check type, value >= 0, str().
+        total = 0
+        times = psutil.cpu_times()
+        sum(times)
+        for cp_time in times:
+            assert isinstance(cp_time, float)
+            assert cp_time >= 0.0
+            total += cp_time
+        assert round(abs(total - sum(times)), 6) == 0
+        str(times)
+        # CPU times are always supposed to increase over time
+        # or at least remain the same and that's because time
+        # cannot go backwards.
+        # Surprisingly sometimes this might not be the case (at
+        # least on Windows and Linux), see:
+        # https://github.com/giampaolo/psutil/issues/392
+        # https://github.com/giampaolo/psutil/issues/645
+        # if not WINDOWS:
+        #     last = psutil.cpu_times()
+        #     for x in range(100):
+        #         new = psutil.cpu_times()
+        #         for field in new._fields:
+        #             new_t = getattr(new, field)
+        #             last_t = getattr(last, field)
+        #             assert new_t >= last_t
+        #         last = new
+
+    def test_cpu_times_time_increases(self):
+        # Make sure time increases between calls.
+        t1 = sum(psutil.cpu_times())
+        stop_at = time.monotonic() + GLOBAL_TIMEOUT
+        while time.monotonic() < stop_at:
+            t2 = sum(psutil.cpu_times())
+            if t2 > t1:
+                return None
+        return pytest.fail("time remained the same")
+
+    def test_per_cpu_times(self):
+        # Check type, value >= 0, str().
+        for times in psutil.cpu_times(percpu=True):
+            total = 0
+            sum(times)
+            for cp_time in times:
+                assert isinstance(cp_time, float)
+                assert cp_time >= 0.0
+                total += cp_time
+            assert round(abs(total - sum(times)), 6) == 0
+            str(times)
+        assert len(psutil.cpu_times(percpu=True)[0]) == len(
+            psutil.cpu_times(percpu=False)
+        )
+
+        # Note: in theory CPU times are always supposed to increase over
+        # time or remain the same but never go backwards. In practice
+        # sometimes this is not the case.
+        # This issue seemed to be afflict Windows:
+        # https://github.com/giampaolo/psutil/issues/392
+        # ...but it turns out also Linux (rarely) behaves the same.
+        # last = psutil.cpu_times(percpu=True)
+        # for x in range(100):
+        #     new = psutil.cpu_times(percpu=True)
+        #     for index in range(len(new)):
+        #         newcpu = new[index]
+        #         lastcpu = last[index]
+        #         for field in newcpu._fields:
+        #             new_t = getattr(newcpu, field)
+        #             last_t = getattr(lastcpu, field)
+        #             assert new_t >= last_t
+        #     last = new
+
+    def test_per_cpu_times_2(self):
+        # Simulate some work load then make sure time have increased
+        # between calls.
+        tot1 = psutil.cpu_times(percpu=True)
+        giveup_at = time.monotonic() + GLOBAL_TIMEOUT
+        while True:
+            if time.monotonic() >= giveup_at:
+                return pytest.fail("timeout")
+            tot2 = psutil.cpu_times(percpu=True)
+            for t1, t2 in zip(tot1, tot2):
+                t1, t2 = psutil._cpu_busy_time(t1), psutil._cpu_busy_time(t2)
+                difference = t2 - t1
+                if difference >= 0.05:
+                    return None
+
+    @skipif(SUNOS, reason="unreliable on SUNOS")
+    @retry_on_failure(30)
+    def test_cpu_times_comparison(self):
+        # Make sure the sum of all per cpu times is almost equal to
+        # base "one cpu" times.
+        base = psutil.cpu_times()
+        per_cpu = psutil.cpu_times(percpu=True)
+        summed_values = base._make([sum(num) for num in zip(*per_cpu)])
+        mismatches = {
+            field: (getattr(base, field), getattr(summed_values, field))
+            for field in base._fields
+            if abs(getattr(base, field) - getattr(summed_values, field)) >= 2
+        }
+        assert mismatches == {}
+
+    def _test_cpu_percent(self, percent, last_ret, new_ret):
+        try:
+            assert isinstance(percent, float)
+            assert percent >= 0.0
+            assert percent <= 100.0 * psutil.cpu_count()
+        except AssertionError as err:
+            raise AssertionError(
+                "\n{}\nlast={}\nnew={}".format(
+                    err, pprint.pformat(last_ret), pprint.pformat(new_ret)
+                )
+            )
+
+    def test_cpu_percent(self):
+        last = psutil.cpu_percent(interval=0.001)
+        for _ in range(100):
+            new = psutil.cpu_percent(interval=None)
+            self._test_cpu_percent(new, last, new)
+            last = new
+        with pytest.raises(ValueError):
+            psutil.cpu_percent(interval=-1)
+
+    def test_per_cpu_percent(self):
+        last = psutil.cpu_percent(interval=0.001, percpu=True)
+        assert len(last) == psutil.cpu_count()
+        for _ in range(100):
+            new = psutil.cpu_percent(interval=None, percpu=True)
+            for percent in new:
+                self._test_cpu_percent(percent, last, new)
+            last = new
+        with pytest.raises(ValueError):
+            psutil.cpu_percent(interval=-1, percpu=True)
+
+    def test_cpu_times_percent(self):
+        last = psutil.cpu_times_percent(interval=0.001)
+        for _ in range(100):
+            new = psutil.cpu_times_percent(interval=None)
+            for percent in new:
+                self._test_cpu_percent(percent, last, new)
+            self._test_cpu_percent(sum(new), last, new)
+            last = new
+        with pytest.raises(ValueError):
+            psutil.cpu_times_percent(interval=-1)
+
+    def test_per_cpu_times_percent(self):
+        last = psutil.cpu_times_percent(interval=0.001, percpu=True)
+        assert len(last) == psutil.cpu_count()
+        for _ in range(100):
+            new = psutil.cpu_times_percent(interval=None, percpu=True)
+            for cpu in new:
+                for percent in cpu:
+                    self._test_cpu_percent(percent, last, new)
+                self._test_cpu_percent(sum(cpu), last, new)
+            last = new
+
+    def test_per_cpu_times_percent_negative(self):
+        # see: https://github.com/giampaolo/psutil/issues/645
+        psutil.cpu_times_percent(percpu=True)
+        zero_times = [
+            x._make([0 for x in range(len(x._fields))])
+            for x in psutil.cpu_times(percpu=True)
+        ]
+        with mock.patch('psutil.cpu_times', return_value=zero_times):
+            for cpu in psutil.cpu_times_percent(percpu=True):
+                for percent in cpu:
+                    self._test_cpu_percent(percent, None, None)
+
+    def test_cpu_stats(self):
+        # Tested more extensively in per-platform test modules.
+        infos = psutil.cpu_stats()
+        assert infos._fields == (
+            'ctx_switches',
+            'interrupts',
+            'soft_interrupts',
+            'syscalls',
+        )
+        for name in infos._fields:
+            value = getattr(infos, name)
+            assert value >= 0
+            # on AIX, ctx_switches is always 0
+            if not AIX and name in {'ctx_switches', 'interrupts'}:
+                assert value > 0
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    def test_cpu_freq(self):
+        def check_ls(ls):
+            for nt in ls:
+                assert nt._fields == ('current', 'min', 'max')
+                for name in nt._fields:
+                    value = getattr(nt, name)
+                    assert isinstance(value, (int, float))
+                    assert value >= 0
+
+        ls = psutil.cpu_freq(percpu=True)
+        if (FREEBSD or AARCH64) and not ls:
+            return pytest.skip(
+                "returns empty list on FreeBSD and Linux aarch64"
+            )
+
+        assert ls, ls
+        check_ls([psutil.cpu_freq(percpu=False)])
+
+        if LINUX:
+            assert len(ls) == psutil.cpu_count()
+
+    @skipif(not HAS_CPU_FREQ, reason="not supported")
+    def test_cpu_freq_none_minmax(self):
+        # min / max are None on FreeBSD when the sysctl is unparsable.
+        # Averaging them across CPUs used to raise TypeError.
+        ret = [
+            psutil._ntuples.scpufreq(100.0, None, None),
+            psutil._ntuples.scpufreq(200.0, None, None),
+        ]
+        with mock.patch("psutil._psplatform.cpu_freq", return_value=ret):
+            with mock.patch("psutil.LINUX", False):
+                nt = psutil.cpu_freq()
+        assert nt.current == 150.0
+        assert nt.min is None
+        assert nt.max is None
+
+    def test_getloadavg(self):
+        loadavg = psutil.getloadavg()
+        assert len(loadavg) == 3
+        for load in loadavg:
+            assert isinstance(load, float)
+            assert load >= 0.0
+
+
+class TestDiskAPIs(PsutilTestCase):
+    def test_disk_usage(self):
+        usage = psutil.disk_usage(os.getcwd())
+        assert usage._fields == ('total', 'used', 'free', 'percent')
+        assert usage.total > 0, usage
+        assert usage.used > 0, usage
+        assert usage.free > 0, usage
+        assert usage.total > usage.used, usage
+        assert usage.total > usage.free, usage
+        assert 0 <= usage.percent <= 100, usage.percent
+
+        shutil_usage = shutil.disk_usage(os.getcwd())
+        tolerance = 5 * 1024 * 1024  # 5MB
+        assert usage.total == shutil_usage.total
+        assert abs(usage.free - shutil_usage.free) < tolerance
+        if not MACOS_12PLUS:
+            # see https://github.com/giampaolo/psutil/issues/2147
+            assert abs(usage.used - shutil_usage.used) < tolerance
+
+        # if path does not exist FileNotFoundError is expected across
+        # all platforms
+        fname = self.get_testfn()
+        with pytest.raises(FileNotFoundError):
+            psutil.disk_usage(fname)
+
+        # we should also be able to use a file path
+        psutil.disk_usage(__file__)
+
+    @skipif(not ASCII_FS, reason="not an ASCII fs")
+    def test_disk_usage_unicode(self):
+        # See: https://github.com/giampaolo/psutil/issues/416
+        with pytest.raises(UnicodeEncodeError):
+            psutil.disk_usage(UNICODE_SUFFIX)
+
+    def test_disk_usage_bytes(self):
+        psutil.disk_usage(b'.')
+
+    def test_disk_partitions(self):
+        def check_ntuple(nt):
+            assert isinstance(nt.device, str)
+            assert isinstance(nt.mountpoint, str)
+            assert isinstance(nt.fstype, str)
+            assert isinstance(nt.opts, str)
+
+        # all = False
+        ls = psutil.disk_partitions(all=False)
+        assert ls
+        for disk in ls:
+            check_ntuple(disk)
+            if WINDOWS and 'cdrom' in disk.opts:
+                continue
+            if not POSIX:
+                assert os.path.exists(disk.device), disk
+            else:
+                # we cannot make any assumption about this, see:
+                # http://goo.gl/p9c43
+                disk.device  # noqa: B018
+            # on modern systems mount points can also be files
+            assert os.path.exists(disk.mountpoint), disk
+            assert disk.fstype, disk
+
+        # all = True
+        ls = psutil.disk_partitions(all=True)
+        assert ls
+        for disk in psutil.disk_partitions(all=True):
+            check_ntuple(disk)
+            if not WINDOWS and disk.mountpoint:
+                try:
+                    os.stat(disk.mountpoint)
+                except OSError as err:
+                    if GITHUB_ACTIONS and MACOS and err.errno == errno.EIO:
+                        continue
+                    # http://mail.python.org/pipermail/python-dev/2012-June/120787.html
+                    if err.errno not in {errno.EPERM, errno.EACCES}:
+                        raise
+                else:
+                    assert os.path.exists(disk.mountpoint), disk
+
+        # ---
+
+        def find_mount_point(path):
+            path = os.path.abspath(path)
+            while not os.path.ismount(path):
+                path = os.path.dirname(path)
+            return path.lower()
+
+        mount = find_mount_point(__file__)
+        mounts = [
+            x.mountpoint.lower()
+            for x in psutil.disk_partitions(all=True)
+            if x.mountpoint
+        ]
+        assert mount in mounts
+
+    @skipif(
+        LINUX and not os.path.exists('/proc/diskstats'),
+        reason="/proc/diskstats not available on this linux version",
+    )
+    @skipif(
+        CI_TESTING and not psutil.disk_io_counters(), reason="unreliable on CI"
+    )  # no visible disks
+    def test_disk_io_counters(self):
+        def check_ntuple(nt):
+            assert nt[0] == nt.read_count
+            assert nt[1] == nt.write_count
+            assert nt[2] == nt.read_bytes
+            assert nt[3] == nt.write_bytes
+            if not (OPENBSD or NETBSD):
+                assert nt[4] == nt.read_time
+                assert nt[5] == nt.write_time
+                if LINUX:
+                    assert nt[6] == nt.read_merged_count
+                    assert nt[7] == nt.write_merged_count
+                    assert nt[8] == nt.busy_time
+                elif FREEBSD:
+                    assert nt[6] == nt.busy_time
+            for name in nt._fields:
+                assert getattr(nt, name) >= 0, nt
+
+        ret = psutil.disk_io_counters(perdisk=False)
+        assert ret is not None, "no disks on this system?"
+        check_ntuple(ret)
+        ret = psutil.disk_io_counters(perdisk=True)
+        # make sure there are no duplicates
+        assert len(ret) == len(set(ret))
+        for key in ret:
+            assert key, key
+            check_ntuple(ret[key])
+
+    def test_disk_io_counters_no_disks(self):
+        # Emulate a case where no disks are installed, see:
+        # https://github.com/giampaolo/psutil/issues/1062
+        with mock.patch(
+            'psutil._psplatform.disk_io_counters', return_value={}
+        ) as m:
+            assert psutil.disk_io_counters(perdisk=False) is None
+            assert psutil.disk_io_counters(perdisk=True) == {}
+            assert m.called
+
+
+class TestNetAPIs(PsutilTestCase):
+    @skipif(not HAS_NET_IO_COUNTERS, reason="not supported")
+    def test_net_io_counters(self):
+        def check_ntuple(nt):
+            assert nt[0] == nt.bytes_sent
+            assert nt[1] == nt.bytes_recv
+            assert nt[2] == nt.packets_sent
+            assert nt[3] == nt.packets_recv
+            assert nt[4] == nt.errin
+            assert nt[5] == nt.errout
+            assert nt[6] == nt.dropin
+            assert nt[7] == nt.dropout
+            assert nt.bytes_sent >= 0, nt
+            assert nt.bytes_recv >= 0, nt
+            assert nt.packets_sent >= 0, nt
+            assert nt.packets_recv >= 0, nt
+            assert nt.errin >= 0, nt
+            assert nt.errout >= 0, nt
+            assert nt.dropin >= 0, nt
+            assert nt.dropout >= 0, nt
+
+        ret = psutil.net_io_counters(pernic=False)
+        check_ntuple(ret)
+        ret = psutil.net_io_counters(pernic=True)
+        assert ret != []
+        for key in ret:
+            assert key
+            assert isinstance(key, str)
+            check_ntuple(ret[key])
+
+    @skipif(not HAS_NET_IO_COUNTERS, reason="not supported")
+    def test_net_io_counters_no_nics(self):
+        # Emulate a case where no NICs are installed, see:
+        # https://github.com/giampaolo/psutil/issues/1062
+        with mock.patch(
+            'psutil._psplatform.net_io_counters', return_value={}
+        ) as m:
+            assert psutil.net_io_counters(pernic=False) is None
+            assert psutil.net_io_counters(pernic=True) == {}
+            assert m.called
+
+    def test_net_if_addrs(self):
+        nics = psutil.net_if_addrs()
+        assert nics, nics
+
+        nic_stats = psutil.net_if_stats()
+
+        # Not reliable on all platforms (net_if_addrs() reports more
+        # interfaces).
+        # assert sorted(nics.keys()) == sorted(
+        #     psutil.net_io_counters(pernic=True).keys()
+        # )
+
+        families = {
+            socket.AF_INET,
+            socket.AF_INET6,
+            socket.AF_UNSPEC,
+            psutil.AF_LINK,
+        }
+        for nic, addrs in nics.items():
+            assert isinstance(nic, str)
+            assert len(set(addrs)) == len(addrs)
+            for addr in addrs:
+                assert isinstance(addr.family, int)
+                assert isinstance(addr.address, (str, type(None)))
+                if addr.address is None:  # virtual NIC
+                    assert addr.family == socket.AF_UNSPEC
+                assert isinstance(addr.netmask, (str, type(None)))
+                assert isinstance(addr.broadcast, (str, type(None)))
+                assert addr.family in families
+                assert isinstance(addr.family, enum.IntEnum)
+                if nic_stats[nic].isup:
+                    # Do not test binding to addresses of interfaces
+                    # that are down
+                    if addr.family == socket.AF_INET:
+                        with socket.socket(addr.family) as s:
+                            s.bind((addr.address, 0))
+                    elif addr.family == socket.AF_INET6:
+                        info = socket.getaddrinfo(
+                            addr.address,
+                            0,
+                            socket.AF_INET6,
+                            socket.SOCK_STREAM,
+                            0,
+                            socket.AI_PASSIVE,
+                        )[0]
+                        af, socktype, proto, _canonname, sa = info
+                        with socket.socket(af, socktype, proto) as s:
+                            s.bind(sa)
+                for ip in (
+                    addr.address,
+                    addr.netmask,
+                    addr.broadcast,
+                    addr.ptp,
+                ):
+                    if ip is not None:
+                        # TODO: skip AF_INET6 for now because I get:
+                        # AddressValueError: Only hex digits permitted in
+                        # u'c6f3%lxcbr0' in u'fe80::c8e0:fff:fe54:c6f3%lxcbr0'
+                        if addr.family != socket.AF_INET6:
+                            check_net_address(ip, addr.family)
+                # broadcast and ptp addresses are mutually exclusive
+                if addr.broadcast:
+                    assert addr.ptp is None
+                elif addr.ptp:
+                    assert addr.broadcast is None
+
+                # check broadcast address
+                if (
+                    addr.broadcast
+                    and addr.netmask
+                    and addr.family in {socket.AF_INET, socket.AF_INET6}
+                ):
+                    assert addr.broadcast == broadcast_addr(addr)
+
+        if BSD or MACOS or SUNOS:
+            if hasattr(socket, "AF_LINK"):
+                assert psutil.AF_LINK == socket.AF_LINK
+        elif LINUX:
+            assert psutil.AF_LINK == socket.AF_PACKET
+        elif WINDOWS:
+            assert psutil.AF_LINK == -1
+
+    def test_net_if_addrs_mac_null_bytes(self):
+        # Simulate that the underlying C function returns an incomplete
+        # MAC address. psutil is supposed to fill it with null bytes.
+        # https://github.com/giampaolo/psutil/issues/786
+        if POSIX:
+            ret = [('em1', psutil.AF_LINK, '06:3d:29', None, None, None)]
+        else:
+            ret = [('em1', -1, '06-3d-29', None, None, None)]
+        with mock.patch(
+            'psutil._psplatform.net_if_addrs', return_value=ret
+        ) as m:
+            addr = psutil.net_if_addrs()['em1'][0]
+            assert m.called
+            if POSIX:
+                assert addr.address == '06:3d:29:00:00:00'
+            else:
+                assert addr.address == '06-3d-29-00-00-00'
+
+    def test_net_if_stats(self):
+        nics = psutil.net_if_stats()
+        assert nics, nics
+        all_duplexes = (
+            psutil.NIC_DUPLEX_FULL,
+            psutil.NIC_DUPLEX_HALF,
+            psutil.NIC_DUPLEX_UNKNOWN,
+        )
+        for name, stats in nics.items():
+            assert isinstance(name, str)
+            isup, duplex, speed, mtu, flags = stats
+            assert isinstance(isup, bool)
+            assert duplex in all_duplexes
+            assert duplex in all_duplexes
+            assert speed >= 0
+            assert mtu >= 0
+            assert isinstance(flags, str)
+
+    @skipif(
+        not (LINUX or BSD or MACOS), reason="LINUX or BSD or MACOS specific"
+    )
+    def test_net_if_stats_enodev(self):
+        # See: https://github.com/giampaolo/psutil/issues/1279
+        with mock.patch.object(
+            _psutil,
+            'net_if_mtu',
+            side_effect=OSError(errno.ENODEV, ""),
+        ) as m:
+            ret = psutil.net_if_stats()
+            assert ret == {}
+            assert m.called
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_nic_names(self):
+        stdlib_names = {name for _, name in socket.if_nameindex()}
+        assert stdlib_names == set(psutil.net_io_counters(pernic=True).keys())
+        assert stdlib_names == set(psutil.net_if_addrs().keys())
+        assert stdlib_names == set(psutil.net_if_stats().keys())
+
+
+class TestSensorsAPIs(PsutilTestCase):
+    @skipif(not HAS_SENSORS_TEMPERATURES, reason="not supported")
+    def test_sensors_temperatures(self):
+        temps = psutil.sensors_temperatures()
+        for name, entries in temps.items():
+            assert isinstance(name, str)
+            for entry in entries:
+                assert isinstance(entry.label, str)
+                if entry.current is not None:
+                    assert entry.current >= 0
+                if entry.high is not None:
+                    assert entry.high >= 0
+                if entry.critical is not None:
+                    assert entry.critical >= 0
+
+    @skipif(not HAS_SENSORS_TEMPERATURES, reason="not supported")
+    def test_sensors_temperatures_fahreneit(self):
+        d = {'coretemp': [('label', 50.0, 60.0, 70.0)]}
+        with mock.patch(
+            "psutil._psplatform.sensors_temperatures", return_value=d
+        ) as m:
+            temps = psutil.sensors_temperatures(fahrenheit=True)['coretemp'][0]
+            assert m.called
+            assert temps.current == 122.0
+            assert temps.high == 140.0
+            assert temps.critical == 158.0
+
+    @skipif(not HAS_SENSORS_BATTERY, reason="not supported")
+    @skipif(not HAS_BATTERY, reason="no battery")
+    def test_sensors_battery(self):
+        ret = psutil.sensors_battery()
+        assert ret.percent >= 0
+        assert ret.percent <= 100
+        if ret.secsleft not in {
+            psutil.POWER_TIME_UNKNOWN,
+            psutil.POWER_TIME_UNLIMITED,
+        }:
+            assert ret.secsleft >= 0
+        elif ret.secsleft == psutil.POWER_TIME_UNLIMITED:
+            assert ret.power_plugged
+        assert isinstance(ret.power_plugged, bool)
+
+    @skipif(not HAS_SENSORS_FANS, reason="not supported")
+    def test_sensors_fans(self):
+        fans = psutil.sensors_fans()
+        for name, entries in fans.items():
+            assert isinstance(name, str)
+            for entry in entries:
+                assert isinstance(entry.label, str)
+                assert isinstance(entry.current, int)
+                assert entry.current >= 0
diff --git a/tests/test_testutils.py b/tests/test_testutils.py
new file mode 100755
index 0000000000..b0a36ca7d9
--- /dev/null
+++ b/tests/test_testutils.py
@@ -0,0 +1,448 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Tests for testing utils."""
+
+import collections
+import errno
+import os
+import socket
+import stat
+import subprocess
+from unittest import mock
+
+import psutil
+import tests
+from psutil import FREEBSD
+from psutil import NETBSD
+from psutil import POSIX
+from psutil._common import open_binary
+from psutil._common import open_text
+from psutil._common import supports_ipv6
+
+from . import HAS_NET_CONNECTIONS_UNIX
+from . import PYTHON_EXE
+from . import PYTHON_EXE_ENV
+from . import PsutilTestCase
+from . import bind_socket
+from . import bind_unix_socket
+from . import call_until
+from . import chdir
+from . import create_sockets
+from . import filter_proc_net_connections
+from . import get_free_port
+from . import is_namedtuple
+from . import process_namespace
+from . import pytest
+from . import reap_children
+from . import requires_cli
+from . import retry
+from . import safe_mkdir
+from . import safe_rmpath
+from . import serial
+from . import sh
+from . import skipif
+from . import system_namespace
+from . import tcp_socketpair
+from . import terminate
+from . import unix_socketpair
+from . import wait_for_file
+from . import wait_for_file_subproc
+from . import wait_for_pid
+
+# ===================================================================
+# --- Unit tests for test utilities.
+# ===================================================================
+
+
+class TestRetryDecorator(PsutilTestCase):
+    @mock.patch('time.sleep')
+    def test_retry_success(self, sleep):
+        # Fail 3 times out of 5; make sure the decorated fun returns.
+
+        @retry(retries=5, interval=1, logfun=None)
+        def foo():
+            while queue:
+                queue.pop()
+                1 / 0  # noqa: B018
+            return 1
+
+        queue = list(range(3))
+        assert foo() == 1
+        assert sleep.call_count == 3
+
+    @mock.patch('time.sleep')
+    def test_retry_failure(self, sleep):
+        # Fail 6 times out of 5; th function is supposed to raise exc.
+        @retry(retries=5, interval=1, logfun=None)
+        def foo():
+            while queue:
+                queue.pop()
+                1 / 0  # noqa: B018
+            return 1
+
+        queue = list(range(6))
+        with pytest.raises(ZeroDivisionError):
+            foo()
+        assert sleep.call_count == 5
+
+    @mock.patch('time.sleep')
+    def test_exception_arg(self, sleep):
+        @retry(exception=ValueError, interval=1)
+        def foo():
+            raise TypeError
+
+        with pytest.raises(TypeError):
+            foo()
+        assert sleep.call_count == 0
+
+    @mock.patch('time.sleep')
+    def test_no_interval_arg(self, sleep):
+        # if interval is not specified sleep is not supposed to be called
+
+        @retry(retries=5, interval=None, logfun=None)
+        def foo():
+            1 / 0  # noqa: B018
+
+        with pytest.raises(ZeroDivisionError):
+            foo()
+        assert sleep.call_count == 0
+
+    @mock.patch('time.sleep')
+    def test_retries_arg(self, sleep):
+        @retry(retries=5, interval=1, logfun=None)
+        def foo():
+            1 / 0  # noqa: B018
+
+        with pytest.raises(ZeroDivisionError):
+            foo()
+        assert sleep.call_count == 5
+
+    @mock.patch('time.sleep')
+    def test_retries_and_timeout_args(self, sleep):
+        with pytest.raises(ValueError):
+            retry(retries=5, timeout=1)
+
+
+class TestSyncTestUtils(PsutilTestCase):
+    def test_wait_for_pid(self):
+        wait_for_pid(os.getpid())
+        nopid = max(psutil.pids()) + 99999
+        with mock.patch('tests.retry.__iter__', return_value=iter([0])):
+            with pytest.raises(psutil.NoSuchProcess):
+                wait_for_pid(nopid)
+
+    def test_wait_for_file(self):
+        testfn = self.get_testfn()
+        with open(testfn, 'w') as f:
+            f.write('foo')
+        wait_for_file(testfn)
+        assert not os.path.exists(testfn)
+
+    def test_wait_for_file_empty(self):
+        testfn = self.get_testfn()
+        with open(testfn, 'w'):
+            pass
+        wait_for_file(testfn, empty=True)
+        assert not os.path.exists(testfn)
+
+    def test_wait_for_file_no_file(self):
+        testfn = self.get_testfn()
+        with mock.patch('tests.retry.__iter__', return_value=iter([0])):
+            with pytest.raises(OSError):
+                wait_for_file(testfn)
+
+    def test_wait_for_file_no_delete(self):
+        testfn = self.get_testfn()
+        with open(testfn, 'w') as f:
+            f.write('foo')
+        wait_for_file(testfn, delete=False)
+        assert os.path.exists(testfn)
+
+    def test_wait_for_file_subproc(self):
+        testfn = self.get_testfn()
+        with open(testfn, 'w') as f:
+            f.write('foo')
+        sproc = self.spawn_subproc()
+        assert wait_for_file_subproc(testfn, sproc) == b"foo"
+
+    def test_wait_for_file_subproc_dead(self):
+        testfn = self.get_testfn()
+        sproc = subprocess.Popen(
+            [
+                PYTHON_EXE,
+                "-c",
+                "import sys; sys.exit(sys.stderr.write('foo'))",
+            ],
+            stderr=subprocess.PIPE,
+        )
+        self.addCleanup(terminate, sproc)
+        sproc.wait()
+        with mock.patch('tests.retry.__iter__', return_value=iter([0])):
+            with pytest.raises(
+                RuntimeError, match=r"(?s)died \(exit 3\).*foo"
+            ):
+                wait_for_file_subproc(testfn, sproc)
+
+    def test_call_until(self):
+        call_until(lambda: 1)
+        # TODO: test for timeout
+
+
+class TestFSTestUtils(PsutilTestCase):
+    def test_open_text(self):
+        with open_text(__file__) as f:
+            assert f.mode == 'r'
+
+    def test_open_binary(self):
+        with open_binary(__file__) as f:
+            assert f.mode == 'rb'
+
+    def test_safe_mkdir(self):
+        testfn = self.get_testfn()
+        safe_mkdir(testfn)
+        assert os.path.isdir(testfn)
+        safe_mkdir(testfn)
+        assert os.path.isdir(testfn)
+
+    def test_safe_rmpath(self):
+        # test file is removed
+        testfn = self.get_testfn()
+        open(testfn, 'w').close()
+        safe_rmpath(testfn)
+        assert not os.path.exists(testfn)
+        # test no exception if path does not exist
+        safe_rmpath(testfn)
+        # test dir is removed
+        os.mkdir(testfn)
+        safe_rmpath(testfn)
+        assert not os.path.exists(testfn)
+        # test other exceptions are raised
+        with mock.patch(
+            'tests.os.stat', side_effect=OSError(errno.EINVAL, "")
+        ) as m:
+            with pytest.raises(OSError):
+                safe_rmpath(testfn)
+            assert m.called
+
+    def test_chdir(self):
+        testfn = self.get_testfn()
+        base = os.getcwd()
+        os.mkdir(testfn)
+        with chdir(testfn):
+            assert os.getcwd() == os.path.join(base, testfn)
+        assert os.getcwd() == base
+
+
+class TestPythonExeEnv(PsutilTestCase):
+    def test_subprocess_imports_our_psutil(self):
+        # A psutil installed elsewhere (typically site-packages) must
+        # not win over the one we're testing. Reproduce the sys.path
+        # order of that situation: the decoy comes after PYTHONPATH,
+        # and the cwd has no psutil of its own.
+        cwd = self.get_testfn()
+        decoy = os.path.join(cwd, "decoy")
+        os.makedirs(os.path.join(decoy, "psutil"))
+        with open(os.path.join(decoy, "psutil", "__init__.py"), "w"):
+            pass
+
+        env = PYTHON_EXE_ENV.copy()
+        env["PYTHONPATH"] = os.pathsep.join(
+            filter(None, [env.get("PYTHONPATH"), decoy])
+        )
+        cmd = [PYTHON_EXE, "-c", "import psutil; print(psutil.__file__)"]
+        out = sh(cmd, env=env, cwd=cwd)
+
+        got = os.path.normcase(os.path.realpath(out))
+        expected = os.path.normcase(os.path.realpath(psutil.__file__))
+        assert got == expected
+
+
+class TestProcessUtils(PsutilTestCase):
+    def test_reap_children(self):
+        subp = self.spawn_subproc()
+        p = psutil.Process(subp.pid)
+        assert p.is_running()
+        reap_children()
+        assert not p.is_running()
+        assert not tests._pids_started
+        assert not tests._subprocesses_started
+
+    def test_spawn_children_pair(self):
+        child, grandchild = self.spawn_children_pair()
+        assert child.pid != grandchild.pid
+        assert child.is_running()
+        assert grandchild.is_running()
+        children = psutil.Process().children()
+        assert children == [child]
+        children = psutil.Process().children(recursive=True)
+        assert len(children) == 2
+        assert child in children
+        assert grandchild in children
+        assert child.ppid() == os.getpid()
+        assert grandchild.ppid() == child.pid
+
+        terminate(child)
+        assert not child.is_running()
+        assert grandchild.is_running()
+
+        terminate(grandchild)
+        assert not grandchild.is_running()
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_spawn_zombie(self):
+        _parent, zombie = self.spawn_zombie()
+        assert zombie.status() == psutil.STATUS_ZOMBIE
+
+    def test_terminate(self):
+        # by subprocess.Popen
+        p = self.spawn_subproc()
+        terminate(p)
+        self.assert_pid_gone(p.pid)
+        terminate(p)
+        # by psutil.Process
+        p = psutil.Process(self.spawn_subproc().pid)
+        terminate(p)
+        self.assert_pid_gone(p.pid)
+        terminate(p)
+        # by psutil.Popen
+        cmd = [
+            PYTHON_EXE,
+            "-c",
+            "import time; [time.sleep(0.1) for x in range(100)];",
+        ]
+        p = psutil.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            env=PYTHON_EXE_ENV,
+        )
+        terminate(p)
+        self.assert_pid_gone(p.pid)
+        terminate(p)
+        # by PID
+        pid = self.spawn_subproc().pid
+        terminate(pid)
+        self.assert_pid_gone(p.pid)
+        terminate(pid)
+        # zombie
+        if POSIX:
+            parent, zombie = self.spawn_zombie()
+            terminate(parent)
+            terminate(zombie)
+            self.assert_pid_gone(parent.pid)
+            self.assert_pid_gone(zombie.pid)
+
+
+@serial
+class TestNetUtils(PsutilTestCase):
+    def bind_socket(self):
+        port = get_free_port()
+        with bind_socket(addr=('', port)) as s:
+            assert s.getsockname()[1] == port
+
+    @skipif(not POSIX, reason="POSIX only")
+    def test_bind_unix_socket(self):
+        name = self.get_testfn()
+        with bind_unix_socket(name) as sock:
+            assert sock.family == socket.AF_UNIX
+            assert sock.type == socket.SOCK_STREAM
+            assert sock.getsockname() == name
+            assert os.path.exists(name)
+            assert stat.S_ISSOCK(os.stat(name).st_mode)
+        # UDP
+        name = self.get_testfn()
+        with bind_unix_socket(name, type=socket.SOCK_DGRAM) as sock:
+            assert sock.type == socket.SOCK_DGRAM
+
+    def test_tcp_socketpair(self):
+        addr = ("127.0.0.1", get_free_port())
+        server, client = tcp_socketpair(socket.AF_INET, addr=addr)
+        with server, client:
+            # Ensure they are connected and the positions are correct.
+            assert server.getsockname() == addr
+            assert client.getpeername() == addr
+            assert client.getsockname() != addr
+
+    @skipif(not POSIX, reason="POSIX only")
+    @skipif(
+        NETBSD or FREEBSD, reason="/var/run/log UNIX socket opened by default"
+    )
+    @skipif(not HAS_NET_CONNECTIONS_UNIX, reason="can't list UNIX sockets")
+    def test_unix_socketpair(self):
+        p = psutil.Process()
+        num_fds = p.num_fds()
+        assert not filter_proc_net_connections(p.net_connections(kind='unix'))
+        name = self.get_testfn()
+        server, client = unix_socketpair(name)
+        try:
+            assert os.path.exists(name)
+            assert stat.S_ISSOCK(os.stat(name).st_mode)
+            assert p.num_fds() - num_fds == 2
+            assert (
+                len(
+                    filter_proc_net_connections(p.net_connections(kind='unix'))
+                )
+                == 2
+            )
+            assert server.getsockname() == name
+            assert client.getpeername() == name
+        finally:
+            client.close()
+            server.close()
+
+    def test_create_sockets(self):
+        with create_sockets() as socks:
+            fams = collections.defaultdict(int)
+            types = collections.defaultdict(int)
+            for s in socks:
+                fams[s.family] += 1
+                # work around http://bugs.python.org/issue30204
+                types[s.getsockopt(socket.SOL_SOCKET, socket.SO_TYPE)] += 1
+            assert fams[socket.AF_INET] >= 2
+            if supports_ipv6():
+                assert fams[socket.AF_INET6] >= 2
+            if POSIX and HAS_NET_CONNECTIONS_UNIX:
+                assert fams[socket.AF_UNIX] >= 2
+            assert types[socket.SOCK_STREAM] >= 2
+            assert types[socket.SOCK_DGRAM] >= 2
+
+
+class TestTestingUtils(PsutilTestCase):
+    def test_process_namespace(self):
+        p = psutil.Process()
+        ns = process_namespace(p)
+        ns.test()
+        fun = next(x for x in ns.iter(ns.getters) if x[1] == 'ppid')[0]
+        assert fun() == p.ppid()
+
+    def test_system_namespace(self):
+        ns = system_namespace()
+        fun = next(x for x in ns.iter(ns.getters) if x[1] == 'net_if_addrs')[0]
+        assert fun() == psutil.net_if_addrs()
+
+    def test_requires_cli(self):
+        @requires_cli(os.path.basename(PYTHON_EXE))
+        def fun1():
+            return 42
+
+        path = os.path.dirname(PYTHON_EXE)
+        with mock.patch.dict(os.environ, {"PATH": path}):
+            assert fun1() == 42
+
+        # not available
+        @requires_cli("does-not-exist")
+        def fun2():
+            1 / 0  # noqa: B018
+
+        with pytest.raises(pytest.skip.Exception):
+            fun2()
+
+
+class TestOtherUtils(PsutilTestCase):
+    def test_is_namedtuple(self):
+        assert is_namedtuple(collections.namedtuple('foo', 'a b c')(1, 2, 3))
+        assert not is_namedtuple(tuple())
diff --git a/tests/test_type_hints.py b/tests/test_type_hints.py
new file mode 100755
index 0000000000..f4eef41f0b
--- /dev/null
+++ b/tests/test_type_hints.py
@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+from __future__ import annotations
+
+import ast
+import enum
+import functools
+import types
+
+import pytest
+
+import psutil
+import psutil._enums
+
+from . import PsutilTestCase
+from . import check_fun_type_hints
+from . import check_ntuple_type_hints
+from . import is_namedtuple
+from . import process_namespace
+from . import skipif
+from . import system_namespace
+
+
+class TypeHintTestCase(PsutilTestCase):
+    pass
+
+
+# ===================================================================
+# --- named tuples type hints
+# ===================================================================
+
+
+class TestTypeHintsNtuples(TypeHintTestCase):
+    """Check that named tuple field values match the type annotations
+    defined in psutil/_ntuples.py.
+    """
+
+    def check_result(self, ret):
+        if is_namedtuple(ret):
+            check_ntuple_type_hints(ret)
+        elif isinstance(ret, list):
+            for item in ret:
+                if is_namedtuple(item):
+                    check_ntuple_type_hints(item)
+
+    def test_system_ntuple_types(self):
+        for fun, name in system_namespace.iter(system_namespace.getters):
+            try:
+                ret = fun()
+            except psutil.Error:
+                continue
+            with self.subTest(name=name, fun=str(fun)):
+                if isinstance(ret, dict):
+                    for v in ret.values():
+                        if isinstance(v, list):
+                            for item in v:
+                                self.check_result(item)
+                        else:
+                            self.check_result(v)
+                else:
+                    self.check_result(ret)
+
+    def test_process_ntuple_types(self):
+        p = psutil.Process()
+        ns = process_namespace(p)
+        for fun, name in ns.iter(ns.getters):
+            with self.subTest(name=name, fun=str(fun)):
+                try:
+                    ret = fun()
+                except psutil.Error:
+                    continue
+                self.check_result(ret)
+
+
+# ===================================================================
+# --- returned type hints
+# ===================================================================
+
+
+class TestTypeHintsReturned(TypeHintTestCase):
+    """Check that annotated return types in psutil/__init__.py match
+    the actual values returned at runtime.
+    """
+
+    def check(self, fun, name):
+        try:
+            ret = fun()
+        except psutil.Error:
+            return
+        check_fun_type_hints(fun, ret)
+
+    def test_system_return_types(self):
+        for fun, name in system_namespace.iter(system_namespace.getters):
+            with self.subTest(name=name, fun=str(fun)):
+                self.check(fun, name)
+
+    def test_process_return_types(self):
+        p = psutil.Process()
+        ns = process_namespace(p)
+        for fun, name in ns.iter(ns.getters):
+            with self.subTest(name=name, fun=str(fun)):
+                self.check(fun, name)
+
+
+# ===================================================================
+# --- enum constants type hints
+# ===================================================================
+
+
+class TestEnumDeclarations(TypeHintTestCase):
+    """psutil/__init__.py injects the enum members into the module
+    namespace at run time. Type checkers can't see that, so they rely
+    on the declarations in the `if TYPE_CHECKING` block. Make sure
+    those don't fall behind.
+    """
+
+    @staticmethod
+    def get_declared_names():
+        with open(psutil.__file__, encoding="utf8") as f:
+            tree = ast.parse(f.read())
+        names = {}
+        for node in tree.body:
+            if not isinstance(node, ast.If):
+                continue
+            if getattr(node.test, "id", None) != "_TYPE_CHECKING":
+                continue
+            for child in node.body:
+                if isinstance(child, ast.AnnAssign):
+                    names[child.target.id] = child.annotation.id
+        return names
+
+    @staticmethod
+    def get_enum_classes():
+        return [
+            obj
+            for obj in vars(psutil._enums).values()
+            if isinstance(obj, type)
+            and issubclass(obj, enum.Enum)
+            and obj.__members__
+        ]
+
+    def test_members_are_declared(self):
+        declared = self.get_declared_names()
+        classes = self.get_enum_classes()
+        assert classes
+        for cls in classes:
+            for name in cls.__members__:
+                with self.subTest(name=name, cls=cls.__name__):
+                    assert declared.get(name) == cls.__name__
+
+
+# =====================================================================
+# --- Tests for check_ntuple_type_hints() test utility fun
+# =====================================================================
+
+
+class TestCheckNtupleTypeHints(TypeHintTestCase):
+    def test_not_namedtuple(self):
+        # plain tuple is rejected
+        with pytest.raises(AssertionError):
+            check_ntuple_type_hints((1, 2, 3))
+
+    def test_ok(self):
+        # addr(ip: str, port: int) - correct types
+        from psutil._ntuples import addr
+
+        check_ntuple_type_hints(addr('127.0.0.1', 80))
+
+    def test_wrong_type(self):
+        # ip should be str, passing int instead
+        from psutil._ntuples import addr
+
+        with pytest.raises(AssertionError):
+            check_ntuple_type_hints(addr(127, 80))
+
+    @skipif(not hasattr(types, "UnionType"), reason="Python 3.10+ only")
+    def test_union_with_none(self):
+        # suser has terminal: str | None and host: str | None
+        from psutil._ntuples import suser
+
+        check_ntuple_type_hints(suser('user', None, None, 1.0, None))
+        check_ntuple_type_hints(suser('user', '/dev/tty1', 'host', 1.0, 1))
+        with pytest.raises(AssertionError):
+            check_ntuple_type_hints(suser(1, None, None, 1.0, None))
+
+    def test_intenum_broadening(self):
+        # NicDuplex is an IntEnum; check_ntuple_type_hints broadens it to int
+        from psutil._ntuples import snicstats
+
+        nt = snicstats(True, psutil.NIC_DUPLEX_FULL, 1000, 1500, '')
+        check_ntuple_type_hints(nt)
+
+
+# =====================================================================
+# --- Tests for check_fun_type_hints() test utility fun
+# =====================================================================
+
+
+class TestCheckFunTypeHints(TypeHintTestCase):
+
+    @skipif(not hasattr(types, "UnionType"), reason="Python 3.10+ only")
+    def test_no_annotation(self):
+        def foo():
+            return 1
+
+        with pytest.raises(ValueError, match="no type hints defined"):
+            check_fun_type_hints(foo, 1)
+
+    def test_float(self):
+        def foo() -> float:
+            return 1.0
+
+        check_fun_type_hints(foo, 1.0)
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(foo, "str")
+
+    def test_bool(self):
+        def foo() -> bool:
+            return True
+
+        check_fun_type_hints(foo, True)
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(foo, "str")
+
+    @skipif(not hasattr(types, "UnionType"), reason="Python 3.10+ only")
+    def test_list(self):
+        def foo() -> list[int]:
+            return [1]
+
+        check_fun_type_hints(foo, foo())
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(foo, "str")
+
+    @skipif(not hasattr(types, "UnionType"), reason="Python 3.10+ only")
+    def test_list_container(self):
+        def foo() -> list[str]:
+            pass
+
+        check_fun_type_hints(foo, ["a", "b"])
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(foo, ["a", 1])
+
+    @skipif(not hasattr(types, "UnionType"), reason="Python 3.10+ only")
+    def test_dict(self):
+        def foo() -> dict[str, int]:
+            return {'a': 1}
+
+        check_fun_type_hints(foo, foo())
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(foo, "str")
+
+    @skipif(not hasattr(types, "UnionType"), reason="Python 3.10+ only")
+    def test_dict_container(self):
+        def foo() -> dict[str, str]:
+            pass
+
+        check_fun_type_hints(foo, {"a": "a", "b": "b"})
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(foo, {"a": "a", "1": 1})
+
+    def test_namedtuple(self):
+        from psutil._ntuples import addr
+
+        def foo() -> addr:
+            return addr('127.0.0.1', 80)
+
+        check_fun_type_hints(foo, addr('127.0.0.1', 80))
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(foo, "str")
+
+    @skipif(not hasattr(types, "UnionType"), reason="Python 3.10+ only")
+    def test_union_with_none(self):
+        def foo() -> int | None:
+            return 1
+
+        check_fun_type_hints(foo, 1)
+        check_fun_type_hints(foo, None)
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(foo, "str")
+
+    @skipif(not hasattr(types, "UnionType"), reason="Python 3.10+ only")
+    def test_union_or_dict_or_none(self):
+        def foo() -> int | dict[str, int] | None:
+            return 1
+
+        check_fun_type_hints(foo, 1)
+        check_fun_type_hints(foo, {'a': 1})
+        check_fun_type_hints(foo, None)
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(foo, "str")
+
+    def test_generator(self):
+        from typing import Generator
+
+        def foo() -> Generator[int, None, None]:
+            yield 1
+
+        check_fun_type_hints(foo, foo())
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(foo, "str")
+
+    def test_partial(self):
+        def foo(x) -> int:
+            return x
+
+        fun = functools.partial(foo, 1)
+        check_fun_type_hints(fun, 1)
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(fun, "str")
+
+    def test_bound_method(self):
+        class MyClass:
+            def foo(self) -> int:
+                return 1
+
+        obj = MyClass()
+        check_fun_type_hints(obj.foo, 1)
+        with pytest.raises(AssertionError):
+            check_fun_type_hints(obj.foo, "str")
diff --git a/tests/test_unicode.py b/tests/test_unicode.py
new file mode 100755
index 0000000000..af906ec7ab
--- /dev/null
+++ b/tests/test_unicode.py
@@ -0,0 +1,312 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Notes about unicode handling in psutil
+======================================.
+
+Starting from version 5.3.0 psutil adds unicode support, see:
+https://github.com/giampaolo/psutil/issues/1040
+The notes below apply to *any* API returning a string such as
+process exe(), cwd() or username():
+
+* all strings are encoded by using the OS filesystem encoding
+  (sys.getfilesystemencoding()) which varies depending on the platform
+  (e.g. "UTF-8" on macOS, "mbcs" on Win)
+* no API call is supposed to crash with UnicodeDecodeError
+* instead, in case of badly encoded data returned by the OS, the
+  following error handlers are used to replace the corrupted characters in
+  the string:
+    * sys.getfilesystemencodeerrors() or "surrogatescape" on POSIX and
+      "replace" on Windows.
+
+For a detailed explanation of how psutil handles unicode see #1040.
+
+Tests
+=====
+
+List of APIs returning or dealing with a string:
+('not tested' means they are not tested to deal with non-ASCII strings):
+
+* Process.cmdline()
+* Process.cwd()
+* Process.environ()
+* Process.exe()
+* Process.memory_maps()
+* Process.name()
+* Process.net_connections('unix')
+* Process.open_files()
+* Process.username()             (not tested)
+
+* disk_io_counters()             (not tested)
+* disk_partitions()              (not tested)
+* disk_usage(str)
+* net_connections('unix')
+* net_if_addrs()                 (not tested)
+* net_if_stats()                 (not tested)
+* net_io_counters()              (not tested)
+* sensors_fans()                 (not tested)
+* sensors_temperatures()         (not tested)
+* users()                        (not tested)
+
+* WindowsService.binpath()       (not tested)
+* WindowsService.description()   (not tested)
+* WindowsService.display_name()  (not tested)
+* WindowsService.name()          (not tested)
+* WindowsService.status()        (not tested)
+* WindowsService.username()      (not tested)
+
+In here we create a unicode path with a funky non-ASCII name and (where
+possible) make psutil return it back (e.g. on name(), exe(), open_files(),
+etc.) and make sure that:
+
+* psutil never crashes with UnicodeDecodeError
+* the returned path matches
+"""
+
+import os
+import shutil
+import warnings
+from contextlib import closing
+
+import psutil
+from psutil import BSD
+from psutil import MACOS
+from psutil import POSIX
+
+from . import ASCII_FS
+from . import HAS_NET_CONNECTIONS_UNIX
+from . import HAS_PROC_ENVIRON
+from . import HAS_PROC_MEMORY_MAPS
+from . import INVALID_UNICODE_SUFFIX
+from . import TESTFN_PREFIX
+from . import UNICODE_SUFFIX
+from . import PsutilTestCase
+from . import bind_unix_socket
+from . import chdir
+from . import copyload_shared_lib
+from . import create_py_exe
+from . import get_testfn
+from . import pytest
+from . import safe_mkdir
+from . import safe_rmpath
+from . import serial
+from . import skip_on_access_denied
+from . import skipif
+from . import spawn_subproc
+from . import terminate
+
+
+def try_unicode(suffix):
+    """Return True if both the fs and the subprocess module can
+    deal with a unicode file name.
+    """
+    sproc = None
+    testfn = get_testfn(suffix=suffix)
+    try:
+        safe_rmpath(testfn)
+        create_py_exe(testfn)
+        sproc = spawn_subproc(cmd=[testfn])
+        shutil.copyfile(testfn, testfn + '-2')
+        safe_rmpath(testfn + '-2')
+    except (UnicodeEncodeError, OSError):
+        return False
+    else:
+        return True
+    finally:
+        if sproc is not None:
+            terminate(sproc)
+        safe_rmpath(testfn)
+
+
+def find_sock(cons):
+    """The UNIX socket bound by the test, among the ones already open."""
+    for conn in cons:
+        if os.path.basename(conn.laddr).startswith(TESTFN_PREFIX):
+            return conn
+    raise ValueError("connection not found")
+
+
+# ===================================================================
+# FS APIs
+# ===================================================================
+
+
+class BaseUnicodeTest(PsutilTestCase):
+    funky_suffix = None
+
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.skip_tests = False
+        cls.funky_name = None
+        if cls.funky_suffix is not None:
+            if not try_unicode(cls.funky_suffix):
+                cls.skip_tests = True
+            else:
+                cls.funky_name = get_testfn(suffix=cls.funky_suffix)
+                create_py_exe(cls.funky_name)
+
+    def setUp(self):
+        super().setUp()
+        if self.skip_tests:
+            return pytest.skip("can't handle unicode str")
+
+
+@serial
+@skipif(ASCII_FS, reason="ASCII fs")
+class TestFSAPIs(BaseUnicodeTest):
+    """Test FS APIs with a funky, valid, UTF8 path name."""
+
+    funky_suffix = UNICODE_SUFFIX
+
+    def expect_exact_path_match(self):
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            return self.funky_name in os.listdir(".")
+
+    # ---
+
+    def test_proc_exe(self):
+        cmd = [
+            self.funky_name,
+            "-c",
+            "import time; [time.sleep(0.1) for x in range(100)]",
+        ]
+        subp = self.spawn_subproc(cmd)
+        p = psutil.Process(subp.pid)
+        exe = p.exe()
+        assert isinstance(exe, str)
+        if self.expect_exact_path_match():
+            assert os.path.normcase(exe) == os.path.normcase(self.funky_name)
+
+    def test_proc_name(self):
+        cmd = [
+            self.funky_name,
+            "-c",
+            "import time; [time.sleep(0.1) for x in range(100)]",
+        ]
+        subp = self.spawn_subproc(cmd)
+        name = psutil.Process(subp.pid).name()
+        assert isinstance(name, str)
+        if self.expect_exact_path_match():
+            assert name == os.path.basename(self.funky_name)
+
+    def test_proc_cmdline(self):
+        cmd = [
+            self.funky_name,
+            "-c",
+            "import time; [time.sleep(0.1) for x in range(100)]",
+        ]
+        subp = self.spawn_subproc(cmd)
+        p = psutil.Process(subp.pid)
+        cmdline = p.cmdline()
+        for part in cmdline:
+            assert isinstance(part, str)
+        if self.expect_exact_path_match():
+            assert cmdline == cmd
+
+    def test_proc_cwd(self):
+        dname = self.funky_name + "2"
+        self.addCleanup(safe_rmpath, dname)
+        safe_mkdir(dname)
+        with chdir(dname):
+            p = psutil.Process()
+            cwd = p.cwd()
+        assert isinstance(p.cwd(), str)
+        if self.expect_exact_path_match():
+            assert cwd == dname
+
+    def test_proc_open_files(self):
+        p = psutil.Process()
+        start = set(p.open_files())
+        with open(self.funky_name, 'rb'):
+            new = set(p.open_files())
+        path = (new - start).pop().path
+        assert isinstance(path, str)
+        if BSD and not path:
+            # XXX - see https://github.com/giampaolo/psutil/issues/595
+            return pytest.skip("open_files on BSD is broken")
+        if self.expect_exact_path_match():
+            assert os.path.normcase(path) == os.path.normcase(self.funky_name)
+
+    @skipif(not POSIX, reason="POSIX only")
+    @skipif(not HAS_NET_CONNECTIONS_UNIX, reason="can't list UNIX sockets")
+    def test_proc_net_connections(self):
+        name = self.get_testfn(suffix=self.funky_suffix)
+        sock = bind_unix_socket(name)
+        with closing(sock):
+            cons = psutil.Process().net_connections('unix')
+            conn = find_sock(cons)
+            assert isinstance(conn.laddr, str)
+            assert conn.laddr == name
+
+    @skipif(not POSIX, reason="POSIX only")
+    @skipif(not HAS_NET_CONNECTIONS_UNIX, reason="can't list UNIX sockets")
+    @skip_on_access_denied
+    def test_net_connections(self):
+        name = self.get_testfn(suffix=self.funky_suffix)
+        sock = bind_unix_socket(name)
+        with closing(sock):
+            cons = psutil.net_connections(kind='unix')
+            conn = find_sock(cons)
+            assert isinstance(conn.laddr, str)
+            assert conn.laddr == name
+
+    def test_disk_usage(self):
+        dname = self.funky_name + "2"
+        self.addCleanup(safe_rmpath, dname)
+        safe_mkdir(dname)
+        psutil.disk_usage(dname)
+
+    @skipif(not HAS_PROC_MEMORY_MAPS, reason="not supported")
+    def test_memory_maps(self):
+        with copyload_shared_lib(suffix=self.funky_suffix) as funky_path:
+
+            def normpath(p):
+                return os.path.realpath(os.path.normcase(p))
+
+            libpaths = [
+                normpath(x.path) for x in psutil.Process().memory_maps()
+            ]
+            # ...just to have a clearer msg in case of failure
+            libpaths = [x for x in libpaths if TESTFN_PREFIX in x]
+            assert normpath(funky_path) in libpaths
+            for path in libpaths:
+                assert isinstance(path, str)
+
+
+class TestFSAPIsWithInvalidPath(TestFSAPIs):
+    """Test FS APIs with a funky, invalid path name."""
+
+    funky_suffix = INVALID_UNICODE_SUFFIX
+
+    def expect_exact_path_match(self):
+        return not MACOS
+
+
+# ===================================================================
+# Non fs APIs
+# ===================================================================
+
+
+class TestNonFSAPIS(BaseUnicodeTest):
+    """Unicode tests for non fs-related APIs."""
+
+    funky_suffix = UNICODE_SUFFIX
+
+    @skipif(not HAS_PROC_ENVIRON, reason="not supported")
+    def test_proc_environ(self):
+        # Note: differently from others, this test does not deal
+        # with fs paths.
+        env = os.environ.copy()
+        env['FUNNY_ARG'] = self.funky_suffix
+        sproc = self.spawn_subproc(env=env)
+        p = psutil.Process(sproc.pid)
+        env = p.environ()
+        for k, v in env.items():
+            assert isinstance(k, str)
+            assert isinstance(v, str)
+        assert env['FUNNY_ARG'] == self.funky_suffix
diff --git a/tests/test_windows.py b/tests/test_windows.py
new file mode 100755
index 0000000000..eb60f62bcc
--- /dev/null
+++ b/tests/test_windows.py
@@ -0,0 +1,1139 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Windows specific tests."""
+
+import ctypes
+import datetime
+import os
+import platform
+import re
+import signal
+import socket
+import subprocess
+import time
+import warnings
+from unittest import mock
+
+import psutil
+from psutil import WINDOWS
+from psutil import _psutil
+
+from . import HAS_BATTERY
+from . import PYPY
+from . import TOLERANCE_DISK_USAGE
+from . import TOLERANCE_SYS_MEM
+from . import PsutilTestCase
+from . import isolated
+from . import pytest
+from . import retry_on_failure
+from . import serial
+from . import sh
+from . import skipif
+from . import spawn_subproc
+from . import terminate
+
+if WINDOWS and not PYPY:
+    import ctypes
+    import ctypes.wintypes
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        import win32api  # requires "pip install pywin32"
+        import win32con
+        import win32process
+        import wmi  # requires "pip install wmi" / "make install-pydeps-test"
+
+if WINDOWS:
+    from psutil._pswindows import ERROR_PARTIAL_COPY
+    from psutil._pswindows import convert_oserror
+
+
+@skipif(not WINDOWS, reason="WINDOWS only")
+@skipif(PYPY, reason="pywin32 not available on PYPY")
+class WindowsTestCase(PsutilTestCase):
+
+    def OpenProcess(self, pid=None):
+        handle = win32api.OpenProcess(
+            win32con.PROCESS_QUERY_INFORMATION,
+            win32con.FALSE,
+            pid or os.getpid(),
+        )
+        self.addCleanup(win32api.CloseHandle, handle)
+        return handle
+
+
+# Note used but could be useful in the future
+def is_bash_env():
+    env = os.environ
+    if "MSYSTEM" in env or "MINGW_PREFIX" in env or "MINGW_CHOST" in env:
+        return True
+    return "bash" in env.get("SHELL", "")
+
+
+def powershell(cmd):
+    """Run a powershell command and return its output.
+    Example usage:
+    >>> powershell(
+        "Get-CIMInstance Win32_PageFileUsage | Select AllocatedBaseSize"
+    )
+    """
+    exe = "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe"
+    cmdline = [
+        exe,
+        "-ExecutionPolicy",
+        "Bypass",
+        "-NoLogo",
+        "-NonInteractive",
+        "-NoProfile",
+        "-WindowStyle",
+        "Hidden",
+        "-Command",
+        cmd,
+    ]
+    return sh(cmdline)
+
+
+def wmic(path, what, converter=int):
+    """Currently not used, but available just in case. Usage:
+
+    >>> wmic("Win32_OperatingSystem", "FreePhysicalMemory")
+    2134124534
+    """
+    out = sh(f"wmic path {path} get {what}").strip()
+    data = "".join(out.splitlines()[1:]).strip()  # get rid of the header
+    if converter is not None:
+        if "," in what:
+            return tuple(converter(x) for x in data.split())
+        else:
+            return converter(data)
+    else:
+        return data
+
+
+# ===================================================================
+# System APIs
+# ===================================================================
+
+
+class TestCpuCount(WindowsTestCase):
+
+    @skipif(
+        'NUMBER_OF_PROCESSORS' not in os.environ,
+        reason="env var not available",
+    )
+    def test_against_NUMBER_OF_PROCESSORS(self):
+        # Will likely fail on many-cores systems:
+        # https://stackoverflow.com/questions/31209256
+        num_cpus = int(os.environ['NUMBER_OF_PROCESSORS'])
+        assert num_cpus == psutil.cpu_count()
+
+    def test_against_GetSystemInfo(self):
+        # Will likely fail on many-cores systems:
+        # https://stackoverflow.com/questions/31209256
+        assert psutil.cpu_count() == win32api.GetSystemInfo()[5]
+
+    def test_against_wmi(self):
+        w = wmi.WMI()
+        procs = sum(
+            proc.NumberOfLogicalProcessors for proc in w.Win32_Processor()
+        )
+        assert psutil.cpu_count() == procs
+
+    def test_cores_against_wmi(self):
+        w = wmi.WMI()
+        cores = sum(proc.NumberOfCores for proc in w.Win32_Processor())
+        assert psutil.cpu_count(logical=False) == cores
+
+    def test_against_cpu_times(self):
+        assert psutil.cpu_count() == len(psutil.cpu_times(percpu=True))
+
+    def test_irq_field(self):
+        t = psutil.cpu_times()
+        assert t.irq >= 0
+        with pytest.warns(DeprecationWarning, match="interrupt"):
+            assert t.interrupt == t.irq
+
+
+class TestCpuFreq(WindowsTestCase):
+    def test_cpu_freq(self):
+        w = wmi.WMI()
+        proc = w.Win32_Processor()[0]
+        assert abs(proc.CurrentClockSpeed - psutil.cpu_freq().current) < 100
+        assert abs(proc.MaxClockSpeed - psutil.cpu_freq().max) < 100
+
+
+class TestCpuStats(WindowsTestCase):
+
+    @retry_on_failure
+    def test_ctx_switches(self):
+        w = wmi.WMI().Win32_PerfRawData_PerfOS_System()[0]
+        wmi_value = int(w.ContextSwitchesPersec)
+        psutil_value = psutil.cpu_stats().ctx_switches
+        assert abs(psutil_value - wmi_value) < 1000
+
+    @retry_on_failure
+    def test_interrupts(self):
+        # Interrupts are summed across all CPUs; use _Total from
+        # Win32_PerfRawData_PerfOS_Processor.
+        w = wmi.WMI().Win32_PerfRawData_PerfOS_Processor(Name="_Total")[0]
+        wmi_value = int(w.InterruptsPersec)
+        psutil_value = psutil.cpu_stats().interrupts
+        assert abs(psutil_value - wmi_value) < 1000
+
+    def test_soft_interrupts(self):
+        # Always 0 on Windows.
+        assert psutil.cpu_stats().soft_interrupts == 0
+
+
+class TestVirtualMemory(WindowsTestCase):
+
+    def test_total(self):
+        w = wmi.WMI().Win32_ComputerSystem()[0]
+        assert int(w.TotalPhysicalMemory) == psutil.virtual_memory().total
+
+    @retry_on_failure
+    def test_free(self):
+        w = wmi.WMI().Win32_PerfRawData_PerfOS_Memory()[0]
+        assert (
+            abs(int(w.AvailableBytes) - psutil.virtual_memory().free)
+            < TOLERANCE_SYS_MEM
+        )
+
+    @retry_on_failure
+    def test_wired(self):
+        w = wmi.WMI().Win32_PerfRawData_PerfOS_Memory()[0]
+        assert (
+            abs(int(w.PoolNonpagedBytes) - psutil.virtual_memory().wired)
+            < TOLERANCE_SYS_MEM
+        )
+
+    @retry_on_failure
+    def test_available(self):
+        w = wmi.WMI().Win32_PerfRawData_PerfOS_Memory()[0]
+        assert (
+            abs(int(w.AvailableBytes) - psutil.virtual_memory().available)
+            < TOLERANCE_SYS_MEM
+        )
+
+    @retry_on_failure
+    def test_used(self):
+        w = wmi.WMI().Win32_PerfRawData_PerfOS_Memory()[0]
+        total = psutil.virtual_memory().total
+        wmi_used = total - int(w.AvailableBytes)
+        assert abs(psutil.virtual_memory().used - wmi_used) < TOLERANCE_SYS_MEM
+
+
+class TestSwapMemory(WindowsTestCase):
+
+    def test_total(self):
+        w = wmi.WMI().Win32_PerfRawData_PerfOS_Memory()[0]
+        assert (
+            int(w.CommitLimit) - psutil.virtual_memory().total
+            == psutil.swap_memory().total
+        )
+        if psutil.swap_memory().total == 0:
+            assert psutil.swap_memory().free == 0
+            assert psutil.swap_memory().used == 0
+
+    def test_percent(self):
+        if psutil.swap_memory().total > 0:
+            w = wmi.WMI().Win32_PerfRawData_PerfOS_PagingFile(Name="_Total")[0]
+            # calculate swap usage to percent
+            percentSwap = int(w.PercentUsage) * 100 / int(w.PercentUsage_Base)
+            # exact percent may change but should be reasonable
+            # assert within +/- 5% and between 0 and 100%
+            assert psutil.swap_memory().percent >= 0
+            assert abs(psutil.swap_memory().percent - percentSwap) < 5
+            assert psutil.swap_memory().percent <= 100
+
+
+class TestNetAPIs(WindowsTestCase):
+
+    def test_net_io_counters_nic_names(self):
+        out = sh('ipconfig /all')
+        nics = psutil.net_io_counters(pernic=True).keys()
+        for nic in nics:
+            if "pseudo-interface" in nic.replace(' ', '-').lower():
+                continue
+            if nic not in out:
+                return pytest.fail(
+                    f"{nic!r} nic wasn't found in 'ipconfig /all' output"
+                )
+
+    @retry_on_failure
+    def test_net_io_counters(self):
+        wmi_nics = [
+            (nic.Name, int(nic.BytesReceivedPerSec), int(nic.BytesSentPerSec))
+            for nic in wmi.WMI().Win32_PerfRawData_Tcpip_NetworkInterface()
+        ]
+        tolerance = 1 * 1024 * 1024  # 1 MB
+        for name, io in psutil.net_io_counters(pernic=True).items():
+            if io.bytes_recv < tolerance and io.bytes_sent < tolerance:
+                # WMI does not list NICs with no traffic, e.g. the
+                # loopback pseudo-interface.
+                continue
+            for _, wmi_recv, wmi_sent in wmi_nics:
+                if (
+                    abs(io.bytes_recv - wmi_recv) < tolerance
+                    and abs(io.bytes_sent - wmi_sent) < tolerance
+                ):
+                    break
+            else:
+                return pytest.fail(
+                    f"no WMI match for {name!r} ({io!r}); wmi={wmi_nics!r}"
+                )
+
+    def test_net_if_addrs(self):
+        ps_addrs = set()
+        for addrs in psutil.net_if_addrs().values():
+            for addr in addrs:
+                if addr.family == socket.AF_INET:
+                    ps_addrs.add(addr.address)
+        out = powershell(
+            "(Get-NetIPAddress -AddressFamily IPv4).IPAddress -join ','"
+        )
+        win_addrs = set(out.strip().split(','))
+        assert win_addrs == ps_addrs
+
+    @serial
+    def test_net_connections(self):
+        # Compare listening TCP ports; they're stable unlike active
+        # connections.
+        ps_ports = {
+            c.laddr.port
+            for c in psutil.net_connections(kind='tcp')
+            if c.status == psutil.CONN_LISTEN
+        }
+        out = powershell(
+            "(Get-NetTCPConnection -State Listen).LocalPort -join ','"
+        )
+        win_ports = {int(p) for p in out.strip().split(',') if p.strip()}
+        assert ps_ports == win_ports
+
+    def test_net_if_stats(self):
+        ps_names = set(_psutil.net_if_stats())
+        wmi_adapters = wmi.WMI().Win32_NetworkAdapter()
+        wmi_names = set()
+        for wmi_adapter in wmi_adapters:
+            wmi_names.add(wmi_adapter.Name)
+            wmi_names.add(wmi_adapter.NetConnectionID)
+        assert (
+            ps_names & wmi_names
+        ), f"no common entries in {ps_names}, {wmi_names}"
+
+
+class TestDiskApis(WindowsTestCase):
+
+    @retry_on_failure
+    def test_disk_partitions(self):
+        ps_parts = psutil.disk_partitions(all=True)
+        wmi_parts = wmi.WMI().Win32_LogicalDisk()
+        for ps_part in ps_parts:
+            for wmi_part in wmi_parts:
+                if ps_part.device.replace('\\', '') == wmi_part.DeviceID:
+                    if not ps_part.mountpoint:
+                        # this is usually a CD-ROM with no disk inserted
+                        break
+                    if 'cdrom' in ps_part.opts:
+                        break
+                    if ps_part.mountpoint.startswith('A:'):
+                        break  # floppy
+                    try:
+                        usage = psutil.disk_usage(ps_part.mountpoint)
+                    except FileNotFoundError:
+                        # usually this is the floppy
+                        break
+                    assert usage.total == int(wmi_part.Size)
+                    wmi_free = int(wmi_part.FreeSpace)
+                    assert usage.free == wmi_free
+                    # 10 MB tolerance
+                    if abs(usage.free - wmi_free) > 10 * 1024 * 1024:
+                        return pytest.fail(
+                            f"psutil={usage.free}, wmi={wmi_free}"
+                        )
+                    break
+            else:
+                return pytest.fail(f"can't find partition {ps_part!r}")
+
+    def test_disk_partitions_mountpoint(self):
+        win = [
+            x + '\\'
+            for x in win32api.GetLogicalDriveStrings().split("\\\x00")
+            if x and not x.startswith('A:')
+        ]
+        ps = [
+            x.mountpoint
+            for x in psutil.disk_partitions(all=True)
+            if not x.mountpoint.startswith('A:')
+        ]
+        assert win == ps
+
+    @retry_on_failure
+    def test_disk_usage(self):
+        for disk in psutil.disk_partitions():
+            if 'cdrom' in disk.opts:
+                continue
+            win = win32api.GetDiskFreeSpaceEx(disk.mountpoint)
+            ps = psutil.disk_usage(disk.mountpoint)
+            assert abs(win[0] - ps.free) < TOLERANCE_DISK_USAGE
+            assert abs(win[1] - ps.total) < TOLERANCE_DISK_USAGE
+            assert ps.used == ps.total - ps.free
+
+    @retry_on_failure
+    def test_disk_io_counters(self):
+        stats = psutil.disk_io_counters()
+        w = wmi.WMI().Win32_PerfRawData_PerfDisk_PhysicalDisk(Name="_Total")[0]
+        tolerance = 10 * 1024 * 1024
+        assert abs(stats.read_bytes - int(w.DiskReadBytesPersec)) < tolerance
+        assert abs(stats.write_bytes - int(w.DiskWriteBytesPersec)) < tolerance
+        assert abs(stats.read_count - int(w.DiskReadsPersec)) < 1000
+        assert abs(stats.write_count - int(w.DiskWritesPersec)) < 1000
+
+
+class TestOtherSystemAPIs(WindowsTestCase):
+
+    # @skipif(wmi is None, reason="wmi module is not installed")
+    # def test__UPTIME(self):
+    #     # _UPTIME constant is not public but it is used internally
+    #     # as value to return for pid 0 creation time.
+    #     # WMI behaves the same.
+    #     w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
+    #     p = psutil.Process(0)
+    #     wmic_create = str(w.CreationDate.split('.')[0])
+    #     psutil_create = time.strftime("%Y%m%d%H%M%S",
+    #                                   time.localtime(p.create_time()))
+
+    def test_convert_dos_path_drive(self):
+        winpath = 'C:\\Windows\\Temp'
+        driveletter = 'C:'
+        # Mocked NT device path for C:
+        devicepath = '\\Device\\HarddiskVolume1'
+
+        # Path returned by RtlDosPathNameToNtPathName
+        ntpath1 = '\\??\\C:\\Windows\\Temp'
+        # Mocked normalized NT path
+        ntpath2 = '\\Device\\HarddiskVolume1\\Windows\\Temp'
+
+        devices = {devicepath: driveletter}
+
+        with mock.patch.object(
+            _psutil, 'QueryDosDevice', side_effect=devices.get
+        ) as m:
+            assert psutil._pswindows.convert_dos_path(ntpath1) == winpath
+            assert psutil._pswindows.convert_dos_path(ntpath2) == winpath
+            assert m.called
+
+    def test_convert_dos_path_unc(self):
+        # UNC path
+        winpath = '\\\\localhost\\C$\\Windows\\Temp'
+        # Path returned by RtlDosPathNameToNtPathName
+        ntpath1 = '\\??\\UNC\\localhost\\C$\\Windows\\Temp'
+        # Normalized NT path
+        ntpath2 = '\\Device\\Mup\\localhost\\C$\\Windows\\Temp'
+
+        assert psutil._pswindows.convert_dos_path(winpath) == winpath
+        assert psutil._pswindows.convert_dos_path(ntpath1) == winpath
+        assert psutil._pswindows.convert_dos_path(ntpath2) == winpath
+
+    def test_boot_time(self):
+        wmi_os = wmi.WMI().Win32_OperatingSystem()
+        wmi_btime_str = wmi_os[0].LastBootUpTime.split('.')[0]
+        wmi_btime_dt = datetime.datetime.strptime(
+            wmi_btime_str, "%Y%m%d%H%M%S"
+        )
+        psutil_dt = datetime.datetime.fromtimestamp(psutil.boot_time())
+        diff = abs((wmi_btime_dt - psutil_dt).total_seconds())
+        assert diff <= 5, (psutil_dt, wmi_btime_dt)
+
+    def test_users(self):
+        current = win32api.GetUserName()
+        assert current in {u.name for u in psutil.users()}
+
+
+# ===================================================================
+# sensors_battery()
+# ===================================================================
+
+
+class TestSensorsBattery(WindowsTestCase):
+    def test_has_battery(self):
+        if win32api.GetPwrCapabilities()['SystemBatteriesPresent']:
+            assert psutil.sensors_battery() is not None
+        else:
+            assert psutil.sensors_battery() is None
+
+    @skipif(not HAS_BATTERY, reason="no battery")
+    def test_percent(self):
+        w = wmi.WMI()
+        battery_wmi = w.query('select * from Win32_Battery')[0]
+        battery_psutil = psutil.sensors_battery()
+        assert (
+            abs(battery_psutil.percent - battery_wmi.EstimatedChargeRemaining)
+            < 1
+        )
+
+    @skipif(not HAS_BATTERY, reason="no battery")
+    def test_power_plugged(self):
+        w = wmi.WMI()
+        battery_wmi = w.query('select * from Win32_Battery')[0]
+        battery_psutil = psutil.sensors_battery()
+        # Status codes:
+        # https://msdn.microsoft.com/en-us/library/aa394074(v=vs.85).aspx
+        assert battery_psutil.power_plugged == (battery_wmi.BatteryStatus == 2)
+
+    @skipif(not HAS_BATTERY, reason="no battery")
+    def test_secsleft(self):
+        class SYSTEM_POWER_STATUS(ctypes.Structure):
+            _fields_ = [
+                ('ACLineStatus', ctypes.c_byte),
+                ('BatteryFlag', ctypes.c_byte),
+                ('BatteryLifePercent', ctypes.c_byte),
+                ('SystemStatusFlag', ctypes.c_byte),
+                ('BatteryLifeTime', ctypes.c_ulong),
+                ('BatteryFullLifeTime', ctypes.c_ulong),
+            ]
+
+        status = SYSTEM_POWER_STATUS()
+        ctypes.windll.kernel32.GetSystemPowerStatus(ctypes.byref(status))
+        bat = psutil.sensors_battery()
+        if status.ACLineStatus == 1 or status.BatteryFlag & 8:
+            # plugged/charging
+            assert bat.secsleft == psutil.POWER_TIME_UNLIMITED
+        elif status.BatteryLifeTime == 0xFFFFFFFF:
+            assert bat.secsleft == psutil.POWER_TIME_UNKNOWN
+        else:
+            assert bat.secsleft == status.BatteryLifeTime
+
+    def test_emulate_secsleft_unknown(self):
+        with mock.patch.object(
+            _psutil,
+            "sensors_battery",
+            return_value=(0, 0, 50, -1),
+        ) as m:
+            bat = psutil.sensors_battery()
+            assert m.called
+        assert bat.secsleft == psutil.POWER_TIME_UNKNOWN
+
+    def test_emulate_no_battery(self):
+        with mock.patch.object(
+            _psutil,
+            "sensors_battery",
+            return_value=(0, 128, 0, 0),
+        ) as m:
+            assert psutil.sensors_battery() is None
+            assert m.called
+
+    def test_emulate_power_connected(self):
+        with mock.patch.object(
+            _psutil, "sensors_battery", return_value=(1, 0, 0, 0)
+        ) as m:
+            assert (
+                psutil.sensors_battery().secsleft
+                == psutil.POWER_TIME_UNLIMITED
+            )
+            assert m.called
+
+    def test_emulate_power_charging(self):
+        with mock.patch.object(
+            _psutil, "sensors_battery", return_value=(0, 8, 0, 0)
+        ) as m:
+            assert (
+                psutil.sensors_battery().secsleft
+                == psutil.POWER_TIME_UNLIMITED
+            )
+            assert m.called
+
+    def test_emulate_secs_left_unknown(self):
+        with mock.patch.object(
+            _psutil,
+            "sensors_battery",
+            return_value=(0, 0, 0, -1),
+        ) as m:
+            assert (
+                psutil.sensors_battery().secsleft == psutil.POWER_TIME_UNKNOWN
+            )
+            assert m.called
+
+
+# ===================================================================
+# Process APIs
+# ===================================================================
+
+
+class TestProcess(WindowsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.pid = spawn_subproc().pid
+
+    @classmethod
+    def tearDownClass(cls):
+        terminate(cls.pid)
+
+    def test_issue_24(self):
+        p = psutil.Process(0)
+        with pytest.raises(psutil.AccessDenied):
+            p.kill()
+
+    def test_special_pid(self):
+        p = psutil.Process(4)
+        assert p.name() == 'System'
+        # use __str__ to access all common Process properties to check
+        # that nothing strange happens
+        str(p)
+        p.username()
+        assert p.create_time() >= 0.0
+        try:
+            rss, _vms = p.memory_info()[:2]
+        except psutil.AccessDenied:
+            # expected on Windows Vista and Windows 7
+            if platform.uname()[1] not in {'vista', 'win-7', 'win7'}:
+                raise
+        else:
+            assert rss > 0
+
+    def test_send_signal(self):
+        p = psutil.Process(self.pid)
+        with pytest.raises(ValueError):
+            p.send_signal(signal.SIGINT)
+
+    def test_num_handles_increment(self):
+        p = psutil.Process(os.getpid())
+        before = p.num_handles()
+        handle = self.OpenProcess()
+        after = p.num_handles()
+        assert after == before + 1
+        win32api.CloseHandle(handle)
+        assert p.num_handles() == before
+
+    @isolated
+    def test_ctrl_signals(self):
+        p = psutil.Process(self.spawn_subproc().pid)
+        p.send_signal(signal.CTRL_C_EVENT)
+        p.send_signal(signal.CTRL_BREAK_EVENT)
+        p.kill()
+        p.wait()
+        with pytest.raises(psutil.NoSuchProcess):
+            p.send_signal(signal.CTRL_C_EVENT)
+        with pytest.raises(psutil.NoSuchProcess):
+            p.send_signal(signal.CTRL_BREAK_EVENT)
+
+    def test_username(self):
+        name = win32api.GetUserNameEx(win32con.NameSamCompatible)
+        if name.endswith('$'):
+            # When running as a service account (most likely to be
+            # NetworkService), these user name calculations don't produce the
+            # same result, causing the test to fail.
+            return pytest.skip('running as service account')
+        assert psutil.Process().username() == name
+
+    def test_cmdline(self):
+        win = re.sub(r"[ ]+", " ", win32api.GetCommandLine()).strip()
+        ps = " ".join(psutil.Process().cmdline())
+        # The PyWin32 command line may retain quotes around argv[0] if they
+        # were used unnecessarily, while psutil will omit them. So remove
+        # the first 2 quotes from win if not in ps.
+        # A path to an executable will not contain quotes, so this is safe.
+        win = win.replace('"', "")
+        ps = ps.replace('"', "")
+        assert win == ps
+
+    # XXX - occasional failures
+
+    # def test_cpu_times(self):
+    #     a = psutil.Process().cpu_times()
+    #     b = win32process.GetProcessTimes(self.OpenProcess())
+    #     assert abs(a.user - b['UserTime'] / 10000000.0) < 0.2
+    #     assert abs(a.user - b['KernelTime'] / 10000000.0) < 0.2
+
+    def test_nice(self):
+        win = win32process.GetPriorityClass(self.OpenProcess())
+        ps = psutil.Process().nice()
+        assert ps == win
+
+    def test_memory_info(self):
+        win = win32process.GetProcessMemoryInfo(self.OpenProcess(self.pid))
+        ps = psutil.Process(self.pid).memory_info()
+        assert ps.rss == win["WorkingSetSize"]
+        assert ps.vms == win["PagefileUsage"]
+        assert ps.peak_rss == win["PeakWorkingSetSize"]
+        assert ps.peak_vms == win["PeakPagefileUsage"]
+        with pytest.warns(DeprecationWarning):
+            assert ps.num_page_faults == win["PageFaultCount"]
+
+    def test_memory_info_deprecated_fields(self):
+        win = win32process.GetProcessMemoryInfo(self.OpenProcess(self.pid))
+        ps = psutil.Process(self.pid).memory_info()
+
+        # old aliases
+        with pytest.warns(DeprecationWarning, match="wset is deprecated"):
+            assert ps.wset == ps.rss
+        with pytest.warns(DeprecationWarning, match="peak_wset is deprecated"):
+            assert ps.peak_wset == ps.peak_rss
+        with pytest.warns(DeprecationWarning, match="pagefile is deprecated"):
+            assert ps.pagefile == ps.vms
+        with pytest.warns(DeprecationWarning, match="private is deprecated"):
+            assert ps.private == ps.vms
+        with pytest.warns(
+            DeprecationWarning, match="peak_pagefile is deprecated"
+        ):
+            assert ps.peak_pagefile == ps.peak_vms
+
+        # fields moved to memory_extras()
+        with pytest.warns(
+            DeprecationWarning, match="paged_pool is deprecated"
+        ):
+            assert ps.paged_pool == win['QuotaPagedPoolUsage']
+        with pytest.warns(
+            DeprecationWarning, match="nonpaged_pool is deprecated"
+        ):
+            assert ps.nonpaged_pool == win['QuotaNonPagedPoolUsage']
+        with pytest.warns(
+            DeprecationWarning, match="peak_paged_pool is deprecated"
+        ):
+            assert ps.peak_paged_pool == win['QuotaPeakPagedPoolUsage']
+        with pytest.warns(
+            DeprecationWarning, match="peak_nonpaged_pool is deprecated"
+        ):
+            assert ps.peak_nonpaged_pool == win['QuotaPeakNonPagedPoolUsage']
+
+        # field moved to pages_fault()
+        with pytest.warns(
+            DeprecationWarning, match="num_page_faults is deprecated"
+        ):
+            assert ps.num_page_faults == win['PageFaultCount']
+
+        # test ntuple's __getattr__ override
+        with pytest.raises(AttributeError, match="foo"):
+            ps.foo  # noqa: B018
+
+    def test_memory_extras(self):
+        win = win32process.GetProcessMemoryInfo(self.OpenProcess(self.pid))
+        ps = psutil.Process(self.pid).memory_extras()
+        assert ps.paged_pool == win["QuotaPagedPoolUsage"]
+        assert ps.nonpaged_pool == win["QuotaNonPagedPoolUsage"]
+        assert ps.peak_paged_pool == win["QuotaPeakPagedPoolUsage"]
+        assert ps.peak_nonpaged_pool == win["QuotaPeakNonPagedPoolUsage"]
+
+        assert ps.virtual > 0
+        assert ps.peak_virtual > 0
+
+        assert ps.peak_virtual >= ps.virtual
+        assert ps.peak_paged_pool >= ps.paged_pool
+        assert ps.peak_nonpaged_pool >= ps.nonpaged_pool
+
+    def test_wait(self):
+        p = psutil.Process(self.pid)
+        p.terminate()
+        ps = p.wait()
+        win = win32process.GetExitCodeProcess(self.OpenProcess(self.pid))
+        assert ps == win
+
+    def test_num_threads(self):
+        ps = psutil.Process(self.pid).num_threads()
+        win = int(powershell(f"(Get-Process -Id {self.pid}).Threads.Count"))
+        assert ps == win
+
+    def test_cpu_affinity(self):
+        def from_bitmask(x):
+            return [i for i in range(64) if (1 << i) & x]
+
+        win = from_bitmask(
+            win32process.GetProcessAffinityMask(self.OpenProcess(self.pid))[0]
+        )
+        ps = psutil.Process(self.pid).cpu_affinity()
+        assert ps == win
+
+    def test_io_counters(self):
+        win = win32process.GetProcessIoCounters(self.OpenProcess())
+        ps = psutil.Process().io_counters()
+        assert ps.read_count == win['ReadOperationCount']
+        assert ps.write_count == win['WriteOperationCount']
+        assert ps.read_bytes == win['ReadTransferCount']
+        assert ps.write_bytes == win['WriteTransferCount']
+        assert ps.other_count == win['OtherOperationCount']
+        assert ps.other_bytes == win['OtherTransferCount']
+
+    def test_num_handles(self):
+        PROCESS_QUERY_INFORMATION = 0x400
+        handle = ctypes.windll.kernel32.OpenProcess(
+            PROCESS_QUERY_INFORMATION, 0, self.pid
+        )
+        self.addCleanup(ctypes.windll.kernel32.CloseHandle, handle)
+
+        hndcnt = ctypes.wintypes.DWORD()
+        ctypes.windll.kernel32.GetProcessHandleCount(
+            handle, ctypes.byref(hndcnt)
+        )
+        win = hndcnt.value
+        ps = psutil.Process(self.pid).num_handles()
+        assert ps == win
+
+    def test_error_partial_copy(self):
+        # https://github.com/giampaolo/psutil/issues/875
+        exc = OSError()
+        exc.winerror = 299
+        with mock.patch.object(_psutil, "proc_cwd", side_effect=exc):
+            with mock.patch("time.sleep") as m:
+                p = psutil.Process()
+                with pytest.raises(psutil.AccessDenied):
+                    p.cwd()
+        assert m.call_count >= 5
+
+    def test_exe(self):
+        # NtQuerySystemInformation succeeds if process is gone. Make sure
+        # it raises NSP for a non existent pid.
+        pid = psutil.pids()[-1] + 99999
+        proc = psutil._psplatform.Process(pid)
+        with pytest.raises(psutil.NoSuchProcess):
+            proc.exe()
+
+    @retry_on_failure
+    def test_page_faults(self):
+        # memory_info() value comes from GetProcessMemoryInfo ->
+        # PageFaultCount. page_faults() value comes from
+        # NtQuerySystemInformation -> HardFaultCount / PageFaultCount
+        p = psutil.Process()
+        mem = p.memory_info()
+        pfaults = p.page_faults()
+        tol = 500
+        with pytest.warns(
+            DeprecationWarning, match="num_page_faults is deprecated"
+        ):
+            assert mem.num_page_faults == pytest.approx(pfaults.minor, abs=tol)
+
+
+class TestProcessWMI(WindowsTestCase):
+    """Compare Process API results with WMI."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.pid = spawn_subproc().pid
+
+    @classmethod
+    def tearDownClass(cls):
+        terminate(cls.pid)
+
+    def test_name(self):
+        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
+        p = psutil.Process(self.pid)
+        assert p.name() == w.Caption
+
+    def test_exe(self):
+        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
+        p = psutil.Process(self.pid)
+        # Note: wmi reports the exe as a lower case string.
+        # Being Windows paths case-insensitive we ignore that.
+        assert p.exe().lower() == w.ExecutablePath.lower()
+
+    def test_cmdline(self):
+        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
+        p = psutil.Process(self.pid)
+        assert ' '.join(p.cmdline()) == w.CommandLine.replace('"', '')
+
+    def test_username(self):
+        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
+        p = psutil.Process(self.pid)
+        domain, _, username = w.GetOwner()
+        username = f"{domain}\\{username}"
+        assert p.username() == username
+
+    @retry_on_failure
+    def test_memory_rss(self):
+        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
+        p = psutil.Process(self.pid)
+        rss = p.memory_info().rss
+        assert rss == int(w.WorkingSetSize)
+
+    @retry_on_failure
+    def test_memory_vms(self):
+        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
+        p = psutil.Process(self.pid)
+        vms = p.memory_info().vms
+        # http://msdn.microsoft.com/en-us/library/aa394372(VS.85).aspx
+        # ...claims that PageFileUsage is represented in Kilo
+        # bytes but funnily enough on certain platforms bytes are
+        # returned instead.
+        wmi_usage = int(w.PageFileUsage)
+        if vms not in {wmi_usage, wmi_usage * 1024}:
+            return pytest.fail(f"wmi={wmi_usage}, psutil={vms}")
+
+    def test_cpu_times(self):
+        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
+        p = psutil.Process(self.pid)
+        ps = p.cpu_times()
+        assert abs(ps.user - int(w.UserModeTime) / 1e7) < 0.1
+        assert abs(ps.system - int(w.KernelModeTime) / 1e7) < 0.1
+
+    def test_ppid(self):
+        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
+        p = psutil.Process(self.pid)
+        assert p.ppid() == int(w.ParentProcessId)
+
+    def test_create_time(self):
+        w = wmi.WMI().Win32_Process(ProcessId=self.pid)[0]
+        p = psutil.Process(self.pid)
+        wmic_create = str(w.CreationDate.split('.')[0])
+        psutil_create = time.strftime(
+            "%Y%m%d%H%M%S", time.localtime(p.create_time())
+        )
+        assert wmic_create == psutil_create
+
+
+# ---
+
+
+@skipif(not WINDOWS, reason="WINDOWS only")
+class TestDualProcessImplementation(PsutilTestCase):
+    """Certain APIs on Windows have 2 internal implementations, one
+    based on documented Windows APIs, another one based
+    NtQuerySystemInformation() which gets called as fallback in
+    case the first fails because of limited permission error.
+    Here we test that the two methods return the exact same value,
+    see:
+    https://github.com/giampaolo/psutil/issues/304.
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        cls.pid = spawn_subproc().pid
+
+    @classmethod
+    def tearDownClass(cls):
+        terminate(cls.pid)
+
+    def test_memory_info(self):
+        mem_1 = psutil.Process(self.pid).memory_info()
+        with mock.patch.object(
+            _psutil,
+            "proc_memory_info",
+            side_effect=PermissionError,
+        ) as fun:
+            mem_2 = psutil.Process(self.pid).memory_info()
+            assert len(mem_1) == len(mem_2)
+            for i in range(len(mem_1)):
+                assert mem_1[i] >= 0
+                assert mem_2[i] >= 0
+                assert abs(mem_1[i] - mem_2[i]) < 512
+            assert fun.called
+
+    def test_create_time(self):
+        ctime = psutil.Process(self.pid).create_time()
+        with mock.patch.object(
+            _psutil,
+            "proc_times",
+            side_effect=PermissionError,
+        ) as fun:
+            assert psutil.Process(self.pid).create_time() == ctime
+            assert fun.called
+
+    def test_cpu_times(self):
+        cpu_times_1 = psutil.Process(self.pid).cpu_times()
+        with mock.patch.object(
+            _psutil,
+            "proc_times",
+            side_effect=PermissionError,
+        ) as fun:
+            cpu_times_2 = psutil.Process(self.pid).cpu_times()
+            assert fun.called
+            assert abs(cpu_times_1.user - cpu_times_2.user) < 0.01
+            assert abs(cpu_times_1.system - cpu_times_2.system) < 0.01
+
+    def test_io_counters(self):
+        io_counters_1 = psutil.Process(self.pid).io_counters()
+        with mock.patch.object(
+            _psutil,
+            "proc_io_counters",
+            side_effect=PermissionError,
+        ) as fun:
+            io_counters_2 = psutil.Process(self.pid).io_counters()
+            for i in range(len(io_counters_1)):
+                assert abs(io_counters_1[i] - io_counters_2[i]) < 5
+            assert fun.called
+
+    def test_num_handles(self):
+        num_handles = psutil.Process(self.pid).num_handles()
+        with mock.patch.object(
+            _psutil,
+            "proc_num_handles",
+            side_effect=PermissionError,
+        ) as fun:
+            assert psutil.Process(self.pid).num_handles() == num_handles
+            assert fun.called
+
+    def test_cmdline(self):
+        for pid in psutil.pids():
+            try:
+                a = _psutil.proc_cmdline(pid, use_peb=True)
+                b = _psutil.proc_cmdline(pid, use_peb=False)
+            except OSError as err:
+                if err.winerror == ERROR_PARTIAL_COPY:
+                    continue  # process is dying
+                err = convert_oserror(err)
+                if not isinstance(
+                    err, (psutil.AccessDenied, psutil.NoSuchProcess)
+                ):
+                    raise
+            else:
+                assert a == b
+
+
+@skipif(not WINDOWS, reason="WINDOWS only")
+class TestWow64Process(PsutilTestCase):
+    """Test reading cmdline, cwd and environ of a 32 bit (WoW64)
+    process, which requires reading its 32 bit PEB, see
+    psutil/arch/windows/proc_peb.c.
+    """
+
+    @staticmethod
+    def assert_wow64(pid):
+        PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+        kernel32 = ctypes.windll.kernel32
+        handle = kernel32.OpenProcess(
+            PROCESS_QUERY_LIMITED_INFORMATION, False, pid
+        )
+        assert handle
+        try:
+            wow64 = ctypes.c_int()
+            assert kernel32.IsWow64Process(handle, ctypes.byref(wow64))
+            assert wow64.value
+        finally:
+            kernel32.CloseHandle(handle)
+
+    def setUp(self):
+        super().setUp()
+        # any exe in SysWOW64 is 32 bit; the dir only exists on 64 bit
+        # Windows
+        exe = os.path.join(
+            os.environ.get("SYSTEMROOT", r"C:\Windows"),
+            "SysWOW64",
+            "findstr.exe",
+        )
+        if not os.path.exists(exe):
+            return pytest.skip("32 bit Windows")
+        env = os.environ.copy()
+        env["THINK_OF_A_NUMBER"] = str(os.getpid())
+        self.args = [exe, "hello"]
+        # findstr hangs reading stdin until we close it
+        self.proc = self.spawn_subproc(
+            self.args, env=env, stdin=subprocess.PIPE
+        )
+        self.assert_wow64(self.proc.pid)
+
+    def tearDown(self):
+        super().tearDown()
+        self.proc.communicate()
+
+    def test_cmdline(self):
+        assert psutil.Process(self.proc.pid).cmdline() == self.args
+
+    def test_cwd(self):
+        assert psutil.Process(self.proc.pid).cwd() == os.getcwd()
+
+    def test_environ(self):
+        environ = psutil.Process(self.proc.pid).environ()
+        assert environ["THINK_OF_A_NUMBER"] == str(os.getpid())
+
+
+# ===================================================================
+# Windows services
+# ===================================================================
+
+
+@skipif(not WINDOWS, reason="WINDOWS only")
+class TestServices(PsutilTestCase):
+    def test_win_service_iter(self):
+        valid_statuses = {
+            "running",
+            "paused",
+            "start",
+            "pause",
+            "continue",
+            "stop",
+            "stopped",
+        }
+        valid_start_types = {"automatic", "manual", "disabled"}
+        valid_statuses = {
+            "running",
+            "paused",
+            "start_pending",
+            "pause_pending",
+            "continue_pending",
+            "stop_pending",
+            "stopped",
+        }
+        for serv in psutil.win_service_iter():
+            if serv.name() == "WaaSMedicSvc":
+                # known issue in Windows 11 reading the description
+                # https://learn.microsoft.com/en-us/answers/questions/1320388/in-windows-11-version-22h2-there-it-shows-(failed
+                # https://github.com/giampaolo/psutil/issues/2383
+                continue
+            data = serv.as_dict()
+            assert isinstance(data['name'], str)
+            assert data['name'].strip()
+            assert isinstance(data['display_name'], str)
+            assert isinstance(data['username'], str)
+            assert data['status'] in valid_statuses
+            if data['pid'] is not None:
+                psutil.Process(data['pid'])
+            assert isinstance(data['binpath'], str)
+            assert isinstance(data['username'], str)
+            assert isinstance(data['start_type'], str)
+            assert data['start_type'] in valid_start_types
+            assert data['status'] in valid_statuses
+            assert isinstance(data['description'], str)
+            pid = serv.pid()
+            if pid is not None:
+                p = psutil.Process(pid)
+                assert p.is_running()
+            # win_service_get
+            s = psutil.win_service_get(serv.name())
+            # test __eq__
+            assert serv == s
+
+    def test_win_service_get(self):
+        ERROR_SERVICE_DOES_NOT_EXIST = _psutil.ERROR_SERVICE_DOES_NOT_EXIST
+        ERROR_ACCESS_DENIED = _psutil.ERROR_ACCESS_DENIED
+
+        name = next(psutil.win_service_iter()).name()
+        with pytest.raises(psutil.NoSuchProcess) as cm:
+            psutil.win_service_get(name + '???')
+        assert cm.value.name == name + '???'
+
+        # test NoSuchProcess
+        service = psutil.win_service_get(name)
+        exc = OSError(0, "msg", 0)
+        exc.winerror = ERROR_SERVICE_DOES_NOT_EXIST
+        with mock.patch.object(
+            _psutil, "winservice_query_status", side_effect=exc
+        ):
+            with pytest.raises(psutil.NoSuchProcess):
+                service.status()
+        with mock.patch.object(
+            _psutil, "winservice_query_config", side_effect=exc
+        ):
+            with pytest.raises(psutil.NoSuchProcess):
+                service.username()
+
+        # test AccessDenied
+        exc = OSError(0, "msg", 0)
+        exc.winerror = ERROR_ACCESS_DENIED
+        with mock.patch.object(
+            _psutil, "winservice_query_status", side_effect=exc
+        ):
+            with pytest.raises(psutil.AccessDenied):
+                service.status()
+        with mock.patch.object(
+            _psutil, "winservice_query_config", side_effect=exc
+        ):
+            with pytest.raises(psutil.AccessDenied):
+                service.username()
+
+        # test __str__ and __repr__
+        assert service.name() in str(service)
+        assert service.display_name() in str(service)
+        assert service.name() in repr(service)
+        assert service.display_name() in repr(service)
diff --git a/tox.ini b/tox.ini
deleted file mode 100644
index be87cf0829..0000000000
--- a/tox.ini
+++ /dev/null
@@ -1,32 +0,0 @@
-# Tox (http://tox.testrun.org/) is a tool for running tests
-# in multiple virtualenvs. This configuration file will run the
-# test suite on all supported python versions.
-# To use it run "pip install tox" and then run "tox" from this
-# directory.
-
-[tox]
-envlist = py26, py27, py32, py33, py34
-
-[testenv]
-deps =
-    flake8
-    py26: ipaddress
-    py26: mock==1.0.1
-    py26: unittest2
-    py27: ipaddress
-    py27: mock
-    py32: ipaddress
-    py32: mock
-    py33: ipaddress
-
-setenv =
-    PYTHONPATH = {toxinidir}/test
-    TOX = 1
-
-commands =
-    python psutil/tests/runner.py
-    git ls-files | grep \\.py$ | xargs flake8
-
-# suppress "WARNING: 'git' command found but not installed in testenv
-whitelist_externals = git
-usedevelop = True