Repository: giampaolo/psutil Branch: master Commit: deb0df5b6c6e Files: 238 Total size: 2.1 MB Directory structure: gitextract_40bz1e68/ ├── .clang-format ├── .dprint.jsonc ├── .github/ │ ├── FUNDING.yml │ ├── ISSUE_TEMPLATE/ │ │ ├── bug.md │ │ ├── config.yml │ │ └── enhancement.md │ ├── PULL_REQUEST_TEMPLATE.md │ ├── no-response.yml │ ├── placeholder │ └── workflows/ │ ├── bsd.yml │ ├── build.yml │ ├── changelog_bot.py │ ├── changelog_bot.yml │ ├── issues.py │ ├── issues.yml │ └── sunos.yml ├── .gitignore ├── CONTRIBUTING.md ├── HISTORY.rst ├── INSTALL.rst ├── LICENSE ├── MANIFEST.in ├── Makefile ├── README.rst ├── SECURITY.md ├── _bootstrap.py ├── docs/ │ ├── .readthedocs.yaml │ ├── DEVNOTES │ ├── Makefile │ ├── README │ ├── _ext/ │ │ ├── add_home_link.py │ │ ├── availability.py │ │ ├── changelog_anchors.py │ │ └── check_python_syntax.py │ ├── _links.rst │ ├── _static/ │ │ ├── copybutton.js │ │ ├── css/ │ │ │ └── custom.css │ │ └── sidebar.js │ ├── _templates/ │ │ └── layout.html │ ├── adoption.rst │ ├── alternatives.rst │ ├── api.rst │ ├── changelog.rst │ ├── conf.py │ ├── credits.rst │ ├── devguide.rst │ ├── faq.rst │ ├── glossary.rst │ ├── index.rst │ ├── install.rst │ ├── migration.rst │ ├── platform.rst │ ├── recipes.rst │ ├── requirements.txt │ ├── shell_equivalents.rst │ └── timeline.rst ├── psutil/ │ ├── __init__.py │ ├── _common.py │ ├── _enums.py │ ├── _ntuples.py │ ├── _psaix.py │ ├── _psbsd.py │ ├── _pslinux.py │ ├── _psosx.py │ ├── _psposix.py │ ├── _pssunos.py │ ├── _psutil_aix.c │ ├── _psutil_bsd.c │ ├── _psutil_linux.c │ ├── _psutil_osx.c │ ├── _psutil_sunos.c │ ├── _psutil_windows.c │ ├── _pswindows.py │ └── arch/ │ ├── aix/ │ │ ├── common.c │ │ ├── common.h │ │ ├── ifaddrs.c │ │ ├── ifaddrs.h │ │ ├── net_connections.c │ │ ├── net_connections.h │ │ └── net_kernel_structs.h │ ├── all/ │ │ ├── errors.c │ │ ├── init.c │ │ ├── init.h │ │ ├── pids.c │ │ ├── str.c │ │ └── utils.c │ ├── bsd/ │ │ ├── cpu.c │ │ ├── disk.c │ │ ├── heap.c │ │ ├── init.c │ │ ├── init.h │ │ ├── mem.c │ │ ├── net.c │ │ ├── proc.c │ │ ├── proc_utils.c │ │ └── sys.c │ ├── freebsd/ │ │ ├── cpu.c │ │ ├── disk.c │ │ ├── init.h │ │ ├── mem.c │ │ ├── pids.c │ │ ├── proc.c │ │ ├── proc_socks.c │ │ ├── sensors.c │ │ └── sys_socks.c │ ├── linux/ │ │ ├── disk.c │ │ ├── heap.c │ │ ├── init.h │ │ ├── mem.c │ │ ├── net.c │ │ └── proc.c │ ├── netbsd/ │ │ ├── cpu.c │ │ ├── disk.c │ │ ├── init.h │ │ ├── mem.c │ │ ├── pids.c │ │ ├── proc.c │ │ └── socks.c │ ├── openbsd/ │ │ ├── cpu.c │ │ ├── disk.c │ │ ├── init.h │ │ ├── mem.c │ │ ├── pids.c │ │ ├── proc.c │ │ ├── socks.c │ │ └── users.c │ ├── osx/ │ │ ├── cpu.c │ │ ├── disk.c │ │ ├── heap.c │ │ ├── init.c │ │ ├── init.h │ │ ├── mem.c │ │ ├── net.c │ │ ├── pids.c │ │ ├── proc.c │ │ ├── proc_utils.c │ │ ├── sensors.c │ │ └── sys.c │ ├── posix/ │ │ ├── init.c │ │ ├── init.h │ │ ├── net.c │ │ ├── pids.c │ │ ├── proc.c │ │ ├── sysctl.c │ │ └── users.c │ ├── sunos/ │ │ ├── cpu.c │ │ ├── disk.c │ │ ├── environ.c │ │ ├── init.h │ │ ├── mem.c │ │ ├── net.c │ │ ├── proc.c │ │ └── sys.c │ └── windows/ │ ├── cpu.c │ ├── disk.c │ ├── heap.c │ ├── init.c │ ├── init.h │ ├── mem.c │ ├── net.c │ ├── ntextapi.h │ ├── pids.c │ ├── proc.c │ ├── proc_handles.c │ ├── proc_info.c │ ├── proc_utils.c │ ├── security.c │ ├── sensors.c │ ├── services.c │ ├── socks.c │ ├── sys.c │ └── wmi.c ├── pyproject.toml ├── scripts/ │ ├── battery.py │ ├── cpu_distribution.py │ ├── disk_usage.py │ ├── fans.py │ ├── free.py │ ├── ifconfig.py │ ├── internal/ │ │ ├── README │ │ ├── bench_oneshot.py │ │ ├── bench_oneshot_2.py │ │ ├── convert_readme.py │ │ ├── download_wheels.py │ │ ├── find_adopters.py │ │ ├── find_broken_links.py │ │ ├── generate_manifest.py │ │ ├── git_pre_commit.py │ │ ├── install-sysdeps.sh │ │ ├── install_pip.py │ │ ├── print_access_denied.py │ │ ├── print_announce.py │ │ ├── print_api_speed.py │ │ ├── print_dist.py │ │ ├── print_downloads.py │ │ ├── print_hashes.py │ │ ├── print_sysinfo.py │ │ ├── purge_installation.py │ │ └── rst_check_dead_refs.py │ ├── iotop.py │ ├── killall.py │ ├── meminfo.py │ ├── netstat.py │ ├── nettop.py │ ├── pidof.py │ ├── pmap.py │ ├── procinfo.py │ ├── procsmem.py │ ├── ps.py │ ├── pstree.py │ ├── sensors.py │ ├── temperatures.py │ ├── top.py │ ├── who.py │ └── winservices.py ├── setup.py └── tests/ ├── README.md ├── __init__.py ├── test_aix.py ├── test_bsd.py ├── test_connections.py ├── test_contracts.py ├── test_heap.py ├── test_linux.py ├── test_memleaks.py ├── test_misc.py ├── test_osx.py ├── test_posix.py ├── test_process.py ├── test_process_all.py ├── test_scripts.py ├── test_sudo.py ├── test_sunos.py ├── test_system.py ├── test_testutils.py ├── test_type_hints.py ├── test_unicode.py └── test_windows.py ================================================ FILE CONTENTS ================================================ ================================================ FILE: .clang-format ================================================ # 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 ================================================ FILE: .dprint.jsonc ================================================ { "markdown": { "lineWidth": 79, "textWrap": "always", }, "json": { "indentWidth": 4, "associations": [ "**/*.json", "**/*.jsonc", ], }, "yaml": { "associations": [ "**/*.yml", "**/*.yaml", "**/.clang-format", ], }, "excludes": [ "**/*-lock.json", ".github/ISSUE_TEMPLATE/bug.md", ".github/ISSUE_TEMPLATE/enhancement.md", ".github/PULL_REQUEST_TEMPLATE.md", ], "plugins": [ "https://plugins.dprint.dev/markdown-0.21.1.wasm", "https://plugins.dprint.dev/json-0.21.1.wasm", "https://plugins.dprint.dev/g-plane/pretty_yaml-v0.6.0.wasm", ], } ================================================ FILE: .github/FUNDING.yml ================================================ # 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 ================================================ FILE: .github/ISSUE_TEMPLATE/bug.md ================================================ --- 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 }}} ================================================ FILE: .github/ISSUE_TEMPLATE/config.yml ================================================ blank_issues_enabled: false contact_links: - name: Ask a question url: https://groups.google.com/g/psutil about: Use this to ask for support ================================================ FILE: .github/ISSUE_TEMPLATE/enhancement.md ================================================ --- 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 }}} ================================================ FILE: .github/PULL_REQUEST_TEMPLATE.md ================================================ ## 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 }}} ================================================ FILE: .github/no-response.yml ================================================ # 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. ================================================ FILE: .github/placeholder ================================================ ================================================ FILE: .github/workflows/bsd.yml ================================================ # 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: push: # only run this job if the following files are modified paths: &bsd_paths - ".github/workflows/bsd.yml" - "psutil/__init__.py" - "psutil/_common.py" - "psutil/_ntuples.py" - "psutil/_psbsd.py" - "psutil/_psposix.py" - "psutil/_psutil_bsd.c" - "psutil/arch/bsd/**" - "psutil/arch/freebsd/**" - "psutil/arch/netbsd/**" - "psutil/arch/openbsd/**" - "psutil/arch/posix/**" - "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 runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Run tests uses: vmactions/freebsd-vm@v1 with: usesh: true run: | make ci-test openbsd: # if: false runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Run tests uses: vmactions/openbsd-vm@v1 with: usesh: true run: | make ci-test netbsd: # if: false runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Run tests uses: vmactions/netbsd-vm@v1 with: usesh: true run: | make ci-test ================================================ FILE: .github/workflows/build.yml ================================================ # Runs CI tests and generates wheels on the following platforms: # * Linux # * macOS # * Windows # # Useful URLs: # * https://github.com/pypa/cibuildwheel # * https://github.com/actions/checkout # * https://github.com/actions/setup-python # * https://github.com/actions/upload-artifact on: [push, pull_request] name: build concurrency: # Cancel build if a new one starts, but don't interrupt all jobs on the first # failure. group: build-${{ github.ref }} cancel-in-progress: true jobs: # Run tests on Linux, macOS, Windows tests: name: "${{ matrix.os }}, ${{ matrix.arch }}" runs-on: ${{ matrix.os }} timeout-minutes: 15 strategy: fail-fast: false matrix: include: - { os: ubuntu-latest, arch: x86_64 } - { os: ubuntu-24.04-arm, arch: aarch64 } - { os: macos-15, arch: x86_64 } - { os: macos-15, arch: arm64 } - { os: windows-2025, arch: AMD64 } - { os: windows-11-arm, arch: ARM64 } steps: - uses: actions/checkout@v5 # Install Python 3.8 on macOS ARM64 for universal2 support, else 3.11 - name: Install Python uses: actions/setup-python@v6 with: python-version: ${{ runner.os == 'macOS' && runner.arch == 'ARM64' && '3.8' || '3.11' }} - name: Build wheels + run tests uses: pypa/cibuildwheel@v3.2.1 env: CIBW_ARCHS: "${{ matrix.arch }}" CIBW_ENABLE: "cpython-freethreading ${{ startsWith(github.ref, 'refs/tags/') && '' || 'cpython-prerelease' }}" - name: Upload wheels uses: actions/upload-artifact@v4 with: name: wheels-${{ matrix.os }}-${{ matrix.arch }} path: wheelhouse # Run linters and build doc. linters-and-doc: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - uses: actions/setup-python@v6 with: python-version: 3.x - name: "Run linters" run: | make ci-lint - name: "Build doc" run: | pip install -r docs/requirements.txt cd docs && make html # Merge wheels and check sanity of the package distribution. merge-and-check-dist: needs: [tests] runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - uses: actions/setup-python@v6 with: python-version: 3.x - uses: actions/upload-artifact/merge@v4 with: name: wheels pattern: wheels-* separate-directories: false delete-merged: true - uses: actions/download-artifact@v4 with: name: wheels path: wheelhouse - run: | make ci-check-dist ================================================ FILE: .github/workflows/changelog_bot.py ================================================ # 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.request import anthropic # CLI args PR_NUMBER = None REPO = None TOKEN = None CHANGELOG_FILE = "docs/changelog.rst" CREDITS_FILE = "docs/credits.rst" MAX_DIFF_CHARS = 20_000 MAX_TOKENS = 1024 PROMPT = """\ You are helping maintain the official changelog for psutil, a Python system monitoring library. Your task is to generate ONE changelog entry describing the user-visible change introduced by a pull request. Do not generate more than one entry. PR #{number}: {title} Author: @{author} (full name: {author_name}) Description: {body} Diff: {diff} ISSUE NUMBER SELECTION The changelog should reference the GitHub ISSUE number when one exists, not the pull request number. Determine the correct issue number using these rules: 1. If the PR title or description references an issue such as: - "Fixes #1234" - "Closes #1234" - "Refs #1234" - "#1234" then use that number. 2. If multiple issues are referenced, choose the primary one most closely related to the change. 3. If no issue reference exists, fall back to the PR number. The chosen number will be used in the :gh:`...` role. 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 Classify the change into one of: Bug fixes Enhancements Bug fixes include: - crashes - incorrect behavior - race conditions - compilation failures - incorrect return values - memory leaks - platform regressions Enhancements include: - new features - performance improvements - better detection - improved error handling - new platform support - packaging improvements (e.g. wheels) PLATFORM TAGS If the change is platform specific, add tags immediately after the issue reference. Examples: :gh:`1234`, [Linux]: :gh:`1234`, [Windows]: :gh:`1234`, [macOS], [BSD]: Only add platform tags if the change clearly affects specific OSes. RST FORMATTING Use Sphinx roles for psutil APIs: Functions: :func:`function_name` Methods: :meth:`Class.method` Classes: :class:`ClassName` Exceptions: :exc:`ExceptionName` C functions or identifiers must use double backticks: ``function_name()`` FORMAT Each entry must follow this structure: - :gh:`ISSUE_NUMBER`: . Or with platforms: - :gh:`ISSUE_NUMBER`, [Linux]: . DESCRIPTION GUIDELINES - Describe the user-visible change. - Mention affected psutil APIs when applicable. - Avoid mentioning internal helper functions. - If fixing incorrect behavior, describe the previous issue. - If fixing a crash or compilation error, state it clearly. 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. - :gh:`2705`, [Linux]: :meth:`Process.wait()` now uses ``pidfd_open()`` + ``poll()`` for waiting, avoiding busy loops and improving response times. CREDITS psutil maintains a list of contributors in docs/credits.rst under "Code contributors by year". Generate a credits entry unless the author is @giampaolo, in which case set credits_entry to null. Use the contributor's full name from their GitHub profile ({author_name}) unless it is not set, in which case fall back to their username (@{author}). The format used in docs/credits.rst is: * `Name or username`_ - :gh:`ISSUE_NUMBER` Examples: * `Sergey Fedorov`_ - :gh:`2701` * `someuser`_ - :gh:`2710` Use the same issue number used in the changelog entry. """ SUBMIT_TOOL = { "name": "submit", "description": "Submit the changelog and credits entries.", "input_schema": { "type": "object", "properties": { "section": { "type": "string", "enum": ["Bug fixes", "Enhancements"], }, "changelog_entry": { "type": "string", "description": "The RST changelog entry.", }, "credits_entry": { "type": ["string", "null"], "description": ( "The RST credits line, or null if author is @giampaolo." ), }, }, "required": ["section", "changelog_entry", "credits_entry"], }, } 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", }, ) with urllib.request.urlopen(req) as resp: return resp.read() 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, } 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 ask_claude(pr, diff): 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], ) api_key = os.environ.get("ANTHROPIC_API_KEY", "").strip() client = anthropic.Anthropic(api_key=api_key) message = client.messages.create( model="claude-sonnet-4-6", max_tokens=MAX_TOKENS, tools=[SUBMIT_TOOL], tool_choice={"type": "tool", "name": "submit"}, messages=[{"role": "user", "content": prompt}], ) tool_use = next(b for b in message.content if b.type == "tool_use") return tool_use.input def insert_changelog_entry(section, entry): with open(CHANGELOG_FILE) as f: lines = f.readlines() version_re = re.compile(r"^(\d+\.\d+\.\d+|X\.X\.X).*$") version_idx = next( (i for i, ln in enumerate(lines) if version_re.match(ln.rstrip())), None, ) if version_idx is None: sys.exit(f"Could not find version block in {CHANGELOG_FILE}") next_version_idx = next( ( i for i in range(version_idx + 1, len(lines)) if version_re.match(lines[i].rstrip()) ), len(lines), ) block = lines[version_idx:next_version_idx] # Skip if this issue is already referenced in the version block gh_ref = re.search(r":gh:`\d+`", entry) if gh_ref and any(gh_ref.group(0) in ln for ln in block): print( f"Changelog entry for {gh_ref.group(0)} already exists, skipping" ) return header = f"**{section}**" header_idx = next( (i for i, ln in enumerate(block) if ln.rstrip() == header), None ) def _entry_gh_number(line): """Extract the ticket number from a :gh:`N` reference.""" m = re.search(r":gh:`(\d+)`", line) return int(m.group(1)) if m else None new_entry_num = _entry_gh_number(entry) if header_idx is None: insert_at = next( ( i for i, ln in enumerate(block) if ln.startswith("**") and ln.rstrip() != header ), len(block), ) new_block = ( block[:insert_at] + [f"{header}\n", "\n", f"{entry}\n", "\n"] + block[insert_at:] ) else: # Find the end of this section (next ** header or end of block). section_end = next( ( i for i in range(header_idx + 1, len(block)) if block[i].startswith("**") ), len(block), ) # Skip the blank line after the header. first_entry = header_idx + 1 if first_entry < len(block) and not block[first_entry].strip(): first_entry += 1 # Find the right position sorted by ticket number. insert_at = section_end if new_entry_num is not None: for i in range(first_entry, section_end): num = _entry_gh_number(block[i]) if num is not None and num > new_entry_num: insert_at = i break else: insert_at = first_entry new_block = block[:insert_at] + [f"{entry}\n"] + block[insert_at:] lines[version_idx:next_version_idx] = new_block with open(CHANGELOG_FILE, "w") as f: f.writelines(lines) def update_credits(credits_entry, author, author_name): """Insert credits entry and link definition into CREDITS_FILE.""" with open(CREDITS_FILE) as f: lines = f.readlines() year = str(datetime.date.today().year) year_re = re.compile(r"^\d{4}$") def sort_key(e): m = re.match(r"\*\s+`([^`]+)`_", e.strip()) return m.group(1).lower() if m else e.strip().lower() # Insert year entry section_idx = next( ( i for i, ln in enumerate(lines) if ln.rstrip() == "Code contributors by year" ), None, ) if section_idx is None: sys.exit( f"Could not find 'Code contributors by year' in {CREDITS_FILE}" ) year_idx = next( ( i for i in range(section_idx, len(lines)) if lines[i].rstrip() == 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].rstrip()) ), len(lines), ) lines[first_year:first_year] = [ f"{year}\n", "~" * len(year) + "\n", "\n", f"{credits_entry}\n", "\n", ] else: year_end = next( ( i for i in range(year_idx + 2, len(lines)) if year_re.match(lines[i].rstrip()) ), len(lines), ) new_key = sort_key(credits_entry) insert_idx = year_end skip = False for i in range(year_idx + 2, year_end): if lines[i].startswith("* "): k = sort_key(lines[i]) if k == new_key: print( f"Credits entry for {new_key!r} already exists," " skipping" ) skip = True break if k > new_key: insert_idx = i break if not skip: # Don't back up past the blank line after the year # underline (year_idx + 2 = "~~~~\n", + 3 = first # content line). min_idx = year_idx + 3 while insert_idx > min_idx and not lines[insert_idx - 1].strip(): insert_idx -= 1 lines.insert(insert_idx, f"{credits_entry}\n") # Insert link definition if missing target = f".. _`{author_name}`:" if not any(ln.startswith(target) for ln in lines): link_section = next( ( i for i, ln in enumerate(lines) if ln.rstrip() == ".. Code contributors" ), None, ) if link_section is None: sys.exit( "Could not find code contributors link section in" f" {CREDITS_FILE}" ) definition = f".. _`{author_name}`: https://github.com/{author}\n" insert_idx = len(lines) for i in range(link_section, len(lines)): m = re.match(r"\.\. _`([^`]+)`:", lines[i]) if m and m.group(1).lower() > author_name.lower(): insert_idx = i break lines.insert(insert_idx, definition) with open(CREDITS_FILE, "w") as f: f.writelines(lines) def post_comment(body): url = f"https://api.github.com/repos/{REPO}/issues/{PR_NUMBER}/comments" data = json.dumps({"body": body}).encode() req = urllib.request.Request( url, data=data, headers={ "Authorization": f"Bearer {TOKEN}", "Accept": "application/vnd.github+json", "Content-Type": "application/json", "X-GitHub-Api-Version": "2022-11-28", }, ) with urllib.request.urlopen(req): pass def parse_cli(): global PR_NUMBER, REPO, TOKEN 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") args = p.parse_args() PR_NUMBER = args.pr_number REPO = args.repo TOKEN = args.token def main(): parse_cli() print(f"Fetching PR #{PR_NUMBER} from {REPO}...") pr = fetch_pr_metadata() diff = fetch_pr_diff() print("Asking Claude for changelog entry...") result = ask_claude(pr, diff) section = result["section"] changelog_entry = result["changelog_entry"] credits_entry = result["credits_entry"] print(f"Section: {section}") print(f"Entry: {changelog_entry}") insert_changelog_entry(section, changelog_entry) print(f"Inserted entry into {CHANGELOG_FILE}") comment = ( f"`{CHANGELOG_FILE}` entry added under **{section}**:\n\n" f"```rst\n{changelog_entry}\n```" ) if credits_entry: print(f"Credits: {credits_entry}") update_credits(credits_entry, pr["author"], pr["author_name"]) print(f"Updated {CREDITS_FILE}") comment += ( f"\n\n`{CREDITS_FILE}` entry added:\n\n" f"```rst\n{credits_entry}\n```" ) post_comment(comment) print("Posted confirmation comment on PR") if __name__ == "__main__": main() ================================================ FILE: .github/workflows/changelog_bot.yml ================================================ name: changelog-bot on: issue_comment: types: [created] permissions: contents: write pull-requests: write jobs: changelog: if: > github.event.comment.body == '/changelog' && github.event.issue.pull_request != null runs-on: ubuntu-latest steps: - name: Check commenter permissions id: check-perms env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: | PERMISSION=$(gh api \ repos/${{ github.repository }}/collaborators/${{ github.event.comment.user.login }}/permission \ --jq '.permission') echo "permission=$PERMISSION" if [[ "$PERMISSION" != "write" && "$PERMISSION" != "admin" ]]; then echo "User ${{ github.event.comment.user.login }} does not have write/admin permission" exit 1 fi - name: Get PR info id: pr-info env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: | PR_NUMBER=${{ github.event.issue.number }} PR_JSON=$(gh pr view $PR_NUMBER \ --repo ${{ github.repository }} \ --json headRefName,headRepository,headRepositoryOwner) 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') echo "branch=$HEAD_BRANCH" >> "$GITHUB_OUTPUT" echo "head_repo=$HEAD_OWNER/$HEAD_REPO" >> "$GITHUB_OUTPUT" - name: Checkout PR branch uses: actions/checkout@v5 with: ref: refs/pull/${{ github.event.issue.number }}/head token: ${{ secrets.GITHUB_TOKEN }} - name: Install dependencies run: pip install anthropic - name: Run changelog bot env: ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }} run: | python .github/workflows/changelog_bot.py \ --pr-number ${{ github.event.issue.number }} \ --repo ${{ github.repository }} \ --token ${{ secrets.GITHUB_TOKEN }} - name: Commit and push if changelog changed env: GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: | git config user.name "github-actions[bot]" git config user.email "github-actions[bot]@users.noreply.github.com" git add docs/changelog.rst docs/credits.rst if git diff --cached --quiet; then echo "No changes, skipping commit" else git commit -m "Update changelog for PR #${{ github.event.issue.number }}" HEAD_REPO="${{ steps.pr-info.outputs.head_repo }}" HEAD_BRANCH="${{ steps.pr-info.outputs.branch }}" PUSH_URL="https://x-access-token:${GH_TOKEN}@github.com/${HEAD_REPO}.git" git push "$PUSH_URL" "HEAD:refs/heads/${HEAD_BRANCH}" fi ================================================ FILE: .github/workflows/issues.py ================================================ #!/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, PR or comment is created. Assign labels, provide replies, closes issues, etc. depending on the situation. """ import functools import json import os import pathlib import re from pprint import pprint as pp from github import Github ROOT_DIR = pathlib.Path(__file__).resolve().parent.parent.parent SCRIPTS_DIR = ROOT_DIR / 'scripts' # --- constants # fmt: off LABELS_MAP = { # platforms "linux": [ "linux", "ubuntu", "redhat", "mint", "centos", "red hat", "archlinux", "debian", "alpine", "gentoo", "fedora", "slackware", "suse", "RHEL", "opensuse", "manylinux", "apt ", "apt-", "rpm", "yum", "kali", "/sys/class", "/proc/net", "/proc/disk", "/proc/smaps", "/proc/vmstat", ], "windows": [ "windows", "win32", "WinError", "WindowsError", "win10", "win7", "win ", "mingw", "msys", "studio", "microsoft", "CloseHandle", "GetLastError", "NtQuery", "DLL", "MSVC", "TCHAR", "WCHAR", ".bat", "OpenProcess", "TerminateProcess", "windows error", "NtWow64", "NTSTATUS", "Visual Studio", ], "macos": [ "macos", "mac ", "osx", "os x", "mojave", "sierra", "capitan", "yosemite", "catalina", "mojave", "big sur", "xcode", "darwin", "dylib", "m1", ], "aix": ["aix"], "cygwin": ["cygwin"], "freebsd": ["freebsd"], "netbsd": ["netbsd"], "openbsd": ["openbsd"], "sunos": ["sunos", "solaris"], "wsl": ["wsl"], "unix": [ "psposix", "waitpid", "statvfs", "/dev/tty", "/dev/pts", "posix", ], "pypy": ["pypy"], "docker": ["docker", "docker-compose"], "vm": [ "docker", "docker-compose", "vmware", "lxc", "hyperv", "virtualpc", "virtualbox", "bhyve", "openvz", "lxc", "xen", "kvm", "qemu", "heroku", ], # types "enhancement": ["enhancement"], "memleak": ["memory leak", "leaks memory", "memleak", "mem leak"], "api": ["idea", "proposal", "api", "feature"], "performance": ["performance", "speedup", "speed up", "slow", "fast"], "wheels": ["wheel", "wheels"], "scripts": [ "example script", "examples script", "example dir", "scripts/", ], # bug "bug": [ "fail", "can't execute", "can't install", "cannot execute", "cannot install", "install error", "crash", "critical", ], # doc "doc": [ "doc ", "document ", "documentation", "readthedocs", "pythonhosted", "HISTORY", "README", "dev guide", "devguide", "sphinx", "docfix", "index.rst", ], # tests "tests": [ " test ", "tests", "travis", "coverage", "cirrus", "continuous integration", "unittest", "pytest", "unit test", ], # critical errors "critical": [ "WinError", "WindowsError", "RuntimeError", "ZeroDivisionError", "SystemError", "MemoryError", "core dump", "segfault", "segmentation fault", ], } OS_LABELS = [ "linux", "windows", "macos", "freebsd", "openbsd", "netbsd", "openbsd", "bsd", "sunos", "unix", "wsl", "aix", "cygwin", ] # fmt: on LABELS_MAP['scripts'].extend( [x for x in os.listdir(SCRIPTS_DIR) if x.endswith('.py')] ) ILLOGICAL_PAIRS = [ ('bug', 'enhancement'), ('doc', 'tests'), ('scripts', 'doc'), ('scripts', 'tests'), ('bsd', 'freebsd'), ('bsd', 'openbsd'), ('bsd', 'netbsd'), ] # --- replies REPLY_MISSING_PYTHON_HEADERS = """\ It looks like you're missing `Python.h` headers. This usually means you have \ to install them first, then retry psutil installation. Please read \ [install](https://psutil.readthedocs.io/install) \ instructions for your platform. \ This is an auto-generated response based on the text you submitted. \ If this was a mistake or you think there's a bug with psutil installation \ process, please add a comment to reopen this issue. """ # REPLY_UPDATE_CHANGELOG = """\ # """ # --- github API utils def is_pr(issue): return issue.pull_request is not None def has_label(issue, label): assigned = [x.name for x in issue.labels] return label in assigned 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_issue(): data = _get_event_data() try: return data['action'] == 'opened' and 'issue' in data except KeyError: return False 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 add_label(issue, label): def should_add(issue, label): if has_label(issue, label): log(f"already has label {label!r}") return False for left, right in ILLOGICAL_PAIRS: if label == left and has_label(issue, right): log(f"already has label f{label}") return False return not has_label(issue, label) if not should_add(issue, label): log(f"should not add label {label!r}") return log(f"add label {label!r}") issue.add_to_labels(label) def _guess_labels_from_text(text): assert isinstance(text, str), text for label, keywords in LABELS_MAP.items(): for keyword in keywords: if keyword.lower() in text.lower(): yield (label, keyword) def add_labels_from_text(issue, text): assert isinstance(text, str), text for label, keyword in _guess_labels_from_text(text): add_label(issue, label) def add_labels_from_new_body(issue, text): assert isinstance(text, str), text log("start searching for template lines in new issue/PR body") # add os label r = re.search(r"\* OS:.*?\n", text) log("search for 'OS: ...' line") if r: log("found") add_labels_from_text(issue, r.group(0)) else: log("not found") # add bug/enhancement label log("search for 'Bug fix: y/n' line") r = re.search(r"\* Bug fix:.*?\n", text) if ( is_pr(issue) and r is not None and not has_label(issue, "bug") and not has_label(issue, "enhancement") ): log("found") s = r.group(0).lower() if 'yes' in s: add_label(issue, 'bug') else: add_label(issue, 'enhancement') else: log("not found") # add type labels log("search for 'Type: ...' line") r = re.search(r"\* Type:.*?\n", text) if r: log("found") s = r.group(0).lower() if 'doc' in s: add_label(issue, 'doc') if 'performance' in s: add_label(issue, 'performance') if 'scripts' in s: add_label(issue, 'scripts') if 'tests' in s: add_label(issue, 'tests') if 'wheels' in s: add_label(issue, 'wheels') if 'new-api' in s: add_label(issue, 'new-api') if 'new-platform' in s: add_label(issue, 'new-platform') else: log("not found") # --- events def on_new_issue(issue): def has_text(text): return text in issue.title.lower() or ( issue.body and text in issue.body.lower() ) def body_mentions_python_h(): if not issue.body: return False body = issue.body.replace(' ', '') return ( "#include\n^~~~" in body or "#include\r\n^~~~" in body ) log("searching for missing Python.h") if ( has_text("missing python.h") or has_text("python.h: no such file or directory") or body_mentions_python_h() ): log("found mention of Python.h") issue.create_comment(REPLY_MISSING_PYTHON_HEADERS) issue.edit(state='closed') return def on_new_pr(issue): pass # pr = get_repo().get_pull(issue.number) # files = [x.filename for x in list(pr.get_files())] # if "changelog.rst" not in files: # issue.create_comment(REPLY_UPDATE_CHANGELOG) 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_issue(): log(f"created new issue {issue}") add_labels_from_text(issue, issue.title) if issue.body: add_labels_from_new_body(issue, issue.body) on_new_issue(issue) elif is_event_new_pr(): log(f"created new PR {issue}") add_labels_from_text(issue, issue.title) if issue.body: add_labels_from_new_body(issue, issue.body) on_new_pr(issue) else: log("unhandled event") if __name__ == '__main__': main() ================================================ FILE: .github/workflows/issues.yml ================================================ # Fired by Github Actions every time an issue, PR or comment is created. name: issues on: issues: types: [opened] pull_request_target: types: [opened] issue_comment: types: [created] permissions: issues: write pull-requests: write jobs: build: runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v5 - name: Install Python uses: actions/setup-python@v6 with: python-version: "3.x" - name: Install deps run: python3 -m pip install PyGithub - name: Run env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} run: | PYTHONUNBUFFERED=1 PYTHONWARNINGS=always python3 .github/workflows/issues.py ================================================ FILE: .github/workflows/sunos.yml ================================================ # Execute tests on SunOS # https://github.com/vmactions/solaris-vm name: sunos on: push: # only run this job if the following files are modified paths: &sunos_paths - ".github/workflows/sunos.yml" - "psutil/_pssunos.py" - "psutil/_psutil_sunos.c" - "psutil/arch/all/**" - "psutil/arch/posix/**" - "psutil/arch/sunos/**" - "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: runs-on: ubuntu-latest steps: - uses: actions/checkout@v5 - name: Run tests id: test uses: vmactions/solaris-vm@v1 with: release: "11.4-gcc" usesh: true run: | set -x python3 setup.py build_ext -i --parallel 4 python3 -c "import psutil" python3 scripts/internal/install_pip.py python3 -m pip install --break-system-packages --user .[test] PYTHONMALLOC=malloc PYTHONUNBUFFERED=1 python3 -m pytest tests/test_memleaks.py ================================================ FILE: .gitignore ================================================ syntax: glob *.al *.bak *.egg-info *.la *.lo *.o *.orig *.pyc *.pyd *.rej *.so *.swp .failed-tests.txt .cache/ .idea/ .tox/ build/ docs/_build/ dist/ wheelhouse/ .tests/ ================================================ FILE: CONTRIBUTING.md ================================================ # 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 try to be accurate in editing the default issue **template**. There is a bot which automatically assigns **labels** based on issue's title and body format. Labels help keeping the issues properly organized and searchable (by OS, issue type, etc.). - When reporting a malfunction, consider enabling [debug mode](https://psutil.readthedocs.io/en/latest/#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 - 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. - In order to get acquainted with the code base and tooling, take a look at the **[Development Guide](https://psutil.readthedocs.io/devguide)**. - If you can, remember to update [changelog.rst](https://github.com/giampaolo/psutil/blob/master/docs/changelog.rst) and [CREDITS](https://github.com/giampaolo/psutil/blob/master/CREDITS) file. ================================================ FILE: HISTORY.rst ================================================ History has moved to: - https://psutil.readthedocs.io/changelog - https://github.com/giampaolo/psutil/blob/master/docs/changelog.rst (source) ================================================ FILE: INSTALL.rst ================================================ Installation instructions have moved to: - https://psutil.readthedocs.io/install - https://github.com/giampaolo/psutil/blob/master/docs/install.rst (source) ================================================ FILE: LICENSE ================================================ BSD 3-Clause License Copyright (c) 2009, Jay Loden, Dave Daeschler, Giampaolo Rodola All rights reserved. Redistribution and use in source and binary forms, with or without modification, 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. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ================================================ FILE: MANIFEST.in ================================================ include .clang-format include .dprint.jsonc include .gitignore include CONTRIBUTING.md include HISTORY.rst include INSTALL.rst include LICENSE include MANIFEST.in include Makefile include README.rst include SECURITY.md include _bootstrap.py include docs/.readthedocs.yaml include docs/DEVNOTES include docs/Makefile include docs/README include docs/_ext/add_home_link.py include docs/_ext/availability.py include docs/_ext/changelog_anchors.py include docs/_ext/check_python_syntax.py include docs/_links.rst include docs/_static/copybutton.js include docs/_static/css/custom.css include docs/_static/favicon.ico include docs/_static/sidebar.js include docs/_templates/layout.html include docs/adoption.rst include docs/alternatives.rst include docs/api.rst include docs/changelog.rst include docs/conf.py include docs/credits.rst include docs/devguide.rst include docs/faq.rst include docs/glossary.rst include docs/index.rst include docs/install.rst include docs/migration.rst include docs/platform.rst include docs/recipes.rst include docs/requirements.txt include docs/shell_equivalents.rst include docs/timeline.rst 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/common.c include psutil/arch/aix/common.h include psutil/arch/aix/ifaddrs.c include psutil/arch/aix/ifaddrs.h include psutil/arch/aix/net_connections.c include psutil/arch/aix/net_connections.h include psutil/arch/aix/net_kernel_structs.h 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_info.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/convert_readme.py include scripts/internal/download_wheels.py include scripts/internal/find_adopters.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-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/internal/rst_check_dead_refs.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 tests/README.md include tests/__init__.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 recursive-exclude docs/_static * ================================================ FILE: Makefile ================================================ # 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.3`. # - To append an argument to a command use ARGS, e.g: `make test ARGS="-k # some_test`. # Configurable PYTHON = python3 ARGS = FILES = PIP_INSTALL_ARGS = --trusted-host files.pythonhosted.org --trusted-host pypi.org --upgrade --upgrade-strategy eager 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 # if make is invoked with no arg, default to `make help` .DEFAULT_GOAL := help # install git hook _ := $(shell mkdir -p .git/hooks/ && ln -sf ../../scripts/internal/git_pre_commit.py .git/hooks/pre-commit && chmod +x .git/hooks/pre-commit) # =================================================================== # Install # =================================================================== 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 -type f -name \*\$testfn` @rm -rfv \ *.core \ *.egg-info \ *\@psutil-* \ .coverage \ .failed-tests.txt \ .pytest_cache \ .ruff_cache/ \ .tests \ build/ \ dist/ \ docs/_build/ \ htmlcov/ \ pytest-cache-files* \ wheelhouse .PHONY: build 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 -i --parallel 4 $(PYTHON_ENV_VARS) $(PYTHON) -c "import psutil" # make sure it actually worked install: ## Install this package as current user in "edit" mode. $(MAKE) build # If not in a virtualenv, add --user to the install command. $(PYTHON_ENV_VARS) $(PYTHON) setup.py develop $(SETUP_INSTALL_ARGS) `$(PYTHON) -c \ "import sys; print('' if hasattr(sys, 'real_prefix') or hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix else '--user')"` 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-pip: ## Install pip (no-op if already installed). $(PYTHON) scripts/internal/install_pip.py install-sysdeps: ./scripts/internal/install-sysdeps.sh install-pydeps-test: ## Install python deps necessary to run unit tests. $(MAKE) install-pip PIP_BREAK_SYSTEM_PACKAGES=1 $(PYTHON) -m pip install $(PIP_INSTALL_ARGS) setuptools PIP_BREAK_SYSTEM_PACKAGES=1 $(PYTHON) -m pip install $(PIP_INSTALL_ARGS) .[test] install-pydeps-lint: ## Install python deps necessary to run linters. $(MAKE) install-pip PIP_BREAK_SYSTEM_PACKAGES=1 $(PYTHON) -m pip install $(PIP_INSTALL_ARGS) setuptools PIP_BREAK_SYSTEM_PACKAGES=1 $(PYTHON) -m pip install $(PIP_INSTALL_ARGS) .[lint] install-pydeps-dev: ## Install python deps meant for local development. $(MAKE) install-pip PIP_BREAK_SYSTEM_PACKAGES=1 $(PYTHON) -m pip install $(PIP_INSTALL_ARGS) setuptools PIP_BREAK_SYSTEM_PACKAGES=1 $(PYTHON) -m pip install $(PIP_INSTALL_ARGS) .[dev] # =================================================================== # Tests # =================================================================== # Cache dir on Windows often causes "Permission denied" errors _PYTEST_EXTRA != if [ "$$OS" = "Windows_NT" ]; then printf '%s' '-o cache_dir=/tmp/pytest-psutil-cache'; fi RUN_TEST = $(PYTHON_ENV_VARS) $(PYTHON) -m pytest $(_PYTEST_EXTRA) 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-parallel: ## Run all tests (except memleak tests) in parallel. $(RUN_TEST) -p xdist -n auto --dist loadgroup $(ARGS) 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) tests/test_scripts.py $(ARGS) test-testutils: ## Run test utils tests. $(RUN_TEST) tests/test_testutils.py $(ARGS) test-unicode: ## Test APIs dealing with strings. $(RUN_TEST) tests/test_unicode.py $(ARGS) test-contracts: ## APIs sanity tests. $(RUN_TEST) tests/test_contracts.py $(ARGS) test-type-hints: ## Test type hints $(RUN_TEST) tests/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) test-memleaks: ## Memory leak tests. PYTHONMALLOC=malloc $(RUN_TEST) -k test_memleaks.py $(ARGS) 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_ENV_VARS) $(PYTHON) -m coverage run -m pytest $(ARGS) $(PYTHON) -m coverage report @echo "writing results to htmlcov/index.html" $(PYTHON) -m coverage html $(PYTHON) -m webbrowser -t htmlcov/index.html # =================================================================== # Linters # =================================================================== # 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 {} dprint: @$(DPRINT) check lint-rst: ## Run linter for .rst files. @$(call _ls,'*.rst') | xargs python3 scripts/internal/rst_check_dead_refs.py @$(call _ls,'*.rst') | xargs sphinx-lint lint-toml: ## Run linter for pyproject.toml. @$(call _ls,'*.toml') | xargs toml-sort --check lint-all: ## Run all linters $(MAKE) black $(MAKE) ruff $(MAKE) lint-c $(MAKE) dprint $(MAKE) lint-rst $(MAKE) lint-toml # --- not mandatory linters (just run from time to time) pylint: ## Python pylint @git ls-files '*.py' | xargs $(PYTHON) -m pylint --rcfile=pyproject.toml --jobs=0 $(ARGS) vulture: ## Find unused code @git ls-files '*.py' | xargs $(PYTHON) -m vulture $(ARGS) # =================================================================== # Fixers # =================================================================== fix-black: @git ls-files '*.py' | xargs $(PYTHON) -m black fix-ruff: @git ls-files '*.py' | xargs $(PYTHON) -m ruff check --fix --output-format=concise $(ARGS) fix-c: @git ls-files '*.c' '*.h' | xargs -P0 -I{} clang-format -i {} # parallel exec fix-toml: ## Fix pyproject.toml @git ls-files '*.toml' | xargs toml-sort fix-dprint: @$(DPRINT) fmt fix-all: ## Run all code fixers. $(MAKE) fix-ruff $(MAKE) fix-black $(MAKE) fix-toml $(MAKE) fix-dprint # =================================================================== # CI jobs # =================================================================== ci-lint: ## Run all linters on GitHub CI. $(MAKE) install-pydeps-lint curl -fsSL https://dprint.dev/install.sh | sh $(DPRINT) --version clang-format --version $(MAKE) lint-all ci-test: ## Run tests on GitHub CI. Used by BSD runners. $(MAKE) install-sysdeps $(MAKE) install-pydeps-test $(MAKE) build $(MAKE) print-sysinfo $(MAKE) test $(MAKE) test-memleaks ci-test-cibuildwheel: ## Run CI tests for the built wheels. $(MAKE) install-sysdeps $(MAKE) install-pydeps-test $(MAKE) print-sysinfo # Tests must be run from a separate directory so pytest does not import # from the source tree and instead exercises only the installed wheel. rm -rf .tests tests/__pycache__ mkdir -p .tests cp -r tests .tests/ cd .tests/ && PYTHONPATH=$$(pwd) $(PYTHON_ENV_VARS) $(PYTHON) -m pytest cd .tests/ && PYTHONPATH=$$(pwd) $(PYTHON_ENV_VARS) PYTHONMALLOC=malloc $(PYTHON) -m pytest -k test_memleaks.py ci-check-dist: ## Run all sanity checks re. to the package distribution. $(PYTHON) -m pip install -U setuptools virtualenv twine check-manifest validate-pyproject[all] abi3audit $(MAKE) create-sdist mv wheelhouse/* dist/ $(MAKE) check-dist $(MAKE) install $(MAKE) print-dist # =================================================================== # Distribution # =================================================================== # --- 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.token $(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) check-manifest $(MAKE) check-pyproject $(MAKE) check-sdist $(MAKE) 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 release-`python3 -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 (supposed to be more precise) $(PYTHON) scripts/internal/bench_oneshot_2.py find-broken-links: ## Look for broken links in source files. git ls-files | xargs $(PYTHON) -Wa scripts/internal/find_broken_links.py help: ## Display callable targets. @awk -F':.*?## ' '/^[a-zA-Z0-9_.-]+:.*?## / {printf "\033[36m%-24s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST) | sort ================================================ FILE: README.rst ================================================ | |downloads| |stars| |forks| |contributors| |packages| | |version| |license| |stackoverflow| |twitter| |tidelift| | |github-actions-wheels| |github-actions-bsd| .. |downloads| image:: https://img.shields.io/pypi/dm/psutil.svg :target: https://clickpy.clickhouse.com/dashboard/psutil :alt: Downloads .. |stars| image:: https://img.shields.io/github/stars/giampaolo/psutil.svg :target: https://github.com/giampaolo/psutil/stargazers :alt: Github stars .. |forks| image:: https://img.shields.io/github/forks/giampaolo/psutil.svg :target: https://github.com/giampaolo/psutil/network/members :alt: Github forks .. |contributors| image:: https://img.shields.io/github/contributors/giampaolo/psutil.svg :target: https://github.com/giampaolo/psutil/graphs/contributors :alt: Contributors .. |stackoverflow| image:: https://img.shields.io/badge/stackoverflow-Ask%20questions-blue.svg :target: https://stackoverflow.com/questions/tagged/psutil :alt: Stackoverflow .. |github-actions-wheels| image:: https://img.shields.io/github/actions/workflow/status/giampaolo/psutil/.github/workflows/build.yml.svg?label=Linux%2C%20macOS%2C%20Windows :target: https://github.com/giampaolo/psutil/actions?query=workflow%3Abuild :alt: Linux, macOS, Windows .. |github-actions-bsd| image:: https://img.shields.io/github/actions/workflow/status/giampaolo/psutil/.github/workflows/bsd.yml.svg?label=BSD :target: https://github.com/giampaolo/psutil/actions?query=workflow%3Absd-tests :alt: FreeBSD, NetBSD, OpenBSD .. |version| image:: https://img.shields.io/pypi/v/psutil.svg?label=pypi :target: https://pypi.org/project/psutil :alt: Latest version .. |packages| image:: https://repology.org/badge/tiny-repos/python:psutil.svg :target: https://repology.org/metapackage/python:psutil/versions :alt: Binary packages .. |license| image:: https://img.shields.io/pypi/l/psutil.svg :target: https://github.com/giampaolo/psutil/blob/master/LICENSE :alt: License .. |twitter| image:: https://img.shields.io/twitter/follow/grodola?style=flat :target: https://twitter.com/grodola :alt: Twitter Follow .. |tidelift| image:: https://tidelift.com/badges/github/giampaolo/psutil?style=flat :target: https://tidelift.com/subscription/pkg/pypi-psutil?utm_source=pypi-psutil&utm_medium=referral&utm_campaign=readme :alt: Tidelift ----- .. raw:: html


Home    Documentation    Who uses psutil    Download    Blog    Funding   
Summary ======= psutil (process and system utilities) 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 classic UNIX command line tools such as *ps, top, free, iotop, netstat, ifconfig, lsof* and others (see `shell equivalents`_). psutil currently supports the following platforms: - **Linux** - **Windows** - **macOS** - **FreeBSD, OpenBSD**, **NetBSD** - **Sun Solaris** - **AIX** .. Sponsors ======== .. raw:: html
add your logo .. Funding ======= While psutil is free software and will always remain so, the project would benefit immensely from some funding. psutil is among the `top 100`_ most-downloaded Python packages, and keeping up with bug reports, user support, and ongoing maintenance has become increasingly difficult to sustain as a one-person effort. If you're a company that's making significant use of psutil you can consider becoming a sponsor via `GitHub `_, `Open Collective `_ or `PayPal `_. Sponsors can have their logo displayed here and in the psutil `documentation `_. Projects using psutil ===================== psutil is one of the `top 100`_ most-downloaded packages on PyPI, with 280+ million downloads per month, `760,000+ GitHub repositories `_ using it, and 14,000+ packages depending on it. Some notable projects using psutil: - `TensorFlow `_, `PyTorch `_, - `Home Assistant `_, `Ansible `_, `Apache Airflow `_, `Sentry `_ - `Celery `_, `Dask `_ - `Glances `_, `bpytop `_, `Ajenti `_, `GRR `_ - `psleak`_ `Full list `_ Ports ===== - Go: `gopsutil `_ - C: `cpslib `_ - Rust: `rust-psutil `_ - Nim: `psutil-nim `_ .. Supporters ========== People who donated money over the years: .. raw:: html
add your avatar .. ---- Example usages ============== Below are interactive examples demonstrating all parts of the psutil API, including CPU, memory, disks, network, sensors, and process management. 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, 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) 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) >>> psutil.swap_memory() sswap(total=2097147904, used=296128512, free=1801019392, percent=14.1, sin=304193536, sout=677842944) >>> 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')] >>> >>> 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 ------- .. 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(kind='tcp') [sconn(fd=115, family=, type=, 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=, type=, 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=, address='127.0.0.1', netmask='255.0.0.0', broadcast='127.0.0.1', ptp=None), snicaddr(family=, address='::1', netmask='ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', broadcast=None, ptp=None), snicaddr(family=, address='00:00:00:00:00:00', netmask=None, broadcast='00:00:00:00:00:00', ptp=None)], 'wlan0': [snicaddr(family=, address='192.168.1.3', netmask='255.255.255.0', broadcast='192.168.1.255', ptp=None), snicaddr(family=, address='fe80::c685:8ff:fe45:641%wlan0', netmask='ffff:ffff:ffff:ffff::', broadcast=None, ptp=None), snicaddr(family=, 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=, speed=0, mtu=65536, flags='up,loopback,running'), 'wlan0': snicstats(isup=True, duplex=, speed=100, mtu=1500, flags='up,broadcast,running,multicast')} >>> Sensors ------- .. code-block:: python >>> 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:: python >>> 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 >>> Process management ------------------ .. 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 psutil.Process(pid=7055, name='python3', status=, 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.ppid() 7054 >>> p.parent() psutil.Process(pid=4699, name='bash', status=, 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=, started='0:06:44'), psutil.Process(pid=1, name='systemd', status=, started='05:56:55')] >>> p.children(recursive=True) [psutil.Process(pid=29835, name='python3', status=, started='11:45:38'), psutil.Process(pid=29836, name='python3', status=, started='11:43:39')] >>> >>> p.status() >>> p.create_time() 1267551141.5019531 >>> p.terminal() '/dev/pts/0' >>> >>> p.username() 'giampaolo' >>> 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, 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.memory_info() pmem(rss=3164160, vms=4410163, shared=897433, text=302694, data=2422374) >>> p.memory_info_ex() pmem_ex(rss=3164160, vms=4410163, shared=897433, text=302694, data=2422374, peak_rss=4172190, peak_vms=6399001, rss_anon=2266726, rss_file=897433, rss_shmem=0, swap=0, hugetlb=0) >>> p.memory_footprint() # "real" USS memory usage pfootprint(uss=2355200, pss=2483712, swap=0) >>> p.memory_percent() 0.7823 >>> 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='[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.page_faults() ppagefaults(minor=5905, major=3) >>> >>> 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=, type=, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status=), pconn(fd=117, family=, type=, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status=)] >>> >>> 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 >>> p.num_fds() 8 >>> 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=, 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', ...} >>> >>> p.as_dict() {'status': , 'num_ctx_switches': pctxsw(voluntary=63, involuntary=1), 'pid': 5457, ...} >>> p.is_running() True >>> p.suspend() >>> p.resume() >>> >>> p.terminate() >>> p.kill() >>> p.wait(timeout=3) >>> >>> 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 ... 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 >>> import psutil >>> for proc in psutil.process_iter(['pid', 'name']): ... print(proc.info) ... {'pid': 1, 'name': 'systemd'} {'pid': 2, 'name': 'kthreadd'} {'pid': 3, 'name': 'ksoftirqd/0'} ... >>> >>> psutil.pid_exists(3) True >>> >>> 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) >>> Heap info --------- .. code-block:: python >>> import psutil >>> psutil.heap_info() pheap(heap_used=5177792, mmap_used=819200) >>> psutil.heap_trim() See also `psleak`_. Windows services ---------------- .. code-block:: python >>> list(psutil.win_service_iter()) [, , , , ...] >>> 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'} .. _`psleak`: https://github.com/giampaolo/psleak .. _`shell equivalents`: https://psutil.readthedocs.io/en/latest/shell_equivalents.html .. _`top 100`: https://clickpy.clickhouse.com/dashboard/psutil ================================================ FILE: SECURITY.md ================================================ # 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. ================================================ FILE: _bootstrap.py ================================================ # 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) ================================================ FILE: docs/.readthedocs.yaml ================================================ # .readthedocs.yaml # Read the Docs configuration file # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details version: 2 build: os: ubuntu-22.04 tools: python: "3.11" # Build documentation in the docs/ directory with Sphinx sphinx: configuration: docs/conf.py # RTD recommends specifying your dependencies to enable reproducible builds: # https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html python: install: - requirements: docs/requirements.txt ================================================ FILE: docs/DEVNOTES ================================================ 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 FEATURES ======== - (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 - 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.net_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. - round Process.memory_percent() result? BUGFIXES ======== - #600: windows / open_files(): support network file handles. REJECTED IDEAS ============== - #550: threads per core - #1667: process_iter(new_only=True) INCONSISTENCIES =============== - PROCFS_PATH should have been set_procfs_path(). - `virtual_memory()` should have been `memory_virtual()`. - `swap_memory()` should have been `memory_swap()`. RESOURCES ========= - conky: https://github.com/brndnmtthws/conky/ - 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/ - oshi: https://github.com/oshi/oshi - netdata: https://github.com/netdata/netdata STATS ===== - https://pepy.tech/projects/psutil - https://clickpy.clickhouse.com/dashboard/psutil - https://pypistats.org/packages/psutil ================================================ FILE: docs/Makefile ================================================ # Makefile for Sphinx documentation PYTHON = python3 SPHINXBUILD = $(PYTHON) -m sphinx BUILDDIR = _build ALLSPHINXOPTS = --fail-on-warning -d $(BUILDDIR)/doctrees . clean: ## Remove all build files rm -rf $(BUILDDIR) html: ## Generate doc in HTML format $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." singlehtml: ## Generate doc as a single HTML page $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." text: ## Generate doc in .txt format $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo "Build finished. The text files are in $(BUILDDIR)/text." auto-build: ## Rebuild HTML on file changes (requires inotify-tools) $(MAKE) clean $(MAKE) html while inotifywait -r -e modify,create,delete,move .; do $(MAKE) html; done check-links: ## Check links $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." help: ## Display callable targets. @awk -F':.*?## ' '/^[a-zA-Z0-9_.-]+:.*?## / {printf "\033[36m%-24s\033[0m %s\n", $$1, $$2}' $(MAKEFILE_LIST) | sort ================================================ FILE: docs/README ================================================ 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 http://psutil.readthedocs.io. 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. ================================================ FILE: docs/_ext/add_home_link.py ================================================ # 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 prepends a 'Home' link to the TOC sidebar. This script gets called on `make html`. """ from sphinx.application import Sphinx def add_home_link(app: Sphinx, pagename, templatename, context, doctree): if "toctree" in context: toctree_func = context["toctree"] toc_html = toctree_func( maxdepth=2, collapse=False, includehidden=False ) # prepend Home link manually home_link = '
  • Home
    • ' context["toctree"] = lambda **_kw: home_link + toc_html def setup(app: Sphinx): app.connect("html-page-context", add_home_link) ================================================ FILE: docs/_ext/availability.py ================================================ # 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 { "version": "1.0", "parallel_read_safe": True, "parallel_write_safe": True, } ================================================ FILE: docs/_ext/changelog_anchors.py ================================================ # 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 docs/changelog.rst. This script gets called on `make html`, and adds numeric anchors for version titles (e.g., 7.2.3 -> #723). """ import re from docutils import nodes VERSION_RE = re.compile(r"^(\d+\.\d+\.\d+)") def add_version_anchors(app, doctree, docname): if docname != "changelog": return for node in doctree.traverse(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) def setup(app): app.connect("doctree-resolved", add_version_anchors) ================================================ FILE: docs/_ext/check_python_syntax.py ================================================ # 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.traverse(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) 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) ================================================ FILE: docs/_links.rst ================================================ ================================================ FILE: docs/_static/copybutton.js ================================================ $(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 = $('>>>'); 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(''); }); // 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); }); }); ================================================ FILE: docs/_static/css/custom.css ================================================ /* ================================================================== */ /* Layout */ /* ================================================================== */ @media (min-width: 1200px) { .wy-nav-content { max-width: 1000px; padding-left: 20px !important; } } /* ================================================================== */ /* Navigation */ /* ================================================================== */ /* hide top navigation, keep footer navigation */ .rst-content > div[role="navigation"] { display: none; } footer div[role="navigation"][aria-label="Footer"] { display: block; } /* ================================================================== */ /* Sidebar */ /* ================================================================== */ .wy-side-nav-search { background-color: grey !important } /* ================================================================== */ /* Headings */ /* ================================================================== */ h1, h2, h3 { background: #eee; padding: 5px; border-bottom: 1px solid #ccc; } h1 { font-size: 35px; } /* ================================================================== */ /* Tables */ /* ================================================================== */ .wy-table-responsive table thead { background-color: #eeeeee; } .document th { padding: 4px 8px !important; font-weight: 600; } .document th p { margin-bottom: 0px !important; } .document td { padding: 4px 8px !important; } .document td p { margin-bottom: 0px !important; } /* "longtable" class (used by alternatives.rst): fixed layout with extra padding for multi-line cells */ .wy-table-responsive table.longtable { table-layout: fixed; width: 100%; } .wy-table-responsive table.longtable th, .wy-table-responsive table.longtable td { padding: 10px !important; white-space: normal !important; word-wrap: break-word; } /* adoption page logos */ .document td img[alt$="-logo"] { height: 20px !important; width: 20px !important; vertical-align: middle; } /* ================================================================== */ /* Lists */ /* ================================================================== */ .rst-content ul { margin-top: 0px !important; } .rst-content ul p { margin-bottom: 0px !important; } .rst-content li { list-style: outside; margin-left: 15px; } /* ================================================================== */ /* API signatures */ /* ================================================================== */ .rst-content dl:not(.docutils) { margin: 0px 0px 0px 0px !important; } .rst-content dl:not(.docutils) dt { color: #555; } .data dd { margin-bottom: 0px !important; } .data .descname { border-right:10px !important; } .function .descclassname, .class .descclassname { font-weight: normal !important; } .sig-paren { padding-left: 2px; padding-right: 2px; } /* ================================================================== */ /* Code blocks */ /* ================================================================== */ pre { padding: 5px !important; } .highlight { background: #eeffcc; } .highlight .hll { background-color: #ffffcc } .highlight .c { color: #408090; font-style: italic } .codeblock div[class^='highlight'], pre.literal-block div[class^='highlight'], .rst-content .literal-block div[class^='highlight'], div[class^='highlight'] div[class^='highlight'] { background-color: #eeffcc !important; } /* ================================================================== */ /* Links */ /* ================================================================== */ /* external links: dotted underline (except intersphinx) */ a.reference.external:not([href*="docs.python.org"]) { text-decoration: underline dotted; } a.reference.external:not([href*="docs.python.org"]):hover { text-decoration: underline solid; } a.external[href^="#"] { text-decoration: none; color: inherit; } /* ================================================================== */ /* Admonitions (note, warning, tip) - styled like python doc */ /* ================================================================== */ div.admonition { margin-top: 10px !important; margin-bottom: 10px !important; } div.warning { background-color: #ffe4e4 !important; border: 1px solid #f66 !important; border-radius: 3px !important; } div.note { background-color: #eee !important; border: 1px solid #ccc !important; border-radius: 3px !important; } div.tip { background-color: #dfd !important; border: 1px solid green !important; border-radius: 3px !important; } div.admonition p.admonition-title + p { display: inline !important; } p.admonition-title { display: inline !important; background: none !important; color: black !important; } p.admonition-title:after { content: ":" !important; } /* hide admonition icons */ .fa-exclamation-circle:before, .wy-inline-validate.wy-inline-validate-warning .wy-input-context:before, .wy-inline-validate.wy-inline-validate-info .wy-input-context:before, .rst-content .admonition-title:before { display: none !important; } .admonition.warning { padding-top: 5px !important; padding-bottom: 5px !important; } .admonition.warning p { margin-bottom: 5px !important; } .admonition.note { padding-top: 5px !important; padding-bottom: 5px !important; } .admonition.note p { margin-bottom: 5px !important; } .note code { background: #d6d6d6 !important; } /* ================================================================== */ /* Version directives (versionadded / versionchanged / deprecated) */ /* ================================================================== */ div.versionadded, div.versionchanged, div.deprecated { border-left: 3px solid; padding: 0 1rem; } div.versionadded { border-left-color: rgb(79, 196, 100); } div.versionchanged { border-left-color: rgb(244, 227, 76); } div.deprecated { border-left-color: rgb(244, 76, 78); } div.versionadded .versionmodified { color: rgb(41, 100, 51); } div.versionchanged .versionmodified { color: rgb(133, 72, 38); } div.deprecated .versionmodified { color: rgb(159, 49, 51); } ================================================ FILE: docs/_static/sidebar.js ================================================ /* * 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( '
    «
    ' ); 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 {% endblock %} ================================================ FILE: docs/adoption.rst ================================================ .. currentmodule:: psutil Who uses psutil =============== psutil is among the `top 100 `__ most-downloaded packages on PyPI, with 280+ million downloads per month, `760,000+ GitHub repositories `__ using it, and 14,000+ packages depending on it. The projects below are a small sample of notable software that depends on it. 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 * - |homeassistant-logo| `Home Assistant `__ - Open source home automation platform - |homeassistant-stars| - system monitor integration * - |ansible-logo| `Ansible `__ - IT automation platform - |ansible-stars| - system fact gathering * - |airflow-logo| `Apache Airflow `__ - Workflow orchestration platform - |airflow-stars| - process supervisor, unit testing * - |celery-logo| `Celery `__ - Distributed task queue - |celery-stars| - worker process monitoring, memleak detection * - |salt-logo| `Salt `__ - Infrastructure automation at scale - |salt-stars| - deep system data collection (grains) * - |dask-logo| `Dask `__ - Parallel computing with task scheduling - |dask-stars| - `metrics dashboard `__, profiling * - |ajenti-logo| `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-logo| `TensorFlow `__ - Open source machine learning framework by Google - |tensorflow-stars| - unit tests * - |pytorch-logo| `PyTorch `__ - Tensors and dynamic neural networks with GPU acceleration - |pytorch-stars| - benchmark scripts * - |ray-logo| `Ray `__ - AI compute engine with distributed runtime - |ray-stars| - metrics dashboard * - |mlflow-logo| `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-logo| `Sentry `__ - Error tracking and performance monitoring - |sentry-stars| - send telemetry metrics * - |locust-logo| `Locust `__ - Scalable load testing in Python - |locust-stars| - monitoring of the Locust process * - |spyder-logo| `Spyder `__ - Scientific Python IDE - |spyder-stars| - deep integration, UI stats, process management * - |psleak-logo| `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-logo| `Glances `__ - System monitoring tool (top/htop alternative) - |glances-stars| - core dependency for all metrics * - |bpytop-logo| `bpytop `__ - Terminal resource monitor - |bpytop-stars| - core dependency for all metrics * - |auto-cpufreq-logo| `auto-cpufreq `__ - Automatic CPU speed and power optimizer for Linux - |auto-cpufreq-stars| - core dependency for CPU monitoring * - |grr-logo| `GRR `__ - Remote live forensics by Google - |grr-stars| - endpoint system data collection, deep integration * - |stui-logo| `s-tui `__ - Terminal CPU stress and monitoring utility - |stui-stars| - core dependency for metrics * - |asitop-logo| `asitop `__ - Apple Silicon performance monitoring CLI - |asitop-stars| - core dependency for system metrics * - |psdash-logo| `psdash `__ - Web dashboard using psutil and Flask - |psdash-stars| - core dependency for all metrics * - |dd-agent-logo| `dd-agent `__ - Original monitoring agent by Datadog - |dd-agent-stars| - system metrics collection * - |ddtrace-logo| `dd-trace-py `__ - Python tracing and profiling library - |ddtrace-stars| - system metrics collection How this list was compiled -------------------------- - `GitHub dependency graph `__ 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 `__ 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 .. Logo images .. ============================================================================ .. |airflow-logo| image:: https://github.com/apache.png?s=28 :height: 28 .. |ajenti-logo| image:: https://github.com/ajenti.png?s=28 :height: 28 .. |ansible-logo| image:: https://github.com/ansible.png?s=28 :height: 28 .. |asitop-logo| image:: https://github.com/tlkh.png?s=28 :height: 28 .. |auto-cpufreq-logo| image:: https://github.com/AdnanHodzic.png?s=28 :height: 28 .. |bpytop-logo| image:: https://github.com/aristocratos.png?s=28 :height: 28 .. |celery-logo| image:: https://github.com/celery.png?s=28 :height: 28 .. |dask-logo| image:: https://github.com/dask.png?s=28 :height: 28 .. |ddtrace-logo| image:: https://github.com/DataDog.png?s=28 :height: 28 .. |dd-agent-logo| image:: https://github.com/DataDog.png?s=28 :height: 28 .. |glances-logo| image:: https://github.com/nicolargo.png?s=28 :height: 28 .. |grr-logo| image:: https://github.com/google.png?s=28 :height: 28 .. |homeassistant-logo| image:: https://github.com/home-assistant.png?s=28 :height: 28 .. |locust-logo| image:: https://github.com/locustio.png?s=28 :height: 28 .. |mlflow-logo| image:: https://github.com/mlflow.png?s=28 :height: 28 .. |osquery-logo| image:: https://github.com/osquery.png?s=28 :height: 28 .. |psdash-logo| image:: https://github.com/Jahaja.png?s=28 :height: 28 .. |psleak-logo| image:: https://github.com/giampaolo.png?s=28 :height: 28 .. |pytorch-logo| image:: https://github.com/pytorch.png?s=28 :height: 28 .. |ray-logo| image:: https://github.com/ray-project.png?s=28 :height: 28 .. |salt-logo| image:: https://github.com/saltstack.png?s=28 :height: 28 .. |sentry-logo| image:: https://github.com/getsentry.png?s=28 :height: 28 .. |spyder-logo| image:: https://github.com/spyder-ide.png?s=28 :height: 28 .. |stui-logo| image:: https://github.com/amanusk.png?s=28 :height: 28 .. |tensorflow-logo| image:: https://github.com/tensorflow.png?s=28 :height: 28 .. --- Notes .. Stars shield: .. https://shields.io/badges/git-hub-repo-stars ================================================ FILE: docs/alternatives.rst ================================================ .. currentmodule:: psutil 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 ----------------------- 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 natively UNIX-only. Things like process CPU and memory usage, open file descriptors, network connections, signals, 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 integers. 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 ``ps``, ``top``, ``netstat``, ``vmstat`` via :mod:`subprocess` and parsing the text 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/pid/status`` or ``/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 (numeric overflow, compatibility with old kernels, graceful fallbacks, etc.) transparently. 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 `_ - Linux distro info (name, version, codename). psutil does not expose OS details. * - `GPUtil `_ / `pynvml `_ - NVIDIA GPU utilization and VRAM usage. * - `ifaddr `_ - Network interface address enumeration. Overlaps with :func:`net_if_addrs`. * - `libvirt-python `_ - Manage KVM/QEMU/Xen VMs: enumerate guests, query CPU/memory allocation. Complements psutil's host-level view. * - `prometheus_client `_ - Export metrics to Prometheus. Use *alongside* psutil. * - `py-cpuinfo `_ - CPU brand string, microarchitecture, feature flags. * - `pyroute2 `_ - Linux netlink (interfaces, routes, connections). Overlaps with :func:`net_if_addrs`, :func:`net_if_stats`, :func:`net_connections`. * - `pywifi `_ - WiFi scanning, signal strength, SSID. Exposes wireless details that :func:`net_if_addrs` does not. * - `pySMART `_ - S.M.A.R.T. disk health data. Complements :func:`disk_io_counters`. * - `pywin32 `_ - Win32 API bindings (Windows only). * - `setproctitle `_ - Set process title shown by ``ps``/``top``. Writes what :meth:`Process.name` reads. * - `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 `_ - Go - CPU, memory, disk, network, processes. Directly inspired by psutil and follows a similar API. * - `Hardware.Info `_ - C# / .NET - CPU, RAM, GPU, disk, network, battery. * - `hwinfo `_ - C++ - CPU, RAM, GPU, disks, mainboard. More hardware-focused. * - `OSHI `_ - Java - OS and hardware information: CPU, memory, disk, network, processes, sensors, USB devices. * - `sysinfo `_ - Rust - CPU, memory, disk, network, processes, components. * - `systeminformation `_ - Node.js - CPU, memory, disk, network, processes, battery, Docker. ================================================ FILE: docs/api.rst ================================================ .. currentmodule:: psutil .. include:: _links.rst .. _availability: API reference ============= .. note:: psutil 8.0 introduces breaking API changes. See the :ref:`migration guide ` if upgrading from 7.x. .. contents:: :local: :depth: 5 System related functions ------------------------ CPU ^^^ .. function:: cpu_times(percpu=False) Return system CPU times as a named tuple. All fields are :term:`cumulative counters ` (seconds) representing time the CPU has spent in each mode since boot. The attributes availability varies depending on the platform. Cross-platform fields: - **user**: time spent by normal processes executing in user mode; on Linux this also includes **guest** time - **system**: time spent by processes executing in kernel mode - **idle**: time spent doing nothing Platform-specific fields: - **nice** *(Linux, macOS, BSD)*: time spent by :term:`niced ` (lower-priority) processes executing in user mode; on Linux this also includes **guest_nice** time. - **iowait** *(Linux, SunOS, AIX)*: time spent waiting for I/O to complete (:term:`iowait`). This is *not* accounted in **idle** time counter. - **irq** *(Linux, Windows, BSD)*: time spent for servicing :term:`hardware interrupts ` - **softirq** *(Linux)*: time spent for servicing :term:`soft interrupts ` - **steal** *(Linux)*: CPU time the virtual machine wanted to run but was used by other virtual machines or the host. A sustained non-zero steal rate indicates CPU contention. - **guest** *(Linux)*: time the host CPU spent running a guest operating system (virtual machine). Already included in **user** time. - **guest_nice** *(Linux)*: like **guest**, but for virtual CPUs running at a lower :term:`nice` priority. Already included in **nice** time. - **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 of named tuples for each logical CPU on the system. The list is ordered by CPU index. The order of the list is consistent across calls. Example output on Linux: .. 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 `_. .. versionchanged:: 4.1.0 added *irq* and *dpc* fields on Windows (*irq* was called *interrupt* before 8.0.0). .. versionchanged:: 8.0.0 *interrupt* field on Windows was renamed to *irq*; *interrupt* still works but raises :exc:`DeprecationWarning`. .. versionchanged:: 8.0.0 ``cpu_times()`` field order was standardized: ``user``, ``system``, ``idle`` are now always the first three fields. Previously on Linux, macOS, and BSD the first three were ``user``, ``nice``, ``system``. See :ref:`migration guide `. .. 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 it 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. The list is ordered by CPU index. The order of the list is consistent across calls. Internally this function maintains a global map (a dict) where each key is the ID of the calling thread (:func:`threading.get_ident`). This means it can be called from different threads, at different intervals, and still return meaningful and independent results. .. 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) [2.0, 1.0] >>> .. note:: 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. See also :ref:`faq_cpu_percent` FAQ. .. versionchanged:: 5.9.6 the function is now thread safe. .. 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)`. *interval* and *percpu* arguments have the same meaning as in :func:`cpu_percent`. On Linux "guest" and "guest_nice" percentages are not accounted in "user" and "user_nice" percentages. .. note:: 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. See also :ref:`faq_cpu_percent` FAQ. .. versionchanged:: 4.1.0 two new *irq* and *dpc* fields are returned on Windows (*irq* was called *interrupt* before 8.0.0). .. versionchanged:: 5.9.6 function is now thread safe. .. function:: cpu_count(logical=True) Return the number of :term:`logical CPUs ` in the system (similar to :func:`os.cpu_count`) or ``None`` if undetermined. Unlike :func:`os.cpu_count`, this is not influenced by the ``PYTHON_CPU_COUNT`` environment variable introduced in Python 3.13. "logical CPUs" means the number of physical cores multiplied by the number of threads that can run on each core (this is known as Hyper Threading). This is what cloud providers often refer to as vCPUs. If *logical* is ``False`` return the number of physical cores only, or ``None`` if undetermined. On OpenBSD and NetBSD ``psutil.cpu_count(logical=False)`` always return ``None``. Example on a system having 2 cores + Hyper Threading: .. code-block:: pycon >>> import psutil >>> psutil.cpu_count() 4 >>> psutil.cpu_count(logical=False) 2 Note that ``psutil.cpu_count()`` may not necessarily be equivalent to the actual number of CPUs the current process can use. That can vary in case process CPU affinity has been changed, Linux cgroups are being used or (in case of Windows) on systems using processor groups or having more than 64 CPUs. The number of usable CPUs can be obtained with: .. code-block:: pycon >>> len(psutil.Process().cpu_affinity()) 1 .. function:: cpu_stats() Return various CPU statistics as a named tuple. All fields are :term:`cumulative counters ` since boot. - **ctx_switches**: number of :term:`context switches ` (voluntary + involuntary). - **interrupts**: number of :term:`hardware interrupts `. - **soft_interrupts**: number of :term:`soft interrupts `. Always set to ``0`` on Windows and SunOS. - **syscalls**: number of system calls. 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 .. function:: cpu_freq(percpu=False) Return CPU frequency as a named tuple including *current*, *min* and *max* frequencies expressed in Mhz. On Linux *current* frequency reports the real-time value, 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 *min* and *max* cannot be determined they are set to ``0.0``. Example (Linux): .. code-block:: python >>> 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. .. versionadded:: 5.1.0 .. versionchanged:: 5.5.1 added FreeBSD support. .. versionchanged:: 5.9.1 added OpenBSD support. .. function:: getloadavg() Return the average system load over the last 1, 5 and 15 minutes as a tuple. The "load" represents the processes which are in a runnable state, either using the CPU or waiting to use the CPU (e.g. waiting for disk I/O). On UNIX systems this relies on :func:`os.getloadavg`. 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. Thus, on Windows, the first time this is called and for the next 5 seconds it will return a meaningless ``(0.0, 0.0, 0.0)`` tuple. The numbers returned only make sense when compared to the number of CPU cores installed on the system. So, for instance, a value of `3.14` on a system with 10 logical CPUs means that the system load was 31.4% percent over the last N minutes. .. code-block:: python >>> 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] .. versionadded:: 5.6.2 Memory ^^^^^^ .. function:: virtual_memory() Return statistics about system memory usage as a named tuple including the following fields, expressed in bytes. - **total**: total physical memory (exclusive swap). - **available**: memory that can be given instantly to processes without the system going into swap. On Linux it uses the ``MemAvailable`` field from ``/proc/meminfo`` *(kernel 3.14+)*; on older kernels it falls back to an estimate. This is the recommended field for monitoring actual memory usage in a cross-platform fashion. See :term:`available memory`. - **percent**: the percentage usage calculated as ``(total - available) / total * 100``. - **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``. - **free**: memory not currently allocated to anything. This is typically much lower than **available** because the OS keeps recently freed memory as reclaimable cache (see **cached** and **buffers**) rather than zeroing it immediately. Do not use this to check for memory pressure; use **available** instead. - **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. - **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 swapping. On BSD systems it is counted in **available**. - **buffers** *(Linux, BSD)*: memory used by the kernel to cache disk metadata (e.g. filesystem structures). Reclaimable by the OS when needed. - **cached** *(Linux, BSD, Windows)*: RAM used by the kernel to cache file contents (data read from or written to disk). Reclaimable by the OS when needed. See :term:`page cache`. - **shared** *(Linux, BSD)*: 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/meminfo`` and is already counted within **active** / **inactive**. - **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 **cached**. - **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/meminfo`_. On macOS via ``host_statistics64()``. On Windows via `GetPerformanceInfo`_. .. list-table:: :header-rows: 1 :widths: 9 15 14 14 26 * - 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:: if you just want to know how much physical memory is left in a cross-platform manner, simply rely on **available** and **percent** fields. .. note:: - On Linux, **total**, **free**, **used**, **shared**, and **available** match the output of the ``free`` command. - On macOS, **free**, **active**, **inactive**, and **wired** match ``vm_stat`` output. - On Windows, **total**, **used** ("In use"), and **available** match the Task Manager (Performance > Memory tab). .. note:: see also `scripts/meminfo.py`_. .. versionchanged:: 4.2.0 added *shared* metric on Linux. .. versionchanged:: 5.4.4 added *slab* metric on Linux. .. versionchanged:: 8.0.0 added *cached* and *wired* metric on Windows. .. function:: swap_memory() Return system swap memory statistics as a named tuple including the following fields: * **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. * **used**: swap space currently in use. * **free**: swap space not in use (``total - used``). * **percent**: swap usage as a percentage, calculated as ``used / total * 100``. * **sin**: number of bytes the system has paged *in* from disk (pages moved from swap space back into RAM) since boot. See :term:`swap-in`. * **sout**: number of bytes the system has paged *out* to disk (pages moved from RAM into swap space) since boot. A continuously increasing **sout** is a sign of memory pressure. See :term:`swap-out`. **sin** and **sout** are :term:`cumulative counters ` since boot; monitor their rate of change rather than the absolute value to detect active swapping. See :term:`swap-in` and :term:`swap-out`. On Windows both are always ``0``. See `scripts/meminfo.py`_ script providing an example on how to convert bytes in a human readable form. .. code-block:: pycon >>> import psutil >>> psutil.swap_memory() sswap(total=2097147904L, used=886620160L, free=1210527744L, percent=42.3, sin=1050411008, sout=1906720768) .. versionchanged:: 5.2.3 on Linux this function relies on /proc fs instead of sysinfo() syscall so that it can be used in conjunction with :const:`psutil.PROCFS_PATH` in order to retrieve memory info about Linux containers such as Docker and Heroku. Disks ^^^^^ .. function:: disk_partitions(all=False) Return all mounted disk partitions as a list of named tuples including device, mount point and filesystem type, similarly to "df" command on UNIX. If *all* parameter is ``False`` it tries to distinguish and return physical devices only (e.g. hard disks, cd-rom drives, USB keys) and ignore all others (e.g. pseudo, memory, duplicate, inaccessible filesystems). Note that this may not be fully reliable on all systems (e.g. on BSD this parameter is ignored). See `scripts/disk_usage.py`_ script providing an example usage. Returns a list of named tuples with the following fields: * **device**: the device path (e.g. ``"/dev/hda1"``). On Windows this is the drive letter (e.g. ``"C:\\"``). * **mountpoint**: the mount point path (e.g. ``"/"``). On Windows this is the drive letter (e.g. ``"C:\\"``). * **fstype**: the partition filesystem (e.g. ``"ext3"`` on UNIX or ``"NTFS"`` on Windows). * **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')] .. versionchanged:: 5.7.4 added *maxfile* and *maxpath* fields. .. versionchanged:: 6.0.0 removed *maxfile* and *maxpath* fields. .. function:: disk_usage(path) Return disk usage statistics about the partition which contains the given *path* as a named tuple including **total**, **used** and **free** space expressed in bytes, plus the **percentage** usage. ``OSError`` is raised if *path* does not exist. Starting from Python 3.3 this is also available as :func:`shutil.disk_usage` (see `BPO-12442`_). See `scripts/disk_usage.py`_ script providing an example usage. .. code-block:: pycon >>> 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 `_). 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, nowrap=True) Return system-wide 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 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). See :term:`busy_time`. - **read_merged_count** (*Linux*): number of merged reads (see `iostats doc`_) - **write_merged_count** (*Linux*): number of merged writes (see `iostats doc`_) 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 named tuple described above as the values. See `scripts/iotop.py`_ for an example application. On some systems such as Linux, on a very busy or long-lived system, the numbers returned by the kernel may overflow and wrap (restart from zero). If *nowrap* is ``True`` psutil will detect and adjust those numbers across function calls and add "old value" to "new value" so that the returned numbers will always be increasing or remain the same, but never decrease. ``disk_io_counters.cache_clear()`` can be used to invalidate the *nowrap* cache. On Windows it may be necessary to issue ``diskperf -y`` command from cmd.exe first in order to enable IO counters. 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 ``"diskperf -y"`` command may need to be executed first otherwise this function won't find any disk. .. versionchanged:: 5.3.0 numbers no longer wrap (restart from zero) across calls thanks to new *nowrap* argument. .. 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, nowrap=True) Return system-wide network I/O statistics as a named tuple 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 macOS and BSD). See :term:`dropin / dropout`. 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 named tuple described above as the values. On some systems such as Linux, on a very busy or long-lived system, the numbers returned by the kernel may overflow and wrap (restart from zero). If *nowrap* is ``True`` psutil will detect and adjust those numbers across function calls and add "old value" to "new value" so that the returned numbers will always be increasing or remain the same, but never decrease. ``net_io_counters.cache_clear()`` can be used to invalidate the *nowrap* cache. On machines with no network interfaces 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)} Also see `scripts/nettop.py`_ and `scripts/ifconfig.py`_ for an example application. .. versionchanged:: 5.3.0 numbers no longer wrap (restart from zero) across calls thanks to new *nowrap* argument. .. function:: net_connections(kind='inet') Return system-wide socket connections as a list of named tuples. Every named tuple provides 7 attributes: - **fd**: the socket file descriptor. If the connection refers to the current process this may be passed to :func:`socket.fromfd` to obtain a usable socket object. On Windows and SunOS this is always set to ``-1``. - **family**: the address family, either :data:`socket.AF_INET`, :data:`socket.AF_INET6` or :data:`socket.AF_UNIX`. - **type**: the address type, either :data:`socket.SOCK_STREAM`, :data:`socket.SOCK_DGRAM` or :data:`socket.SOCK_SEQPACKET`. - **laddr**: the local address as a ``(ip, port)`` named tuple or a ``path`` in case of AF_UNIX sockets. For UNIX sockets see notes below. - **raddr**: the remote address as a ``(ip, port)`` named 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 ``""`` (AF_UNIX). For UNIX sockets see notes below. - **status**: represents the status of a TCP connection. The return value is one of the `psutil.CONN_* <#connections-constants>`_ 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 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 | +----------------+-----------------------------------------------------+ On macOS and AIX this function requires root privileges. To get per-process connections use :meth:`Process.net_connections`. Also, see `scripts/netstat.py`_ example script. Example: .. code-block:: pycon >>> import psutil >>> psutil.net_connections() [pconn(fd=115, family=, type=, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status=, pid=1254), pconn(fd=117, family=, type=, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status=, pid=2987), pconn(fd=-1, family=, type=, laddr=addr(ip='10.0.0.1', port=60759), raddr=addr(ip='72.14.234.104', port=80), status=, pid=None), pconn(fd=-1, family=, type=, laddr=addr(ip='10.0.0.1', port=51314), raddr=addr(ip='72.14.234.83', port=443), status=, 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:: (macOS and AIX) :exc:`psutil.AccessDenied` is always raised unless running as root. This is a limitation of the OS and ``lsof`` does the same. .. note:: (Solaris) UNIX sockets are not supported. .. note:: (Linux, FreeBSD, OpenBSD) *raddr* field for UNIX sockets is always set to ``""`` (empty string). This is a limitation of the OS. .. versionadded:: 2.1.0 .. versionchanged:: 5.3.0 socket "fd" is now set for real instead of being ``-1``. .. versionchanged:: 5.3.0 *laddr* and *raddr* are named tuples. .. versionchanged:: 5.9.5 OpenBSD: retrieve *laddr* path for AF_UNIX sockets (before it was an empty string). .. versionchanged:: 8.0.0 *status* field is now a :class:`psutil.ConnectionStatus` enum member instead of a plain ``str``. See :ref:`migration guide `. .. function:: net_if_addrs() Return the addresses associated to each :term:`NIC` (network interface card) installed on the system as a dictionary whose keys are the NIC names and value is a list of named tuples for each address assigned to the NIC. Each named tuple includes 5 fields: - **family**: the address family, either :data:`socket.AF_INET` or :data:`socket.AF_INET6` or :const:`psutil.AF_LINK`, which refers to a MAC address. - **address**: the primary NIC address (always set). - **netmask**: the netmask address (may be ``None``). - **broadcast**: the broadcast address (may be ``None``). - **ptp**: stands for "point to point"; it's the destination address on a point to point interface (typically a VPN). *broadcast* and *ptp* are mutually exclusive. May be ``None``. .. code-block:: pycon >>> import psutil >>> psutil.net_if_addrs() {'lo': [snicaddr(family=, address='127.0.0.1', netmask='255.0.0.0', broadcast='127.0.0.1', ptp=None), snicaddr(family=, address='::1', netmask='ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', broadcast=None, ptp=None), snicaddr(family=, address='00:00:00:00:00:00', netmask=None, broadcast='00:00:00:00:00:00', ptp=None)], 'wlan0': [snicaddr(family=, address='192.168.1.3', netmask='255.255.255.0', broadcast='192.168.1.255', ptp=None), snicaddr(family=, address='fe80::c685:8ff:fe45:641%wlan0', netmask='ffff:ffff:ffff:ffff::', broadcast=None, ptp=None), snicaddr(family=, address='c4:85:08:45:06:41', netmask=None, broadcast='ff:ff:ff:ff:ff:ff', ptp=None)]} >>> See also `scripts/nettop.py`_ and `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 `_ 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:: *broadcast* and *ptp* are not supported on Windows and are always ``None``. .. versionadded:: 3.0.0 .. versionchanged:: 3.2.0 *ptp* field was added. .. versionchanged:: 4.4.0 added support for *netmask* field on Windows which is no longer ``None``. .. versionchanged:: 7.0.0 added support for *broadcast* field on Windows which is no longer ``None``. .. function:: net_if_stats() Return information about each :term:`NIC` (network interface card) installed on the system as a dictionary whose keys are the NIC names and value is a named tuple with the following fields: - **isup**: a bool indicating whether the NIC is up and running (meaning ethernet cable or Wi-Fi is connected). - **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 megabits (Mbps), if it can't be determined (e.g. 'localhost') it will be set to ``0``. - **mtu**: NIC's maximum transmission unit expressed in bytes. - **flags**: a string of comma-separated flags on the interface (may be an empty string). Possible flags are: ``up``, ``broadcast``, ``debug``, ``loopback``, ``pointopoint``, ``notrailers``, ``running``, ``noarp``, ``promisc``, ``allmulti``, ``master``, ``slave``, ``multicast``, ``portsel``, ``dynamic``, ``oactive``, ``simplex``, ``link0``, ``link1``, ``link2``, and ``d2`` (some flags are only available on certain platforms). Also see `scripts/nettop.py`_ and `scripts/ifconfig.py`_ for an example application. .. code-block:: pycon >>> import psutil >>> psutil.net_if_stats() {'eth0': snicstats(isup=True, duplex=, speed=100, mtu=1500, flags='up,broadcast,running,multicast'), 'lo': snicstats(isup=True, duplex=, speed=0, mtu=65536, flags='up,loopback,running')} .. availability:: UNIX .. versionadded:: 3.0.0 .. versionchanged:: 5.7.3 `isup` on UNIX also checks whether the NIC is running. .. versionchanged:: 5.9.3 *flags* field was added on POSIX. Sensors ^^^^^^^ .. function:: sensors_temperatures(fahrenheit=False) Return hardware temperatures. Each entry is a named tuple representing a certain hardware temperature 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``. If sensors are not supported by the OS an empty dict is returned. Each named tuple includes 4 fields: - **label**: a string label for the sensor, if available, else ``""``. - **current**: current temperature, or ``None`` if not available. - **high**: temperature at which the system will throttle, or ``None`` if not available. - **critical**: temperature at which the system will shut down, or ``None`` if not available. See also `scripts/temperatures.py`_ and `scripts/sensors.py`_ for an example application. .. 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)]} .. availability:: Linux, FreeBSD .. versionadded:: 5.1.0 .. versionchanged:: 5.5.0 added FreeBSD support. .. function:: sensors_fans() Return hardware fans speed. Each entry is a named tuple representing a certain hardware sensor fan. Fan speed is expressed in RPM (revolutions per minute). If sensors are not supported by the OS an empty dict is returned. .. code-block:: pycon >>> import psutil >>> psutil.sensors_fans() {'asus': [sfan(label='cpu_fan', current=3200)]} See also `scripts/fans.py`_ and `scripts/sensors.py`_ for an example application. .. availability:: Linux .. versionadded:: 5.2.0 .. function:: sensors_battery() Return battery status information as a named tuple including the following values. If no battery is installed or metrics can't be determined ``None`` is returned. - **percent**: battery power left as a percentage. - **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:`psutil.POWER_TIME_UNLIMITED `. If it can't be determined it is set to :data:`psutil.POWER_TIME_UNKNOWN `. - **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 See also `scripts/battery.py`_ and `scripts/sensors.py`_ for an example application. .. availability:: Linux, Windows, macOS, FreeBSD .. versionadded:: 5.1.0 .. versionchanged:: 5.4.2 added macOS support. ---- 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 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). .. code-block:: python >>> 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' .. note:: on Windows this function may return a time which is off by 1 second if it's used across different processes (see issue :gh:`1007`). .. function:: users() Return users currently connected on the system as a list of named tuples including the following fields: - **name**: 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, else ``None``. - **started**: the creation time as a floating point number expressed in seconds since the epoch. - **pid**: the PID of the login process (like sshd, tmux, gdm-session-worker, ...). On Windows and OpenBSD this is always set to ``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)] .. versionchanged:: 5.3.0 added "pid" field. ---- Processes --------- Functions ^^^^^^^^^ .. function:: pids() Return a sorted list of current running PIDs. To iterate over all processes and avoid race conditions :func:`process_iter` should be preferred. .. 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` class instance for all running processes on the local machine. 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` result will be stored as a ``info`` attribute attached to the returned :class:`Process` instances. If *attrs* is an empty list it will retrieve all process info (slow). Sorting order in which processes are returned is based on their PID. .. code-block:: pycon >>> import psutil >>> for proc in psutil.process_iter(['pid', 'name', 'username']): ... print(proc.info) ... {'name': 'systemd', 'pid': 1, 'username': 'root'} {'name': 'kthreadd', 'pid': 2, 'username': 'root'} {'name': 'ksoftirqd/0', 'pid': 3, 'username': 'root'} ... A dict comprehensions to create a ``{pid: info, ...}`` data structure: .. code-block:: pycon >>> import psutil >>> procs = {p.pid: p.info for p in psutil.process_iter(['name', 'username'])} >>> procs {1: {'name': 'systemd', 'username': 'root'}, 2: {'name': 'kthreadd', 'username': 'root'}, 3: {'name': 'ksoftirqd/0', 'username': 'root'}, ...} Clear internal cache: .. code-block:: pycon >>> psutil.process_iter.cache_clear() .. versionchanged:: 5.3.0 added "attrs" and "ad_value" parameters. .. versionchanged:: 6.0.0 no longer checks whether each yielded process PID has been reused. .. versionchanged:: 6.0.0 added ``psutil.process_iter.cache_clear()`` API. .. 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:: 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 as returned by :meth:`Process.wait`. ``callback`` is a function which gets called when one of the processes being waited on is terminated and a :class:`Process` instance is passed as callback argument (the instance will also have a *returncode* attribute set). This function will return as soon as all processes terminate or when *timeout* (seconds) occurs. Differently from :meth:`Process.wait` it will not raise :exc:`TimeoutExpired` if timeout occurs. A typical use case may be: - send SIGTERM to a list of processes - give them some time to terminate - send SIGKILL to those ones which are still alive Example which terminates and waits all the children of this process:: import psutil def on_terminate(proc): print("process {} terminated with exit code {}".format(proc, 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: 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 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. See also :ref:`faq_no_such_process` FAQ. .. exception:: ZombieProcess(pid, name=None, ppid=None, msg=None) This may be raised by :class:`Process` class methods when querying a :term:`zombie process` on UNIX (Windows doesn't have zombie processes). *name* and *ppid* attributes are available if :meth:`Process.name` or :meth:`Process.ppid` methods were called before the process turned into a zombie. See also :ref:`faq_zombie_process` FAQ. .. note:: this is a subclass of :exc:`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 :exc:`NoSuchProcess`. .. versionadded:: 3.0.0 .. exception:: AccessDenied(pid=None, name=None, msg=None) Raised by :class:`Process` class methods when permission to perform an action is denied due to insufficient privileges. *name* attribute is available if :meth:`Process.name` was previously called. See also :ref:`faq_access_denied` FAQ. .. 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 available 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 current process *pid* (:func:`os.getpid`) is used. Raise :exc:`NoSuchProcess` if *pid* does not exist. On Linux *pid* can also refer to a thread ID (the *id* field returned by :meth:`threads` method). When calling methods of this class, always be prepared to catch :exc:`NoSuchProcess` and :exc:`AccessDenied` exceptions. :func:`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 + creation time). As such it can also be used with :class:`set`. .. note:: In order to efficiently fetch more than one information about the process at the same time, make sure to use either :meth:`oneshot` context manager or :meth:`as_dict` utility method. .. note:: the way this class is bound to a process is via its **PID**. That means that if the process terminates and the OS reuses its PID you may inadvertently end up interacting with another process. To prevent this problem you can use :meth:`is_running` first. Some methods (e.g. setters and signal-related methods) perform an additional check based on PID + creation time and will raise :exc:`NoSuchProcess` if the PID has been reused. See :ref:`faq_pid_reuse` FAQ for details. .. method:: oneshot() Utility context manager which considerably speeds up the retrieval of multiple process information at the same time. Internally different process info (e.g. :meth:`name`, :meth:`ppid`, :meth:`uids`, :meth:`create_time`, ...) may be fetched by using the same routine, but only one value is returned and the others are discarded. When using this context manager the internal routine is executed once (in the example below on :meth:`name`) the value of interest is returned and the others are cached. The subsequent calls sharing the same internal routine will return the cached value. The cache is cleared when exiting the context manager block. The advice is to use this every time you retrieve more than one information about the process. If you're lucky, you'll get a hell of a speedup. .. code-block:: pycon >>> import psutil >>> p = psutil.Process() >>> with p.oneshot(): ... p.name() # execute internal routine once collecting multiple info ... p.cpu_times() # return cached value ... p.cpu_percent() # return cached value ... p.create_time() # return cached value ... p.ppid() # return cached value ... p.status() # return cached value ... >>> Here's a list of methods which can take advantage of the speedup depending on what platform you're on. In the table below horizontal empty rows indicate what process methods can be efficiently grouped together internally. The last column (speedup) shows an approximation of the speedup you can get if you call all the methods together (best case scenario). +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | Linux | Windows | macOS | BSD | SunOS | AIX | +==============================+===============================+==============================+==============================+==========================+==========================+ | :meth:`cpu_num` | :meth:`~Process.cpu_percent` | :meth:`~Process.cpu_percent` | :meth:`cpu_num` | :meth:`name` | :meth:`name` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`~Process.cpu_percent` | :meth:`cpu_times` | :meth:`cpu_times` | :meth:`~Process.cpu_percent` | :meth:`cmdline` | :meth:`cmdline` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`cpu_times` | :meth:`io_counters` | :meth:`memory_info` | :meth:`cpu_times` | :meth:`create_time` | :meth:`create_time` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`create_time` | :meth:`memory_info` | :meth:`memory_percent` | :meth:`create_time` | | | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`name` | :meth:`memory_info_ex` | :meth:`num_ctx_switches` | :meth:`gids` | :meth:`memory_info` | :meth:`memory_info` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`ppid` | :meth:`num_ctx_switches` | :meth:`num_threads` | :meth:`io_counters` | :meth:`memory_percent` | :meth:`memory_percent` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`status` | :meth:`num_handles` | | :meth:`name` | :meth:`num_threads` | :meth:`num_threads` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`terminal` | :meth:`num_threads` | :meth:`create_time` | :meth:`memory_info` | :meth:`ppid` | :meth:`ppid` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | | | :meth:`gids` | :meth:`memory_percent` | :meth:`status` | :meth:`status` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`gids` | :meth:`exe` | :meth:`name` | :meth:`num_ctx_switches` | :meth:`terminal` | :meth:`terminal` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`memory_info_ex` | :meth:`name` | :meth:`ppid` | :meth:`ppid` | | | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`num_ctx_switches` | | :meth:`status` | :meth:`status` | :meth:`gids` | :meth:`gids` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`num_threads` | | :meth:`terminal` | :meth:`terminal` | :meth:`uids` | :meth:`uids` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`uids` | | :meth:`terminal` | :meth:`terminal` | :meth:`uids` | :meth:`uids` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`username` | | :meth:`uids` | :meth:`uids` | :meth:`username` | :meth:`username` | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | | | :meth:`username` | :meth:`username` | | | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`memory_footprint` | | | | | | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | :meth:`memory_maps` | | | | | | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ | *speedup: +2.6x* | *speedup: +1.8x / +6.5x* | *speedup: +1.9x* | *speedup: +2.0x* | *speedup: +1.3x* | *speedup: +1.3x* | +------------------------------+-------------------------------+------------------------------+------------------------------+--------------------------+--------------------------+ .. versionadded:: 5.0.0 .. attribute:: pid The process PID. This is the only (read-only) attribute of the class. .. method:: ppid() The process parent PID. On Windows the return value is cached after the first call. On POSIX it is not cached because the ppid may change if the process becomes a :term:`zombie process`. See also :meth:`parent` and :meth:`parents` methods. .. method:: name() The process name. On Windows the return value is cached after first call. Not on POSIX because the process name may change. See also how to `find a process by name <#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 may be 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() ['python', '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 `_. .. versionadded:: 4.0.0 .. versionchanged:: 5.3.0 added SunOS support. .. 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 may be 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 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. Here's a list of possible string values: ``'cmdline'``, ``'net_connections'``, ``'cpu_affinity'``, ``'cpu_num'``, ``'cpu_percent'``, ``'cpu_times'``, ``'create_time'``, ``'cwd'``, ``'environ'``, ``'exe'``, ``'gids'``, ``'io_counters'``, ``'ionice'``, ``'memory_footprint'``, ``'memory_full_info'``, ``'memory_info'``, ``'memory_info_ex'``, ``'memory_maps'``, ``'memory_percent'``, ``'name'``, ``'nice'``, ``'num_ctx_switches'``, ``'num_fds'``, ``'num_handles'``, ``'num_threads'``, ``'open_files'``, ``'pid'``, ``'ppid'``, ``'status'``, ``'terminal'``, ``'threads'``, ``'uids'``, ``'username'```. If *attrs* argument is not passed all public read only attributes 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. 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'} >>> >>> # get a list of valid attrs names >>> list(psutil.Process().as_dict().keys()) ['cmdline', 'connections', 'cpu_affinity', 'cpu_num', 'cpu_percent', 'cpu_times', 'create_time', 'cwd', 'environ', 'exe', 'gids', 'io_counters', 'ionice', 'memory_footprint', 'memory_full_info', 'memory_info', 'memory_info_ex', 'memory_maps', 'memory_percent', 'name', 'net_connections', 'nice', 'num_ctx_switches', 'num_fds', 'num_threads', 'open_files', 'pid', 'ppid', 'status', 'terminal', 'threads', 'uids', 'username'] .. versionchanged:: 3.0.0 *ad_value* is used also when incurring into :exc:`ZombieProcess` exception, not only :exc:`AccessDenied`. .. versionchanged:: 4.5.0 :meth:`as_dict` is considerably faster thanks to :meth:`oneshot` context manager. .. 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. .. versionadded:: 5.6.0 .. method:: status() The current process status as a :class:`psutil.ProcessStatus` enum member. The returned value is one of the `psutil.STATUS_* <#process-status-constants>`_ constants. A common use case is detecting :term:`zombie processes ` (``p.status() == psutil.STATUS_ZOMBIE``). .. versionchanged:: 8.0.0 return value is now a :class:`psutil.ProcessStatus` enum member instead of a plain ``str``. See :ref:`migration guide `. .. method:: cwd() The process current working directory as an absolute path. If cwd cannot be determined for some internal reason (e.g. system process or directory no longer exists) it may return 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 real process uid. .. method:: uids() The real, effective and saved user ids 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 real, effective and saved group ids 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 niceness (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. .. code-block:: pycon >>> import psutil >>> p = psutil.Process() >>> p.nice(10) # set >>> p.nice() # get 10 >>> Starting from Python 3.3 this functionality is also available as :func:`os.getpriority` and :func:`os.setpriority` (see `BPO-10784`_). On Windows this is implemented via `GetPriorityClass`_ and `SetPriorityClass`_ Windows APIs and *value* is one of the :data:`psutil.*_PRIORITY_CLASS ` constants reflecting the MSDN documentation. The return value on Windows is a :class:`psutil.ProcessPriority` enum member. Example which increases process priority on Windows: .. code-block:: pycon >>> p.nice(psutil.HIGH_PRIORITY_CLASS) .. versionchanged:: 8.0.0 on Windows, return value is now a :class:`psutil.ProcessPriority` enum member. See :ref:`migration guide `. .. method:: ionice(ioclass=None, value=None) Get or set process I/O niceness (priority). If no argument is provided it acts as a get, returning a ``(ioclass, value)`` tuple on Linux and a *ioclass* integer on Windows. If *ioclass* is provided it acts as a set. In this case an additional *value* can be specified on Linux only in order to increase or decrease the I/O priority even further. Here's the possible platform-dependent *ioclass* values. Linux (see `ioprio_get`_ manual): * :const:`IOPRIO_CLASS_RT`: (high) the process gets first access to the disk every time. Use it with care as it can starve the entire system. Additional priority *level* can be specified and ranges from ``0`` (highest) to ``7`` (lowest). * :const:`IOPRIO_CLASS_BE`: (normal) the default for any process that hasn't set a specific I/O priority. Additional priority *level* ranges from ``0`` (highest) to ``7`` (lowest). * :const:`IOPRIO_CLASS_IDLE`: (low) get I/O time when no-one else needs the disk. No additional *value* is accepted. * :const:`IOPRIO_CLASS_NONE`: returned when no priority was previously set. Windows: * :const:`IOPRIO_HIGH`: highest priority. * :const:`IOPRIO_NORMAL`: default priority. * :const:`IOPRIO_LOW`: low priority. * :const:`IOPRIO_VERYLOW`: lowest priority. Here's an example on how to set the highest I/O priority depending on what platform you're on: .. code-block:: pycon >>> import psutil >>> p = psutil.Process() >>> if psutil.LINUX: ... p.ionice(psutil.IOPRIO_CLASS_RT, value=7) ... else: ... p.ionice(psutil.IOPRIO_HIGH) ... >>> p.ionice() # get pionice(ioclass=, value=7) .. availability:: Linux, Windows .. versionchanged:: 5.6.2 Windows accepts new :data:`IOPRIO_* ` constants. .. versionchanged:: 8.0.0 *ioclass* is now a :class:`psutil.ProcessIOPriority` enum member. See :ref:`migration guide `. .. method:: rlimit(resource, limits=None) Get or set process :term:`resource limits ` (see `man prlimit`_). *resource* is one of the :data:`psutil.RLIMIT_* ` constants. *limits* is a ``(soft, hard)`` tuple. This is the same as :func:`resource.getrlimit` and :func:`resource.setrlimit` but can be used for any process PID, not only :func:`os.getpid`. For get, return value is a ``(soft, hard)`` tuple. Each value may be either an integer or :data:`psutil.RLIMIT_* `. Also see `scripts/procinfo.py`_ script. .. code-block:: pycon >>> import psutil >>> p = psutil.Process() >>> p.rlimit(psutil.RLIMIT_NOFILE, (128, 128)) # process can open max 128 file descriptors >>> p.rlimit(psutil.RLIMIT_FSIZE, (1024, 1024)) # can create files no bigger than 1024 bytes >>> p.rlimit(psutil.RLIMIT_FSIZE) # get (1024, 1024) >>> .. availability:: Linux, FreeBSD .. versionchanged:: 5.7.3 added FreeBSD support. .. method:: io_counters() Return process I/O statistics as a named tuple. For Linux you can refer to `/proc filesystem documentation `_. All fields are :term:`cumulative counters ` since process creation. - **read_count**: the number of read operations performed. This is supposed to count the number of read-related syscalls such as ``read()`` and ``pread()`` on UNIX. - **write_count**: the number of write operations performed. This is supposed to count the number of write-related syscalls such as ``write()`` and ``pwrite()`` on UNIX. - **read_bytes**: the number of bytes read. Always ``-1`` on BSD. - **write_bytes**: the number of bytes written. Always ``-1`` on BSD. Linux specific: - **read_chars** *(Linux)*: the amount of bytes which this process passed to ``read()`` and ``pread()`` syscalls. Differently from *read_bytes* it doesn't care whether or not actual physical disk I/O occurred. - **write_chars** *(Linux)*: the amount of bytes which this process passed to ``write()`` and ``pwrite()`` syscalls. Differently from *write_bytes* it doesn't care whether or not actual physical disk I/O occurred. Windows specific: - **other_count** *(Windows)*: the number of I/O operations performed other than read and write operations. - **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, BSD, Windows, AIX .. versionchanged:: 5.2.0 added *read_chars* + *write_chars* on Linux and *other_count* + *other_bytes* on Windows. .. method:: num_ctx_switches() The number of :term:`context switches ` performed by this process (:term:`cumulative counter`). .. note:: (Windows, macOS) *involuntary* value is always set to 0, while *voluntary* value reflect the total number of context switches (voluntary + involuntary). This is a limitation of the OS. .. versionchanged:: 5.4.1 added AIX support. .. method:: num_fds() The number of :term:`file descriptors ` currently opened by this process (non cumulative). .. availability:: UNIX .. method:: num_handles() The number of :term:`handles ` 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 threads opened by process as a list of named tuples. On OpenBSD this method requires root privileges. - **id**: the native thread ID assigned by the kernel. If :attr:`pid` refers to the current process, this matches the `native_id `_ attribute of the :class:`threading.Thread` class, and can be used to reference individual Python threads running within your own Python app. - **user_time**: time spent in user mode. - **system_time**: time spent in kernel mode. .. method:: cpu_times() Return a named tuple of :term:`cumulative counters ` (seconds) representing the accumulated process CPU times (see `explanation `_). This is similar to :func:`os.times` but can be used for any process PID. - **user**: time spent in user mode. - **system**: time spent in kernel mode. - **children_user**: user time of all child processes (always ``0`` on Windows and macOS). - **children_system**: system time of all child processes (always ``0`` on Windows and macOS). - **iowait**: (Linux) time spent waiting for blocking I/O to complete (:term:`iowait`). This value is excluded from `user` and `system` times count (because the CPU is not doing any work). .. 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:: 4.1.0 return two extra fields: *children_user* and *children_system*. .. versionchanged:: 5.6.4 added *iowait* on Linux. .. method:: cpu_percent(interval=None) Return a float representing the process CPU utilization as a percentage which can also be ``> 100.0`` in case of a process running multiple threads on different CPUs. 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. For accuracy, it is recommended to call this function a second time 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 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. See also :ref:`faq_cpu_percent` FAQ. .. note:: the returned value can be > 100.0 in case of a process running multiple threads on different CPU cores. .. note:: the returned value is explicitly *not* split evenly between all available CPUs (differently from :func:`psutil.cpu_percent`). 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%. This was done in order to be consistent with ``top`` UNIX utility, and also to make it easier to identify processes hogging CPU resources independently from the number of CPUs. It must be noted that ``taskmgr.exe`` on Windows does not behave like this (it would report 50% usage instead). To emulate Windows ``taskmgr.exe`` behavior you can do: ``p.cpu_percent() / psutil.cpu_count()``. .. method:: cpu_affinity(cpus=None) Get or set process current `CPU affinity `_. CPU affinity consists in telling the OS to run a process on a limited set of CPUs only (on Linux cmdline, ``taskset`` command is typically used). If no argument is passed it returns the current CPU affinity as a list of integers. If passed it must be a list of integers specifying the new CPUs affinity. If an empty list is passed all eligible CPUs are assumed (and set). On some systems such as Linux this may not necessarily mean all available logical CPUs as in ``list(range(psutil.cpu_count()))``). .. 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 .. versionchanged:: 2.2.0 added support for FreeBSD. .. versionchanged:: 5.1.0 an empty list can be passed to set affinity against all eligible CPUs. .. 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 as shown by `scripts/cpu_distribution.py`_ example script. .. availability:: Linux, FreeBSD, SunOS .. versionadded:: 5.1.0 .. method:: memory_info() Return a named tuple with variable fields depending on the platform representing memory information about the process. The "portable" fields available on all platforms are `rss` and `vms`. All numbers are expressed in bytes. +---------+---------+----------+---------+-----+-----------------+ | 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 | +---------+---------+----------+---------+-----+-----------------+ - **rss**: aka :term:`RSS`. The portion of physical memory currently held by this process (code, data, stack, and mapped files that are resident). Pages swapped out to disk are not counted. On UNIX it matches the ``top`` RES column. On Windows it maps to ``WorkingSetSize``. See also :ref:`faq_memory_rss_vs_vms` FAQ. - **vms**: aka :term:`VMS`. The total address space reserved by the process, including pages not yet touched, pages in swap, and memory-mapped files not yet accessed. Typically much larger than **rss**. On UNIX it matches the ``top`` VIRT column. On Windows this maps to ``PrivateUsage`` (private committed pages only), which differs from the UNIX definition; use ``virtual`` from :meth:`memory_info_ex` for the true virtual address space size. - **shared** *(Linux)*: memory backed by a file or device (shared libraries, mmap'd files, POSIX shared memory) that *could* be shared with other processes. A page is counted here even if no other process is currently mapping it. Matches ``top``'s SHR column. - **text** *(Linux, BSD)*: aka TRS (Text Resident Set). Resident memory devoted to executable code. These pages are read-only and typically shared across all processes running the same binary. Matches ``top``'s CODE column. - **data** *(Linux, BSD)*: aka DRS (Data Resident Set). On Linux this covers the data **and** stack segments combined (from ``/proc//statm``). On BSD it covers the data segment only (see **stack**). Matches ``top``'s DATA column. - **stack** *(BSD)*: size of the process stack segment. Reported separately from **data** (unlike Linux where both are combined). - **peak_rss** *(BSD, Windows)*: the highest :term:`RSS` value (high water mark) the process has ever reached. See :term:`peak_rss`. On BSD this may be ``0`` for kernel PIDs. On Windows it maps to ``PeakWorkingSetSize``. - **peak_vms** *(Windows)*: peak private committed (page-file-backed) virtual memory. 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) .. versionchanged:: 4.0.0 multiple fields are returned, not only *rss* and *vms*. .. versionchanged:: 8.0.0 Linux: *lib* and *dirty* removed (always 0 since Linux 2.6). Deprecated aliases returning 0 and emitting `DeprecationWarning` are kept. See :ref:`migration guide `. .. versionchanged:: 8.0.0 macOS: *pfaults* and *pageins* removed with **no backward-compatible aliases**. Use :meth:`page_faults` instead. See :ref:`migration guide `. .. versionchanged:: 8.0.0 Windows: eliminated old aliases: *wset* → *rss*, *peak_wset* → *peak_rss*, *pagefile* / *private* → *vms*, *peak_pagefile* → *peak_vms*, *num_page_faults* → :meth:`page_faults` method. At the same time *paged_pool*, *nonpaged_pool*, *peak_paged_pool*, *peak_nonpaged_pool* were moved to :meth:`memory_info_ex`. All these old names still work but raise `DeprecationWarning`. See :ref:`migration guide `. .. versionchanged:: 8.0.0 BSD: added *peak_rss*. .. method:: memory_info_ex() Return a named tuple extending :meth:`memory_info` with additional platform-specific memory metrics. On platforms where extra fields are not implemented this returns the same result as :meth:`memory_info`. All numbers are expressed in bytes. +-------------+----------------+--------------------+ | Linux | macOS | Windows | +=============+================+====================+ | peak_rss | peak_rss | virtual | +-------------+----------------+--------------------+ | peak_vms | | peak_virtual | +-------------+----------------+--------------------+ | rss_anon | rss_anon | paged_pool | +-------------+----------------+--------------------+ | rss_file | rss_file | nonpaged_pool | +-------------+----------------+--------------------+ | rss_shmem | wired | peak_paged_pool | +-------------+----------------+--------------------+ | swap | compressed | peak_nonpaged_pool | +-------------+----------------+--------------------+ | hugetlb | phys_footprint | | +-------------+----------------+--------------------+ - **peak_rss** *(Linux, macOS)*: the highest :term:`RSS` value (high water mark) the process has reached since it started. See :term:`peak_rss`. - **peak_vms** *(Linux)*: the highest VMS value the process has reached since it started. - **rss_anon** *(Linux, macOS)*: resident :term:`anonymous memory` pages (heap, stack, private mappings) not backed by any file. Set to 0 on Linux < 4.5. - **rss_file** *(Linux, macOS)*: resident file-backed memory; pages mapped from files (shared libraries, mmap'd files). Set to 0 on Linux < 4.5. - **rss_shmem** *(Linux)*: resident shared memory pages (``tmpfs``, ``shm_open``). ``rss_anon + rss_file + rss_shmem`` equals **rss**. Set to 0 on Linux < 4.5. - **wired** *(macOS)*: memory pinned in RAM by the kernel on behalf of this process; cannot be compressed or paged out. - **swap** *(Linux)*: process memory currently in swap. Equivalent to ``memory_footprint().swap`` but cheaper, as it reads from ``/proc//status`` instead of ``/proc//smaps``. - **compressed** *(macOS)*: pages held in the in-RAM memory compressor; not counted in **rss**. A large value signals memory pressure but has not yet triggered swapping. - **hugetlb** *(Linux)*: resident memory backed by huge pages. Set to 0 on Linux < 4.4. - **phys_footprint** *(macOS)*: total physical memory impact including compressed pages. What Xcode and ``footprint(1)`` report; prefer this over **rss** macOS memory monitoring. - **virtual** *(Windows)*: true virtual address space size, including reserved-but-uncommitted regions (unlike **vms** in :meth:`memory_info`). - **peak_virtual** *(Windows)*: peak virtual address space size. - **paged_pool** *(Windows)*: 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. - **nonpaged_pool** *(Windows)*: 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. - **peak_paged_pool** *(Windows)*: peak paged-pool usage. - **peak_nonpaged_pool** *(Windows)*: peak non-paged-pool usage. For the full definitions of Windows fields see `PROCESS_MEMORY_COUNTERS_EX`_. .. versionadded:: 8.0.0 .. method:: memory_footprint() Return a named tuple with USS, PSS and swap memory metrics. These give a more accurate picture of actual memory consumption than :meth:`memory_info`, as explained in this `blog post `_. It works by walking the full process address space, so it is considerably slower than :meth:`memory_info` and may require elevated privileges. - **uss** *(Linux, macOS, Windows)*: aka :term:`USS`. This is the memory which is unique to a process and which would be freed if the process were terminated right now. The most representative metric for actual memory usage. - **pss** *(Linux)*: aka :term:`PSS`, 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)*: process memory currently in swap, counted per-mapping (slower, but may be more accurate than ``memory_info_ex().swap``). Example on Linux: .. code-block:: pycon >>> import psutil >>> p = psutil.Process() >>> p.memory_footprint() pfootprint(uss=6545408, pss=6872064, swap=0) See also `scripts/procsmem.py`_ for an example application. .. versionadded:: 8.0.0 .. availability:: Linux, macOS, Windows .. method:: memory_full_info() This deprecated method returns the same information as :meth:`memory_info` plus :meth:`memory_footprint` in a single named tuple. .. versionadded:: 4.0.0 .. deprecated:: 8.0.0 use :meth:`memory_footprint` instead. See :ref:`migration guide `. .. method:: memory_percent(memtype="rss") Return process memory usage as a percentage of total physical memory (``process.memory_info().rss / virtual_memory().total * 100``). *memtype* can be any field name from :meth:`memory_info`, :meth:`memory_info_ex`, or :meth:`memory_footprint` and controls which memory value is used in the calculation (defaults to ``"rss"``). .. versionchanged:: 4.0.0 added `memtype` parameter. .. method:: memory_maps(grouped=True) Return process's memory-mapped file regions as a list of named tuples whose 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 and the tuple also includes *addr* (address range) and *perms* (permission string e.g. ``"r-xp"``). See `scripts/pmap.py`_ for an example application. +---------------+---------+--------------+-----------+ | 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//smaps``): - **rss**: resident pages in this mapping. - **size**: total virtual size; may far exceed **rss** for sparse or reserved-but-unaccessed mappings. - **pss**: proportional RSS. **rss** divided by the number of processes sharing this mapping. Useful for fair per-process accounting. - **shared_clean**: shared pages not modified (e.g. shared library code); can be dropped from RAM without writing to swap. - **shared_dirty**: shared pages that have been written to. - **private_clean**: private unmodified pages; can be dropped without writing to swap. - **private_dirty**: private modified pages; must be written to swap before they can be reclaimed. The key indicator of a mapping's real memory cost. - **referenced**: pages recently accessed. - **anonymous**: :term:`anonymous memory` pages not backed by a file (heap, stack allocations). - **swap**: pages from this mapping currently in swap. FreeBSD fields: - **private**: pages in this mapping private to this process. - **ref_count**: reference count on the VM object backing this mapping. - **shadow_count**: depth of the copy-on-write shadow object 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), ...] .. availability:: Linux, Windows, FreeBSD, SunOS .. versionchanged:: 5.6.0 removed macOS support because inherently broken (see issue `#1291 `_) .. method:: children(recursive=False) Return the children of this process as a list of :class:`Process` instances. If recursive is ``True`` return all the parent descendants. Pseudo code example assuming *A == this process*: :: 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 that in the example above if process X disappears process Y won't be returned either as the reference to process A is lost. This concept is well illustrated by this `unit test `_. See also how to :ref:`kill a process tree `. .. method:: page_faults() Return the number of :term:`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 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. Both counters are :term:`cumulative counters ` 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 of named tuples including the following fields: - **path**: the absolute file name. - **fd**: the file descriptor number; on Windows this is always ``-1``. Linux only: - **position** (*Linux*): the file (offset) position. - **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"``). - **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:: on Windows this method is not reliable due to some limitations of the underlying Windows API which may hang when retrieving certain file handles. In order to work around that psutil spawns a thread to determine the file handle name and kills it if it's not responding after 100ms. That implies that this method on Windows is not guaranteed to enumerate all regular file handles (see `issue 597 `_). Tools like ProcessHacker have the same limitation. .. 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 `_). .. versionchanged:: 3.1.0 no longer hangs on Windows. .. versionchanged:: 4.1.0 new *position*, *mode* and *flags* fields on Linux. .. method:: net_connections(kind="inet") Return socket connections opened by process as a list of named tuples. To get system-wide connections use :func:`psutil.net_connections`. Every named tuple provides 6 attributes: - **fd**: the socket file descriptor. If the connection refers to the current process this may be passed to :func:`socket.fromfd` to obtain a usable socket object. On Windows, FreeBSD and SunOS this is always set to ``-1``. - **family**: the address family, either :data:`socket.AF_INET`, :data:`socket.AF_INET6` or :data:`socket.AF_UNIX`. - **type**: the address type, either :data:`socket.SOCK_STREAM`, :data:`socket.SOCK_DGRAM` or :data:`socket.SOCK_SEQPACKET`. - **laddr**: the local address as a ``(ip, port)`` named tuple or a ``path`` in case of AF_UNIX sockets. For UNIX sockets see notes below. - **raddr**: the remote address as a ``(ip, port)`` named 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 ``""`` (AF_UNIX). For UNIX sockets see notes below. - **status**: represents the status of a TCP connection. The return value is one of the :data:`psutil.CONN_* ` 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 | +----------------+-----------------------------------------------------+ .. code-block:: pycon >>> import psutil >>> p = psutil.Process(1694) >>> p.name() 'firefox' >>> p.net_connections() [pconn(fd=115, family=, type=, laddr=addr(ip='10.0.0.1', port=48776), raddr=addr(ip='93.186.135.91', port=80), status=), pconn(fd=117, family=, type=, laddr=addr(ip='10.0.0.1', port=43761), raddr=addr(ip='72.14.234.100', port=80), status=), pconn(fd=119, family=, type=, laddr=addr(ip='10.0.0.1', port=60759), raddr=addr(ip='72.14.234.104', port=80), status=), pconn(fd=123, family=, type=, laddr=addr(ip='10.0.0.1', port=51314), raddr=addr(ip='72.14.234.83', port=443), status=)] .. warning:: On Linux, retrieving connections for certain processes requires root privileges. If psutil is not run as root, those connections are silently skipped instead of raising :exc:`psutil.AccessDenied`. That means the returned list may be incomplete. .. note:: (Solaris) UNIX sockets are not supported. .. note:: (Linux, FreeBSD) *raddr* field for UNIX sockets is always set to "". This is a limitation of the OS. .. note:: (OpenBSD) *laddr* and *raddr* fields for UNIX sockets are always set to "". This is a limitation of the OS. .. note:: (AIX) :exc:`psutil.AccessDenied` is always raised unless running as root (lsof does the same). .. versionchanged:: 5.3.0 *laddr* and *raddr* are named tuples. .. versionchanged:: 6.0.0 method renamed from `connections` to `net_connections`. .. versionchanged:: 8.0.0 *status* field is now a :class:`psutil.ConnectionStatus` enum member instead of a plain ``str``. See :ref:`migration guide `. .. 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 in the current process list. Differently from ``psutil.pid_exists(p.pid)``, this is reliable also in case the process is gone and its PID reused by another process (:ref:`PID reuse `). If PID has been reused, this method will also remove the process from :func:`process_iter` internal cache. .. note:: this will return ``True`` also if the process is a :term:`zombie process` (``p.status() == psutil.STATUS_ZOMBIE``). .. versionchanged:: 6.0.0 automatically remove process from :func:`process_iter` internal cache if PID has been reused by another process. .. method:: send_signal(signal) Send a signal 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`. See also how to :ref:`kill a process tree `. .. 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`. See also how to :ref:`kill a process 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`_. See also how to :ref:`kill a process 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 a positive integer >= 0 indicating the exit code. If the process was terminated by a signal return 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) just wait until the process disappears and return ``None``. If PID does not exist return ``None`` immediately. *On Windows*: always return the exit code, which is a positive integer as returned by `GetExitCodeProcess`_. *timeout* is expressed in seconds. If specified and the process is still alive raise :exc:`TimeoutExpired` exception. ``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() .. 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). .. 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 on POSIX, in case of negative signal, 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() `, :meth:`terminate() `, :meth:`kill() `. This is done in order to avoid killing another process in case its PID has been reused, fixing `BPO-6973`_. .. code-block:: pycon >>> 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 >>> .. versionchanged:: 4.4.0 added context manager support. ---- C heap introspection -------------------- The following functions provide direct access to the platform's native C 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 RSS/VMS metrics. These functions do not reflect Python object memory; they operate solely on allocations made in C via ``malloc()``, ``free()``, and related calls. The general idea behind these functions is straightforward: capture the state of the C 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. .. 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's `mallinfo2`_. Returns a named tuple containing: - ``heap_used``: total number of bytes currently allocated via ``malloc()`` (small allocations). - ``mmap_used``: total number of bytes currently allocated via ``mmap()`` 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 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. .. availability:: Linux with glibc, Windows, macOS, FreeBSD, NetBSD .. versionadded:: 7.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 :exc:`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. Example code: .. code-block:: pycon >>> import psutil >>> list(psutil.win_service_iter()) [, , , , ...] >>> 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 .. versionadded:: 4.2.0 ---- Constants --------- The following enum classes group related constants and are useful for type annotations and introspection. The individual constants (e.g. :data:`psutil.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:: psutil.ProcessStatus :class:`enum.StrEnum` collection of :data:`STATUS_* ` constants. Returned by :meth:`Process.status`. .. versionadded:: 8.0.0 .. class:: psutil.ProcessPriority :class:`enum.IntEnum` collection of :data:`*_PRIORITY_CLASS ` constants for :meth:`Process.nice` on Windows. .. availability:: Windows .. versionadded:: 8.0.0 .. class:: psutil.ProcessIOPriority :class:`enum.IntEnum` collection of I/O priority constants for :meth:`Process.ionice`. :data:`IOPRIO_CLASS_* ` on Linux, :data:`IOPRIO_* ` on Windows. .. availability:: Linux, Windows .. versionadded:: 8.0.0 .. class:: psutil.ProcessRlimit :class:`enum.IntEnum` collection of :data:`RLIMIT_* ` constants for :meth:`Process.rlimit`. .. availability:: Linux, FreeBSD .. versionadded:: 8.0.0 .. class:: psutil.ConnectionStatus :class:`enum.StrEnum` collection of :data:`CONN_* ` constants. Returned in the *status* field of :func:`psutil.net_connections` and :meth:`Process.net_connections`. .. versionadded:: 8.0.0 .. class:: psutil.NicDuplex :class:`enum.IntEnum` collection of :data:`NIC_DUPLEX_* ` constants. Returned in the *duplex* field of :func:`psutil.net_if_stats`. .. versionadded:: 3.0.0 .. class:: psutil.BatteryTime :class:`enum.IntEnum` collection of :data:`POWER_TIME_* ` constants. May appear in the *secsleft* field of :func:`psutil.sensors_battery`. .. versionadded:: 5.1.0 Operating system constants ^^^^^^^^^^^^^^^^^^^^^^^^^^ .. _const-oses: .. data:: POSIX .. data:: LINUX .. data:: WINDOWS .. data:: MACOS .. data:: FREEBSD .. data:: NETBSD .. data:: OPENBSD .. data:: BSD .. data:: SUNOS .. data:: AIX ``bool`` constants which define what platform you're on. E.g. if on Windows, :const:`WINDOWS` constant will be ``True``, all others will be ``False``. .. versionadded:: 4.0.0 .. versionchanged:: 5.4.0 added AIX. .. data:: OSX Alias for :const:`MACOS`. .. deprecated:: 5.4.7 use :const:`MACOS` instead. Process status constants ^^^^^^^^^^^^^^^^^^^^^^^^ .. _const-pstatus: .. data:: STATUS_RUNNING .. data:: STATUS_SLEEPING .. data:: STATUS_DISK_SLEEP .. data:: STATUS_STOPPED .. data:: STATUS_TRACING_STOP .. data:: STATUS_ZOMBIE .. data:: STATUS_DEAD .. data:: STATUS_WAKE_KILL .. data:: STATUS_WAKING .. data:: STATUS_PARKED (Linux) .. data:: STATUS_IDLE (Linux, macOS, FreeBSD) .. data:: STATUS_LOCKED (FreeBSD) .. data:: STATUS_WAITING (FreeBSD) .. data:: STATUS_SUSPENDED (NetBSD) Represent a process status. Returned by :meth:`Process.status`. These constants are members of the :class:`psutil.ProcessStatus` enum. .. versionadded:: 3.4.1 ``STATUS_SUSPENDED`` (NetBSD) .. versionadded:: 5.4.7 ``STATUS_PARKED`` (Linux) .. versionchanged:: 8.0.0 constants are now :class:`psutil.ProcessStatus` enum members (were plain strings). See :ref:`migration guide `. Process priority constants ^^^^^^^^^^^^^^^^^^^^^^^^^^ .. _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 Represent the priority of a process on Windows (see `SetPriorityClass`_). They can be used in conjunction with :meth:`Process.nice` to get or set process priority. These constants are members of the :class:`psutil.ProcessPriority` enum. .. availability:: Windows .. versionchanged:: 8.0.0 constants are now :class:`psutil.ProcessPriority` enum members (were plain integers). See :ref:`migration guide `. .. _const-ioprio-linux: .. data:: IOPRIO_CLASS_NONE .. data:: IOPRIO_CLASS_RT .. data:: IOPRIO_CLASS_BE .. data:: 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:`Process.ionice` to get or set process I/O priority. These constants are members of the :class:`psutil.ProcessIOPriority` enum. :const:`IOPRIO_CLASS_NONE` and :const:`IOPRIO_CLASS_BE` (best effort) is the default for any process that hasn't set a specific I/O priority. :const:`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. :const:`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 `_ command line utility or `ioprio_get`_ system call. .. availability:: Linux .. versionchanged:: 8.0.0 constants are now :class:`psutil.ProcessIOPriority` enum members (previously ``IOPriority`` enum). See :ref:`migration guide `. .. _const-ioprio-windows: .. data:: IOPRIO_VERYLOW .. data:: IOPRIO_LOW .. data:: IOPRIO_NORMAL .. data:: IOPRIO_HIGH A set of integers representing the I/O priority of a process on Windows. They can be used in conjunction with :meth:`Process.ionice` to get or set process I/O priority. These constants are members of the :class:`psutil.ProcessIOPriority` enum. .. availability:: Windows .. versionadded:: 5.6.2 .. versionchanged:: 8.0.0 constants are now :class:`psutil.ProcessIOPriority` enum members (previously ``IOPriority`` enum). See :ref:`migration guide `. Process resource constants ^^^^^^^^^^^^^^^^^^^^^^^^^^ .. _const-rlimit: 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 .. data:: RLIMIT_SBSIZE .. data:: RLIMIT_NPTS Constants used for getting and setting process resource limits to be used in conjunction with :meth:`Process.rlimit`. See :func:`resource.getrlimit` for further information. These constants are members of the :class:`psutil.ProcessRlimit` enum. .. availability:: Linux, FreeBSD .. versionchanged:: 5.7.3 added FreeBSD support, added ``RLIMIT_SWAP``, ``RLIMIT_SBSIZE``, ``RLIMIT_NPTS``. .. versionchanged:: 8.0.0 constants are now :class:`psutil.ProcessRlimit` enum members (were plain integers). See :ref:`migration guide `. Connections constants ^^^^^^^^^^^^^^^^^^^^^ .. _const-conn: .. 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) A set of strings representing the status of a TCP connection. Returned by :meth:`Process.net_connections` and :func:`psutil.net_connections` (`status` field). These constants are members of the :class:`psutil.ConnectionStatus` enum. .. versionchanged:: 8.0.0 constants are now :class:`psutil.ConnectionStatus` enum members (were plain strings). See :ref:`migration guide `. Hardware constants ^^^^^^^^^^^^^^^^^^ .. _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 .. data:: NIC_DUPLEX_HALF .. data:: NIC_DUPLEX_UNKNOWN Constants which identifies whether a :term:`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_HALF 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 .. _const-power: .. data:: POWER_TIME_UNKNOWN .. data:: POWER_TIME_UNLIMITED Whether the remaining time of the battery cannot be determined or is unlimited. May be assigned to :func:`psutil.sensors_battery`'s *secsleft* field. .. versionadded:: 5.1.0 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 your /proc filesystem is mounted elsewhere or if you want to retrieve information about Linux containers such as Docker, Heroku or LXC (see `here `_ 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 .. versionadded:: 3.2.3 .. versionchanged:: 3.4.2 also available on Solaris. .. versionchanged:: 5.4.0 also available on AIX. .. _const-version-info: .. data:: version_info A tuple to check psutil installed version. Example: .. code-block:: pycon >>> import psutil >>> if psutil.version_info >= (4, 5): ... pass .. _`BPO-10784`: https://bugs.python.org/issue10784 .. _`BPO-12442`: https://bugs.python.org/issue12442 .. _`BPO-6973`: https://bugs.python.org/issue6973 .. _`ioprio_get`: https://linux.die.net/man/2/ioprio_get .. _`iostats doc`: https://www.kernel.org/doc/Documentation/iostats.txt .. _`mallinfo2`: https://man7.org/linux/man-pages/man3/mallinfo.3.html .. _`man prlimit`: https://linux.die.net/man/2/prlimit .. _`psleak`: https://github.com/giampaolo/psleak .. _`/proc/meminfo`: https://man7.org/linux/man-pages/man5/proc_meminfo.5.html .. === scripts .. _`scripts/battery.py`: https://github.com/giampaolo/psutil/blob/master/scripts/battery.py .. _`scripts/cpu_distribution.py`: https://github.com/giampaolo/psutil/blob/master/scripts/cpu_distribution.py .. _`scripts/disk_usage.py`: https://github.com/giampaolo/psutil/blob/master/scripts/disk_usage.py .. _`scripts/fans.py`: https://github.com/giampaolo/psutil/blob/master/scripts/fans.py .. _`scripts/ifconfig.py`: https://github.com/giampaolo/psutil/blob/master/scripts/ifconfig.py .. _`scripts/iotop.py`: https://github.com/giampaolo/psutil/blob/master/scripts/iotop.py .. _`scripts/meminfo.py`: https://github.com/giampaolo/psutil/blob/master/scripts/meminfo.py .. _`scripts/netstat.py`: https://github.com/giampaolo/psutil/blob/master/scripts/netstat.py .. _`scripts/nettop.py`: https://github.com/giampaolo/psutil/blob/master/scripts/nettop.py .. _`scripts/pmap.py`: https://github.com/giampaolo/psutil/blob/master/scripts/pmap.py .. _`scripts/procinfo.py`: https://github.com/giampaolo/psutil/blob/master/scripts/procinfo.py .. _`scripts/procsmem.py`: https://github.com/giampaolo/psutil/blob/master/scripts/procsmem.py .. _`scripts/sensors.py`: https://github.com/giampaolo/psutil/blob/master/scripts/sensors.py .. _`scripts/temperatures.py`: https://github.com/giampaolo/psutil/blob/master/scripts/temperatures.py .. === Windows API .. _`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 .. _`GetPriorityClass`: https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-getpriorityclass .. _`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 ================================================ FILE: docs/changelog.rst ================================================ .. currentmodule:: psutil Changelog ========= 8.0.0 (IN DEVELOPMENT) ^^^^^^^^^^^^^^^^^^^^^^ **Compatibility notes** psutil 8.0 introduces breaking API changes and drops support for Python 3.6. See the :ref:`migration guide ` if upgrading from 7.x. **Enhancements** Doc improvements (:gh:`2761`, :gh:`2757`, :gh:`2760`, :gh:`2745`, :gh:`2763`, :gh:`2764`, :gh:`2767`, :gh:`2768`, :gh:`2769`, :gh:`2771`, :gh:`2774`, :gh:`2775`) - Split docs from a single HTML file into multiple sections (API reference, install, etc.). - Added new sections: - `/recipes `__: show code samples - `/adoption `__: notable software using psutil - `/glossary `__: a section explaining the core concepts - `/shell_equivalents `__: maps each psutil API to native CLI commands - `/install `__ (was old ``INSTALL.rst`` in root dir) - `/credits `__: list contributors and donors (was old ``CREDITS`` in root dir) - `/platform `__: summary of OSes and architectures support - `/faq `__: extended FAQ section. - `/alternatives `__: list of alternative Python libraries and tools that overlap with psutil. - `/migration `__: a section explaining how to migrate to newer psutil versions that break backward compatibility. - Usability: - Show a clickable COPY button to copy code snippets. - Show ``psutil.`` prefix for all APIs. - Use sphinx extension to validate Python code snippets syntax at build-time. - Testing: - Replace ``rstcheck`` with ``sphinx-lint`` for RST linting. - Add custom script to detect dead reference links in ``.rst`` files. - Build doc as part of CI process. - Greatly improved :func:`virtual_memory` doc. Type hints / enums: - :gh:`1946`: Add inline type hints to all public APIs in `psutil/__init__.py`. Type checkers (mypy, pyright, etc.) can now statically verify code that uses psutil. No runtime behavior is changed; the annotations are purely informational. - :gh:`2751`: Convert all named tuples from ``collections.namedtuple`` to ``typing.NamedTuple`` classes with **type annotations**. This makes the classes self-documenting, effectively turning this module into a readable API reference. - :gh:`2753`: Introduce enum classes (:class:`ProcessStatus`, :class:`ConnectionStatus`, :class:`ProcessIOPriority`, :class:`ProcessPriority`, :class:`ProcessRlimit`) grouping related constants. The individual top-level constants (e.g. ``psutil.STATUS_RUNNING``) remain the primary API, and are now aliases for the corresponding enum members. - New APIs: - :gh:`1541`: New :meth:`Process.page_faults` method, returning a ``(minor, major)`` named tuple. - Reorganization of process memory APIs (:gh:`2731`, :gh:`2736`, :gh:`2723`, :gh:`2733`). - Add new :meth:`Process.memory_info_ex` method, which extends :meth:`Process.memory_info` with platform-specific metrics: - Linux: *peak_rss*, *peak_vms*, *rss_anon*, *rss_file*, *rss_shmem*, *swap*, *hugetlb* - macOS: *peak_rss*, *rss_anon*, *rss_file*, *wired*, *compressed*, *phys_footprint* - Windows: *virtual*, *peak_virtual* - Add new :meth:`Process.memory_footprint` method, which returns *uss*, *pss* and *swap* metrics (what :meth:`Process.memory_full_info` used to return, which is now **deprecated**, see :ref:`migration guide `). - :meth:`Process.memory_info` named tuple changed: - BSD: added *peak_rss*. - Linux: *lib* and *dirty* removed (always 0 since Linux 2.6). Deprecated aliases returning 0 and emitting `DeprecationWarning` are kept. - macOS: *pfaults* and *pageins* removed with **no backward-compatible aliases**. Use :meth:`Process.page_faults` instead. - Windows: eliminated old aliases: *wset* → *rss*, *peak_wset* → *peak_rss*, *pagefile* / *private* → *vms*, *peak_pagefile* → *peak_vms*. At the same time *paged_pool*, *nonpaged_pool*, *peak_paged_pool*, *peak_nonpaged_pool* were moved to :meth:`Process.memory_info_ex`. All these old names still work but raise `DeprecationWarning`. See :ref:`migration guide `. - :meth:`Process.memory_full_info` is **deprecated**. Use the new :meth:`Process.memory_footprint` instead. See :ref:`migration guide `. Others - :gh:`2747`: 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 ``user, system, idle``. See compatibility notes below. - :gh:`2754`: standardize :func:`sensors_battery`'s `percent` so that it returns a `float` instead of `int` on all systems, not only Linux. - :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:`2772`, [Windows]: :func:`cpu_times` ``interrupt`` field renamed to ``irq`` to match the field name used on Linux and BSD. ``interrupt`` still works but raises :exc:`DeprecationWarning`. See :ref:`migration guide `. - :gh:`2776`: Windows: :func:`virtual_memory` now includes ``cached`` and ``wired`` fields. **Bug fixes** - :gh:`2770`, [Linux]: fix :func:`cpu_count_cores` raising ``ValueError`` on s390x architecture, where ``/proc/cpuinfo`` uses spaces before the colon separator instead of a tab. - :gh:`2726`, [macOS]: :meth:`Process.num_ctx_switches` return an unusual high number due to a C type precision issue. - :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:`2732`, [Linux]: net_if_duplex_speed: handle EBUSY from ioctl(SIOCETHTOOL). - :gh:`2744`, [NetBSD]: fix possible double `free()` in :func:`swap_memory`. - :gh:`2746`, [FreeBSD]: :meth:`Process.memory_maps`, `rss` and `private` fields, are erroneously reported in memory pages instead of bytes. Other platforms (Linux, macOS, Windows) return bytes. 7.2.3 — 2026-02-08 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`2715`, [Linux]: ``wait_pid_pidfd_open()`` (from :meth:`Process.wait`) crashes with ``EINVAL`` due to kernel race condition. 7.2.2 — 2026-01-28 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2705`: [Linux]: :meth:`Process.wait` now uses ``pidfd_open()`` + ``poll()`` for waiting, resulting in no busy loop and faster response times. Requires Linux >= 5.3 and Python >= 3.9. Falls back to traditional polling if unavailable. - :gh:`2705`: [macOS], [BSD]: :meth:`Process.wait` now uses ``kqueue()`` for waiting, resulting in no busy loop and faster response times. **Bug fixes** - :gh:`2701`, [macOS]: fix compilation error on macOS < 10.7. (patch by Sergey Fedorov) - :gh:`2707`, [macOS]: fix potential memory leaks in error paths of `Process.memory_full_info()` and `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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1275`: new :func:`heap_info` and :func:`heap_trim` functions, providing direct access to the platform's native C heap allocator (glibc, mimalloc, libmalloc). Useful to create tools to detect memory leaks. - :gh:`2403`, [Linux]: publish wheels for Linux musl. - :gh:`2680`: unit tests are no longer installed / part of the distribution. They now live under `tests/` instead of `psutil/tests`. **Bug fixes** * :gh:`2684`, [FreeBSD], [critical]: compilation fails on FreeBSD 14 due to missing include. * :gh:`2691`, [Windows]: fix memory leak in :func:`net_if_stats` due to missing ``Py_CLEAR``. **Compatibility notes** - :gh:`2680`: `import psutil.tests` no longer works (but it was never documented to begin with). 7.1.3 — 2025-11-02 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2667`: enforce `clang-format` on all C and header files. It is now the mandatory formatting style for all C sources. - :gh:`2672`, [macOS], [BSD]: increase the chances to recognize zombie processes and raise the appropriate exception (:exc:`ZombieProcess`). - :gh:`2676`, :gh:`2678`: replace unsafe `sprintf` / `snprintf` / `sprintf_s` calls with `str_format()`. Replace `strlcat` / `strlcpy` with safe `str_copy` / `str_append`. This unifies string handling across platforms and reduces unsafe usage of standard string functions, improving robustness. **Bug fixes** - :gh:`2674`, [Windows]: :func:`disk_usage` could truncate values on 32-bit platforms, potentially reporting incorrect total/free/used space for drives larger than 4GB. - :gh:`2675`, [macOS]: :meth:`Process.status` incorrectly returns "running" for 99% of the processes. - :gh:`2677`, [Windows]: fix MAC address string construction in :func:`net_if_addrs`. Previously, the MAC address buffer was incorrectly updated using a fixed increment and `sprintf_s`, which could overflow or misformat the string if the MAC length or formatting changed. Also, the final '\n' was inserted unnecessarily. - :gh:`2679`, [OpenBSD], [NetBSD], [critical]: can't build due to C syntax error. 7.1.2 — 2025-10-25 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2657`: 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 Lysandros Nikolaou) **Bug fixes** - :gh:`2650`, [macOS]: :meth:`Process.cmdline` and :meth:`Process.environ` may incorrectly raise :exc:`NoSuchProcess` instead of :exc:`ZombieProcess`. - :gh:`2658`, [macOS]: double ``free()`` in :meth:`Process.environ` when it fails internally. This posed a risk of segfault. - :gh:`2662`, [macOS]: massive C code cleanup to guard against possible segfaults which were (not so) sporadically spotted on CI. **Compatibility notes** - :gh:`2657`: stop publishing prebuilt Linux and Windows wheels for 32-bit Python. 7.1.1 — 2025-10-19 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2645`, [SunOS]: dropped support for SunOS 10. - :gh:`2646`, [SunOS]: add CI test runner for SunOS. **Bug fixes** - :gh:`2641`, [SunOS]: cannot compile psutil from sources due to missing C include. - :gh:`2357`, [SunOS]: :meth:`Process.cmdline` does not handle spaces properly. (patch by Ben Raz) **Compatibility notes** * :gh:`2645`: SunOS 10 is no longer supported. 7.1.0 — 2025-09-17 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2581`, [Windows]: publish ARM64 wheels. (patch by Matthieu Darbois) - :gh:`2571`, [FreeBSD]: Dropped support for FreeBSD 8 and earlier. FreeBSD 8 was maintained from 2009 to 2013. - :gh:`2575`: introduced `dprint` CLI tool to format .yml and .md files. **Bug fixes** - :gh:`2473`, [macOS]: Fix build issue on macOS 11 and lower. - :gh:`2494`, [Windows]: All APIs dealing with paths, such as :meth:`Process.memory_maps`, :meth:`Process.exe` and :meth:`Process.open_files` does not properly handle UNC paths. Paths such as ``\\??\\C:\\Windows\\Temp`` and ``'\\Device\\HarddiskVolume1\\Windows\\Temp'`` are now converted to ``C:\\Windows\\Temp``. (patch by Ben Peddell) - :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 `FileNotFoundError` due to a race condition. - :gh:`2526`, [Linux]: :meth:`Process.create_time`, which is used to univocally identify a process over time, is subject to system clock updates, and as such can lead to :meth:`Process.is_running` returning a wrong result. A monotonic creation time is now used instead. (patch by Jonathan Kohler) - :gh:`2528`, [Linux]: :meth:`Process.children` may raise ``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:`2545`: [Illumos]: Fix handling of MIB2_UDP_ENTRY in :func:`net_connections`. - :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 `IndexError` on RISCV64 due to a malformed `/proc/{PID}/smaps` file. (patch by Julien Stephan) - :gh:`2586`, [macOS], [CRITICAL]: fixed different places in C code which can trigger a segfault. - :gh:`2604`, [Linux]: :func:`virtual_memory` "used" memory does not match recent versions of ``free`` CLI utility. (patch by Isaac K. Ko) - :gh:`2605`, [Linux]: :func:`sensors_battery` reports a negative amount for seconds left. - :gh:`2607`, [Windows]: ``WindowsService.description()`` method may fail with ``ERROR_NOT_FOUND``. Now it returns an empty string instead. - 2610:, [macOS], [CRITICAL]: fix :func:`cpu_freq` segfault on ARM architectures. **Compatibility notes** - :gh:`2571`: dropped support for FreeBSD 8 and earlier. 7.0.0 — 2025-02-13 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`669`, [Windows]: :func:`net_if_addrs` also returns the ``broadcast`` address instead of ``None``. - :gh:`2480`: Python 2.7 is no longer supported. Latest version supporting Python 2.7 is psutil 6.1.X. Install it with: ``pip2 install psutil==6.1.*``. - :gh:`2490`: removed long deprecated ``Process.memory_info_ex()`` method. It was deprecated in psutil 4.0.0, released 8 years ago. Substitute is ``Process.memory_full_info()``. **Bug fixes** - :gh:`2496`, [Linux]: Avoid segfault (a cPython bug) on ``Process.memory_maps()`` for processes that use hundreds of GBs of memory. - :gh:`2502`, [macOS]: :func:`virtual_memory` now relies on ``host_statistics64`` instead of ``host_statistics``. This is the same approach used by ``vm_stat`` CLI tool, and should grant more accurate results. **Compatibility notes** - :gh:`2480`: Python 2.7 is no longer supported. - :gh:`2490`: removed long deprecated ``Process.memory_info_ex()`` method. 6.1.1 — 2024-12-19 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2471`: use Vulture CLI tool to detect dead code. **Bug fixes** - :gh:`2418`, [Linux]: fix race condition in case /proc/PID/stat does not exist, but /proc/PID does, resulting in 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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2366`, [Windows]: drastically speedup :func:`process_iter`. We now determine process unique identity by using process "fast" create time method. This will considerably speedup those apps which use :func:`process_iter` only once, e.g. to look for a process with a certain name. - :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 to run tests via ``python3 -m psutil.tests`` even if ``pytest`` module is not installed. This is useful for production environments that don't have pytest installed, but still want to be able to test psutil installation. **Bug fixes** - :gh:`2427`: psutil (segfault) on import in the free-threaded (no GIL) version of Python 3.13. (patch by Sam Gross) - :gh:`2455`, [Linux]: ``IndexError`` may occur when reading /proc/pid/stat and field 40 (blkio_ticks) is missing. - :gh:`2457`, [AIX]: significantly improve the speed of :meth:`Process.open_files` for some edge cases. - :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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2109`: ``maxfile`` and ``maxpath`` fields were removed from the named tuple returned by :func:`disk_partitions`. Reason: on network filesystems (NFS) this can potentially take a very long time to complete. - :gh:`2366`, [Windows]: log debug message when using slower process APIs. - :gh:`2375`, [macOS]: provide arm64 wheels. (patch by Matthieu Darbois) - :gh:`2396`: :func:`process_iter` no longer pre-emptively checks whether PIDs have been reused. This makes :func:`process_iter` around 20x times faster. - :gh:`2396`: a new ``psutil.process_iter.cache_clear()`` API can be used the clear :func:`process_iter` internal cache. - :gh:`2401`, Support building with free-threaded CPython 3.13. (patch by Sam Gross) - :gh:`2407`: :meth:`Process.connections` was renamed to :meth:`Process.net_connections`. The old name is still available, but it's deprecated (triggers a ``DeprecationWarning``) and will be removed in the future. - :gh:`2425`: [Linux]: provide aarch64 wheels. (patch by Matthieu Darbois / Ben Raz) **Bug fixes** - :gh:`2250`, [NetBSD]: :meth:`Process.cmdline` sometimes fail with EBUSY. It usually happens for long cmdlines with lots of arguments. In this case retry getting the cmdline for up to 50 times, and return an empty list as last resort. - :gh:`2254`, [Linux]: offline cpus raise NotImplementedError in cpu_freq() (patch by Shade Gladden) - :gh:`2272`: Add pickle support to psutil Exceptions. - :gh:`2359`, [Windows], [CRITICAL]: :func:`pid_exists` disagrees with :class:`Process` on whether a pid exists when ERROR_ACCESS_DENIED. - :gh:`2360`, [macOS]: can't compile on macOS < 10.13. (patch by Ryan Schmidt) - :gh:`2362`, [macOS]: can't compile on macOS 10.11. (patch by Ryan Schmidt) - :gh:`2365`, [macOS]: can't compile on macOS < 10.9. (patch by Ryan Schmidt) - :gh:`2395`, [OpenBSD]: :func:`pid_exists` erroneously return True if the argument is a thread ID (TID) instead of a PID (process ID). - :gh:`2412`, [macOS]: can't compile on macOS 10.4 PowerPC due to missing `MNT_` constants. **Porting notes** Version 6.0.0 introduces some changes which affect backward compatibility: - :gh:`2109`: the named tuple returned by :func:`disk_partitions`' no longer has ``maxfile`` and ``maxpath`` fields. - :gh:`2396`: :func:`process_iter` no longer pre-emptively checks whether PIDs have been reused. If you want to check for PID reusage you are supposed to use :meth:`Process.is_running` against the yielded :class:`Process` instances. That will also automatically remove reused PIDs from :func:`process_iter` internal cache. - :gh:`2407`: :meth:`Process.connections` was renamed to :meth:`Process.net_connections`. The old name is still available, but it's deprecated (triggers a ``DeprecationWarning``) and will be removed in the future. 5.9.8 — 2024-01-19 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2343`, [FreeBSD]: filter :func:`net_connections` returned list in C instead of Python, and avoid to retrieve unnecessary connection types unless explicitly asked. E.g., on an IDLE system with few IPv6 connections this will run around 4 times faster. Before all connection types (TCP, UDP, UNIX) were retrieved internally, even if only a portion was returned. - :gh:`2342`, [NetBSD]: same as above (#2343) but for NetBSD. - :gh:`2349`: adopted black formatting style. **Bug fixes** - :gh:`930`, [NetBSD], [critical]: :func:`net_connections` implementation was broken. It could either leak memory or core dump. - :gh:`2340`, [NetBSD]: if process is terminated, :meth:`Process.cwd` will return an empty string instead of raising :exc:`NoSuchProcess`. - :gh:`2345`, [Linux]: fix compilation on older compiler missing DUPLEX_UNKNOWN. - :gh:`2222`, [macOS]: `cpu_freq()` now returns fixed values for `min` and `max` frequencies in all Apple Silicon chips. 5.9.7 — 2023-12-17 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2324`: enforce Ruff rule `raw-string-in-exception`, which helps providing clearer tracebacks when exceptions are raised by psutil. **Bug fixes** - :gh:`2325`, [PyPy]: psutil did not compile on PyPy due to missing `PyErr_SetExcFromWindowsErrWithFilenameObject` cPython API. 5.9.6 — 2023-10-15 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1703`: :func:`cpu_percent` and :func:`cpu_times_percent` are now thread safe, meaning they can be called from different threads and still return meaningful and independent results. Before, if (say) 10 threads called ``cpu_percent(interval=None)`` at the same time, only 1 thread out of 10 would get the right result. - :gh:`2266`: if :class:`Process` class is passed a very high PID, raise :exc:`NoSuchProcess` instead of OverflowError. (patch by Xuehai Pan) - :gh:`2246`: drop python 3.4 & 3.5 support. (patch by Matthieu Darbois) - :gh:`2290`: PID reuse is now pre-emptively checked for :meth:`Process.ppid` and :meth:`Process.parents`. - :gh:`2312`: use ``ruff`` Python linter instead of ``flake8 + isort``. It's an order of magnitude faster + it adds a ton of new code quality checks. **Bug fixes** - :gh:`2195`, [Linux]: no longer print exception at import time in case /proc/stat can't be read due to permission error. Redirect it to ``PSUTIL_DEBUG`` instead. - :gh:`2241`, [NetBSD]: can't compile On NetBSD 10.99.3/amd64. (patch by Thomas Klausner) - :gh:`2245`, [Windows]: fix var unbound error on possibly in :func:`swap_memory` (patch by student_2333) - :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/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 pre-emptively 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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2196`: in case of exception, display a cleaner error traceback by hiding the `KeyError` bit deriving from a missed cache hit. - :gh:`2217`: print the full traceback when a `DeprecationWarning` or `UserWarning` is raised. - :gh:`2230`, [OpenBSD]: :func:`net_connections` implementation was rewritten from scratch: - We're now able to retrieve the path of AF_UNIX sockets (before it was an empty string) - The function is faster since it no longer iterates over all processes. - No longer produces duplicate connection entries. - :gh:`2238`: there are cases where :meth:`Process.cwd` cannot be determined (e.g. directory no longer exists), in which case we returned either ``None`` or an empty string. This was consolidated and we now return ``""`` on all platforms. - :gh:`2239`, [UNIX]: if process is a zombie, and we can only determine part of the its truncated :meth:`Process.name` (15 chars), don't fail with :exc:`ZombieProcess` when we try to guess the full name from the :meth:`Process.cmdline`. Just return the truncated name. - :gh:`2240`, [NetBSD], [OpenBSD]: add CI testing on every commit for NetBSD and OpenBSD platforms (python 3 only). **Bug fixes** - :gh:`1043`, [OpenBSD] :func:`net_connections` returns duplicate entries. - :gh:`1915`, [Linux]: on certain kernels, ``"MemAvailable"`` field from ``/proc/meminfo`` returns ``0`` (possibly a kernel bug), in which case we calculate an approximation for ``available`` memory which matches "free" CLI utility. - :gh:`2164`, [Linux]: compilation fails on kernels < 2.6.27 (e.g. CentOS 5). - :gh:`2186`, [FreeBSD]: compilation fails with Clang 15. (patch by Po-Chuan Hsieh) - :gh:`2191`, [Linux]: :func:`disk_partitions`: do not unnecessarily read /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 ``started`` attribute (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]: *available* :func:`virtual_memory` is higher than *total*. - :gh:`2234`, [NetBSD]: :func:`virtual_memory` metrics are wrong: *available* and *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 ``FileNotFoundError`` if cwd no longer exists. Return an empty string instead. 5.9.4 — 2022-11-07 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2102`: use Limited API when building wheels with CPython 3.6+ on Linux, macOS and Windows. This allows to use pre-built wheels in all future versions of cPython 3. (patch by Matthieu Darbois) **Bug fixes** - :gh:`2077`, [Windows]: Use system-level values for :func:`virtual_memory`. (patch by Daniel Widdis) - :gh:`2156`, [Linux]: compilation may fail on very old gcc compilers due to missing ``SPEED_UNKNOWN`` definition. (patch by Amir Rossert) - :gh:`2010`, [macOS]: on MacOS, arm64 ``IFM_1000_TX`` and ``IFM_1000_T`` are the same value, causing a build failure. (patch by Lawrence D'Anna) - :gh:`2160`, [Windows]: Get Windows percent swap usage from performance counters. (patch by Daniel Widdis) 5.9.3 — 2022-10-18 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`2040`, [macOS]: provide wheels for arm64 architecture. (patch by Matthieu Darbois) **Bug fixes** - :gh:`2116`, [macOS], [critical]: :func:`net_connections` fails with RuntimeError. - :gh:`2135`, [macOS]: :meth:`Process.environ` may contain garbage data. Fix out-of-bounds read around ``sysctl_procargs``. (patch by Bernhard Urban-Forster) - :gh:`2138`, [Linux], **[critical]**: can't compile psutil on Android due to undefined ``ethtool_cmd_speed`` symbol. - :gh:`2142`, [POSIX]: :func:`net_if_stats` 's ``flags`` on Python 2 returned unicode instead of str. (patch by Matthieu Darbois) - :gh:`2147`, [macOS] Fix disk usage report on macOS 12+. (patch by Matthieu Darbois) - :gh:`2150`, [Linux] :meth:`Process.threads` may raise ``NoSuchProcess``. Fix race condition. (patch by Daniel Li) - :gh:`2153`, [macOS] Fix race condition in test_posix.TestProcess.test_cmdline. (patch by Matthieu Darbois) 5.9.2 — 2022-09-04 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`2093`, [FreeBSD], **[critical]**: :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], **[critical]**: :func:`virtual_memory` may raise ENOMEM due to missing ``#include `` directive. (patch by Peter Jeremy) - :gh:`2128`, [NetBSD]: :func:`swap_memory` was miscalculated. (patch by Thomas Klausner) 5.9.1 — 2022-05-20 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1053`: drop Python 2.6 support. (patches by Matthieu Darbois and Hugo van Kemenade) - :gh:`2037`: Add additional flags to net_if_stats. - :gh:`2050`, [Linux]: increase ``read(2)`` buffer size from 1k to 32k when reading ``/proc`` pseudo files line by line. This should help having more consistent results. - :gh:`2057`, [OpenBSD]: add support for :func:`cpu_freq`. - :gh:`2107`, [Linux]: :meth:`Process.memory_full_info` (reporting process USS/PSS/Swap memory) now reads ``/proc/pid/smaps_rollup`` instead of ``/proc/pids/smaps``, which makes it 5 times faster. **Bug fixes** - :gh:`2048`: ``AttributeError`` is raised if ``psutil.Error`` class is raised manually and passed through ``str``. - :gh:`2049`, [Linux]: :func:`cpu_freq` erroneously returns ``curr`` value in GHz while ``min`` and ``max`` are in MHz. - :gh:`2050`, [Linux]: :func:`virtual_memory` may raise ``ValueError`` if running in a LCX container. 5.9.0 — 2021-12-29 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1851`, [Linux]: :func:`cpu_freq` is slow on systems with many CPUs. Read current frequency values for all CPUs from ``/proc/cpuinfo`` instead of opening many files in ``/sys`` fs. (patch by marxin) - :gh:`1992`: :exc:`NoSuchProcess` message now specifies if the PID has been reused. - :gh:`1992`: error classes (:exc:`NoSuchProcess`, :exc:`AccessDenied`, etc.) now have a better formatted and separated ``__repr__`` and ``__str__`` implementations. - :gh:`1996`, [BSD]: add support for MidnightBSD. (patch by Saeed Rasooli) - :gh:`1999`, [Linux]: :func:`disk_partitions`: convert ``/dev/root`` device (an alias used on some Linux distros) to real root device path. - :gh:`2005`: ``PSUTIL_DEBUG`` mode now prints file name and line number of the debug messages coming from C extension modules. - :gh:`2042`: rewrite HISTORY.rst to use hyperlinks pointing to psutil API doc. **Bug fixes** - :gh:`1456`, [macOS], **[critical]**: :func:`cpu_freq` ``min`` and ``max`` are set to 0 if can't be determined (instead of crashing). - :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 mountpoints 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. - :gh:`1901`, [macOS]: different functions, especially :meth:`Process.open_files` and :meth:`Process.connections`, could randomly raise :exc:`AccessDenied` because the internal buffer of ``proc_pidinfo(PROC_PIDLISTFDS)`` syscall was not big enough. We now dynamically increase the buffer size until it's big enough instead of giving up and raising :exc:`AccessDenied`, which was a fallback to avoid crashing. - :gh:`1904`, [Windows]: ``OpenProcess`` fails with ``ERROR_SUCCESS`` due to ``GetLastError()`` called after ``sprintf()``. (patch by alxchk) - :gh:`1913`, [Linux]: :func:`wait_procs` should catch ``subprocess.TimeoutExpired`` exception. - :gh:`1919`, [Linux]: :func:`sensors_battery` can raise ``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 Nikita Radchenko) - :gh:`1948`, **[critical]**: ``memoize_when_activated`` decorator is not thread-safe. (patch by Xuehai Pan) - :gh:`1953`, [Windows], **[critical]**: :func:`disk_partitions` crashes due to insufficient buffer len. (patch by MaWe2019) - :gh:`1965`, [Windows], **[critical]**: fix "Fatal Python error: deallocating None" when calling :func:`users` multiple times. - :gh:`1980`, [Windows]: 32bit / WoW64 processes fails to read :meth:`Process.name` longer than 128 characters resulting in :exc:`AccessDenied`. This is now fixed. (patch by PetrPospisil) - :gh:`1991`, **[critical]**: :func:`process_iter` is not thread safe and can raise ``TypeError`` if invoked from multiple threads. - :gh:`1956`, [macOS]: :meth:`Process.cpu_times` reports incorrect timings on M1 machines. (patch by Olivier Dormond) - :gh:`2023`, [Linux]: :func:`cpu_freq` return order is wrong on systems with more than 9 CPUs. 5.8.0 — 2020-12-19 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1863`: :func:`disk_partitions` exposes 2 extra fields: ``maxfile`` and ``maxpath``, which are the maximum file name and path name length. - :gh:`1872`, [Windows]: added support for PyPy 2.7. - :gh:`1879`: provide pre-compiled wheels for Linux and macOS (yey!). - :gh:`1880`: get rid of Travis and Cirrus CI services (they are no longer free). CI testing is now done by GitHub Actions on Linux, macOS and FreeBSD (yes). AppVeyor is still being used for Windows CI. **Bug fixes** - :gh:`1708`, [Linux]: get rid of :func:`sensors_temperatures` duplicates. (patch by Tim Schlueter). - :gh:`1839`, [Windows], **[critical]**: always raise :exc:`AccessDenied` instead of ``WindowsError`` when failing to query 64 processes from 32 bit ones by using ``NtWoW64`` APIs. - :gh:`1866`, [Windows], **[critical]**: :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], **[critical]**: :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], **[critical]**: ``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-23 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`809`, [FreeBSD]: add support for :meth:`Process.rlimit`. - :gh:`893`, [BSD]: add support for :meth:`Process.environ` (patch by Armin Gruner) - :gh:`1830`, [POSIX]: :func:`net_if_stats` ``isup`` also checks whether the NIC is running (meaning Wi-Fi or ethernet cable is connected). (patch by Chris Burger) - :gh:`1837`, [Linux]: improved battery detection and charge ``secsleft`` calculation (patch by aristocratos) **Bug fixes** - :gh:`1620`, [Linux]: :func:`cpu_count` with ``logical=False`` result is incorrect on systems with more than one CPU socket. (patch by Vincent A. Arcila) - :gh:`1738`, [macOS]: :meth:`Process.exe` may raise ``FileNotFoundError`` if process is still alive but the exe file which launched it got deleted. - :gh:`1791`, [macOS]: fix missing include for ``getpagesize()``. - :gh:`1823`, [Windows], **[critical]**: :meth:`Process.open_files` may cause a segfault due to a NULL pointer. - :gh:`1838`, [Linux]: :func:`sensors_battery`: if `percent` can be determined but not the remaining values, still return a result instead of ``None``. (patch by aristocratos) 5.7.2 — 2020-07-15 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - wheels for 2.7 were inadvertently deleted. 5.7.1 — 2020-07-15 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1729`: parallel tests on POSIX (``make test-parallel``). They're twice as fast! - :gh:`1741`, [POSIX]: ``make build`` now runs in parallel on Python >= 3.6 and it's about 15% faster. - :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 ````. - :gh:`1747`: :class:`Process` class provides more info about the process on ``str()`` and ``repr()`` (status and exit code). - :gh:`1757`: memory leak tests are now stable. - :gh:`1768`, [Windows]: added support for Windows Nano Server. (contributed by Julien Lebot) **Bug fixes** - :gh:`1726`, [Linux]: :func:`cpu_freq` parsing should use spaces instead of tabs on ia64. (patch by Michał Górny) - :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`. - :gh:`1781`, **[critical]**: :func:`getloadavg` can crash the Python interpreter. (patch by Ammar Askar) 5.7.0 — 2020-02-18 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1637`, [SunOS]: add partial support for old SunOS 5.10 Update 0 to 3. - :gh:`1648`, [Linux]: :func:`sensors_temperatures` looks into an additional ``/sys/device/`` directory for additional data. (patch by Javad Karabi) - :gh:`1652`, [Windows]: dropped support for Windows XP and Windows Server 2003. Minimum supported Windows version now is Windows Vista. - :gh:`1671`, [FreeBSD]: add CI testing/service for FreeBSD (Cirrus CI). - :gh:`1677`, [Windows]: :meth:`Process.exe` will succeed for all process PIDs (instead of raising :exc:`AccessDenied`). - :gh:`1679`, [Windows]: :func:`net_connections` and :meth:`Process.connections` are 10% faster. - :gh:`1682`, [PyPy]: added CI / test integration for PyPy via Travis. - :gh:`1686`, [Windows]: added support for PyPy on Windows. - :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). **Bug fixes** - :gh:`1538`, [NetBSD]: :meth:`Process.cwd` may return ``ENOENT`` instead of :exc:`NoSuchProcess`. - :gh:`1627`, [Linux]: :meth:`Process.memory_maps` can raise ``KeyError``. - :gh:`1642`, [SunOS]: querying basic info for PID 0 results in ``FileNotFoundError``. - :gh:`1646`, [FreeBSD], **[critical]**: many :class:`Process` methods may cause a segfault due to a backward incompatible change in a C type on FreeBSD 12.0. - :gh:`1656`, [Windows]: :meth:`Process.memory_full_info` raises :exc:`AccessDenied` even for the current user and os.getpid(). - :gh:`1660`, [Windows]: :meth:`Process.open_files` complete rewrite + check of errors. - :gh:`1662`, [Windows], **[critical]**: :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 Mike Hommey) - :gh:`1672`: use the right C type when dealing with PIDs (int or long). Thus far (long) was almost always assumed, which is wrong on most platforms. - :gh:`1673`, [OpenBSD]: :meth:`Process.connections`, :meth:`Process.num_fds` and :meth:`Process.threads` returned improper exception if process is gone. - :gh:`1674`, [SunOS]: :func:`disk_partitions` may raise ``OSError``. - :gh:`1684`, [Linux]: :func:`disk_io_counters` may raise ``ValueError`` on systems not having ``/proc/diskstats``. - :gh:`1695`, [Linux]: could not compile on kernels <= 2.6.13 due to ``PSUTIL_HAS_IOPRIO`` not being defined. (patch by Anselm Kruis) 5.6.7 — 2019-11-26 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`1630`, [Windows], **[critical]**: can't compile source distribution due to C syntax error. 5.6.6 — 2019-11-25 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`1179`, [Linux]: :meth:`Process.cmdline` now takes into account misbehaving processes renaming the command line and using inappropriate chars to separate args. - :gh:`1616`, **[critical]**: use of ``Py_DECREF`` instead of ``Py_CLEAR`` will result in double ``free()`` and segfault (`CVE-2019-18874 `__). (patch by Riccardo Schirone) - :gh:`1619`, [OpenBSD], **[critical]**: compilation fails due to C syntax error. (patch by Nathan Houghton) 5.6.5 — 2019-11-06 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`1615`: remove ``pyproject.toml`` as it was causing installation issues. 5.6.4 — 2019-11-04 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1527`, [Linux]: added :meth:`Process.cpu_times` ``iowait`` counter, which is the time spent waiting for blocking I/O to complete. - :gh:`1565`: add PEP 517/8 build backend and requirements specification for better pip integration. (patch by Bernát Gábor) **Bug fixes** - :gh:`875`, [Windows], **[critical]**: :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:`1126`, [Linux], **[critical]**: :meth:`Process.cpu_affinity` segfaults on CentOS 5 / manylinux. :meth:`Process.cpu_affinity` support for CentOS 5 was removed. - :gh:`1528`, [AIX], **[critical]**: compilation error on AIX 7.2 due to 32 vs 64 bit differences. (patch by Arnon Yaari) - :gh:`1535`: ``type`` and ``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`, [OSX]: avoid calling ``close()`` (in C) on possible negative integers. (patch by Athos Ribeiro) - :gh:`1606`, [SunOS], **[critical]**: compilation fails on SunOS 5.10. (patch by vser1) 5.6.3 — 2019-06-11 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1494`, [AIX]: added support for :meth:`Process.environ`. (patch by Arnon Yaari) **Bug fixes** - :gh:`1276`, [AIX]: can't get whole :meth:`Process.cmdline`. (patch by Arnon Yaari) - :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], **[critical]**: :meth:`Process.cmdline` could raise ``MemoryError``. (patch by Kamil Rytarowski) 5.6.2 — 2019-04-26 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`604`, [Windows]: add new :func:`getloadavg`, returning system load average calculation, including on Windows (emulated). (patch by Ammar Askar) - :gh:`1404`, [Linux]: :func:`cpu_count` with ``logical=False`` uses a second method (read from ``/sys/devices/system/cpu/cpu[0-9]/topology/core_id``) in order to determine the number of CPU cores in case ``/proc/cpuinfo`` does not provide this info. - :gh:`1458`: provide coloured test output. Also show failures on ``KeyboardInterrupt``. - :gh:`1464`: various docfixes (always point to Python 3 doc, fix links, etc.). - :gh:`1476`, [Windows]: it is now possible to set process high I/O priority (:meth:`Process.ionice`). Also, I/O priority values are now exposed as 4 new constants: ``IOPRIO_VERYLOW``, ``IOPRIO_LOW``, ``IOPRIO_NORMAL``, ``IOPRIO_HIGH``. - :gh:`1478`: add make command to re-run tests failed on last run. **Bug fixes** - :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 ``min`` and ``max`` fields can't be determined. (patch by Alex Manuskin) - :gh:`1462`, [Linux]: (tests) make tests invariant to ``LANG`` setting (patch by Benjamin Drung) - :gh:`1463`: `cpu_distribution.py`_ script was broken. - :gh:`1470`, [Linux]: :func:`disk_partitions`: fix corner case when ``/etc/mtab`` doesn't exist. (patch by Cedric Lamoriniere) - :gh:`1471`, [SunOS]: :meth:`Process.name` and :meth:`Process.cmdline` can return ``SystemError``. (patch by Daniel Beer) - :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], **[critical]**: ``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:`1480`, [Windows], **[critical]**: :func:`cpu_count` with ``logical=False`` could cause a crash due to fixed read violation. (patch by Samer Masterson) - :gh:`1486`, [AIX], [SunOS]: ``AttributeError`` when interacting with :class:`Process` methods involved into :meth:`Process.oneshot` context. - :gh:`1491`, [SunOS]: :func:`net_if_addrs`: use ``free()`` against ``ifap`` struct on error. (patch by Agnewee) - :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:`1329`, [AIX]: psutil doesn't compile on AIX 6.1. (patch by Arnon Yaari) - :gh:`1448`, [Windows], **[critical]**: crash on import due to ``rtlIpv6AddressToStringA`` not available on Wine. - :gh:`1451`, [Windows], **[critical]**: :meth:`Process.memory_full_info` segfaults. ``NtQueryVirtualMemory`` is now used instead of ``QueryWorkingSet`` to calculate USS memory. 5.6.0 — 2019-03-05 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1379`, [Windows]: :meth:`Process.suspend` and :meth:`Process.resume` now use ``NtSuspendProcess`` and ``NtResumeProcess`` instead of stopping/resuming all threads of a process. This is faster and more reliable (aka this is what ProcessHacker does). - :gh:`1420`, [Windows]: in case of exception :func:`disk_usage` now also shows the path name. - :gh:`1422`, [Windows]: Windows APIs requiring to be dynamically loaded from DLL libraries are now loaded only once on startup (instead of on per function call) significantly speeding up different functions and methods. - :gh:`1426`, [Windows]: ``PAGESIZE`` and number of processors is now calculated on startup. - :gh:`1428`: in case of error, the traceback message now shows the underlying C function called which failed. - :gh:`1433`: new :meth:`Process.parents` method. (idea by Ghislain Le Meur) - :gh:`1437`: :func:`pids` are returned in sorted order. - :gh:`1442`: Python 3 is now the default interpreter used by Makefile. **Bug fixes** - :gh:`1353`: :func:`process_iter` is now thread safe (it rarely raised ``TypeError``). - :gh:`1394`, [Windows], **[critical]**: :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:`1411`, [BSD]: lack of ``Py_DECREF`` could cause segmentation fault on process instantiation. - :gh:`1419`, [Windows]: :meth:`Process.environ` raises ``NotImplementedError`` when querying a 64-bit process in 32-bit-WoW mode. Now it raises :exc:`AccessDenied`. - :gh:`1427`, [OSX]: :meth:`Process.cmdline` and :meth:`Process.environ` may erroneously raise ``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]: :meth:`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. **Incompatible API changes** - :gh:`1291`, [OSX], **[critical]**: :meth:`Process.memory_maps` was removed because inherently broken (segfault) for years. 5.5.1 — 2019-02-15 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1348`, [Windows]: on Windows >= 8.1 if :meth:`Process.cmdline` fails due to ``ERROR_ACCESS_DENIED`` attempt using ``NtQueryInformationProcess`` + ``ProcessCommandLineInformation``. (patch by EccoTheFlintstone) **Bug fixes** - :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. - :gh:`1408`, [AIX], **[critical]**: psutil won't compile on AIX 7.1 due to missing header. (patch by Arnon Yaari) 5.5.0 — 2019-01-23 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1350`, [FreeBSD]: added support for :func:`sensors_temperatures`. (patch by Alex Manuskin) - :gh:`1352`, [FreeBSD]: added support for :func:`cpu_freq`. (patch by Alex Manuskin) **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`, **[critical]**: 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`` access rights wherever possible, resulting in less :exc:`AccessDenied` exceptions being thrown for system processes. - :gh:`1376`, [Windows]: check if variable is ``NULL`` before ``free()`` ing it. (patch by EccoTheFlintstone) 5.4.8 — 2018-10-30 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1197`, [Linux]: :func:`cpu_freq` is now implemented by parsing ``/proc/cpuinfo`` in case ``/sys/devices/system/cpu/*`` filesystem is not available. - :gh:`1310`, [Linux]: :func:`sensors_temperatures` now parses ``/sys/class/thermal`` in case ``/sys/class/hwmon`` fs is not available (e.g. Raspberry Pi). (patch by Alex Manuskin) - :gh:`1320`, [POSIX]: better compilation support when using g++ instead of GCC. (patch by Jaime Fullaondo) **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 ``ValueError``. - :gh:`1277`, [OSX]: 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 Sylvain Duchesne) - :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 Jaime Fullaondo) - :gh:`1332`, [OSX]: psutil debug messages are erroneously printed all the time. (patch by Ilya Yanok) - :gh:`1346`, [SunOS]: :func:`net_connections` returns an empty list. (patch by Oleksii Shevchuk) 5.4.7 — 2018-08-14 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1286`, [macOS]: ``psutil.OSX`` constant is now deprecated in favor of new ``psutil.MACOS``. - :gh:`1309`, [Linux]: added ``psutil.STATUS_PARKED`` constant for :meth:`Process.status`. - :gh:`1321`, [Linux]: add :func:`disk_io_counters` dual implementation relying on ``/sys/block`` filesystem in case ``/proc/diskstats`` is not available. (patch by Lawrence Ye) **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 Nikhil Marathe) - :gh:`1279`, [Linux], [macOS], [BSD]: :func:`net_if_stats` may return ``ENODEV``. - :gh:`1294`, [Windows]: :meth:`Process.connections` may sometime fail with ``MemoryError``. (patch by 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 ``"idle"`` and ``"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 ``ValueError``. 5.4.6 — 2018-06-07 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`1258`, [Windows], **[critical]**: :meth:`Process.username` may cause a segfault (Python interpreter crash). (patch by Jean-Luc Migot) - :gh:`1273`: :func:`net_if_addrs` named tuple's name has been renamed from ``snic`` to ``snicaddr``. - :gh:`1274`, [Linux]: there was a small chance :meth:`Process.children` may swallow :exc:`AccessDenied` exceptions. 5.4.5 — 2018-04-14 ^^^^^^^^^^^^^^^^^^ **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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1239`, [Linux]: expose kernel ``slab`` memory field for :func:`virtual_memory`. (patch by Maxime Mouial) **Bug fixes** - :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 Georg Sauthoff) - :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 Georg Sauthoff) - :gh:`1194`, [SunOS]: return nice value from ``psinfo`` as ``getpriority()`` doesn't support real-time processes. (patch by Georg Sauthoff) - :gh:`1194`, [SunOS]: fix double ``free()`` in :meth:`Process.cpu_num`. (patch by Georg Sauthoff) - :gh:`1194`, [SunOS]: fix undefined behavior related to strict-aliasing rules and warnings. (patch by Georg Sauthoff) - :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 Arnon Yaari) - :gh:`1216`: fix compatibility with Python 2.6 on Windows (patch by Dan Vinakovsky) - :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 stswandering) - :gh:`1245`, [Linux]: :func:`sensors_temperatures` may fail with ``IOError`` "no such file". - :gh:`1255`, [FreeBSD]: :func:`swap_memory` stats were erroneously represented in KB. (patch by Denis Krienbühl) **Backward compatibility** - :gh:`771`, [Windows]: :func:`cpu_count` with ``logical=False`` on Windows XP and Vista is no longer supported and returns ``None``. 5.4.3 — 2018-01-01 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`775`: :func:`disk_partitions` on Windows return mount points. **Bug fixes** - :gh:`1193`: :func:`pids` may return ``False`` on macOS. 5.4.2 — 2017-12-07 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1173`: introduced ``PSUTIL_DEBUG`` environment variable which can be set in order to print useful debug messages on stderr (useful in case of nasty errors). - :gh:`1177`, [macOS]: added support for :func:`sensors_battery`. (patch by Arnon Yaari) - :gh:`1183`: :meth:`Process.children` is 2x faster on POSIX and 2.4x faster on Linux. - :gh:`1188`: deprecated method :meth:`Process.memory_info_ex` now warns by using ``FutureWarning`` instead of ``DeprecationWarning``. **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 janderbrain) - :gh:`1172`, [Windows]: ``make test`` does not work. - :gh:`1179`, [Linux]: :meth:`Process.cmdline` is now able to split cmdline args for misbehaving processes which overwrite ``/proc/pid/cmdline`` and use spaces instead of null bytes as args separator. - :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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1164`, [AIX]: add support for :meth:`Process.num_ctx_switches`. (patch by Arnon Yaari) - :gh:`1053`: drop Python 3.3 support (psutil still works but it's no longer tested). **Bug fixes** - :gh:`1150`, [Windows]: when a process is terminated now the exit code is set to ``SIGTERM`` instead of ``0``. (patch by Akos Kiss) - :gh:`1151`: ``python -m psutil.tests`` fail. - :gh:`1154`, [AIX], **[critical]**: psutil won't compile on AIX 6.1.0. (patch by Arnon Yaari) - :gh:`1167`, [Windows]: :func:`net_io_counters` packets count now include also non-unicast packets. (patch by Matthew Long) 5.4.0 — 2017-10-12 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1123`, [AIX]: added support for AIX platform. (patch by Arnon Yaari) **Bug fixes** - :gh:`1009`, [Linux]: :func:`sensors_temperatures` may crash with ``IOError``. - :gh:`1012`, [Windows]: :func:`disk_io_counters` ``read_time`` and ``write_time`` were expressed in tens of micro seconds instead of milliseconds. - :gh:`1127`, [macOS], **[critical]**: invalid reference counting in :meth:`Process.open_files` may lead to segfault. (patch by Jakub Bacic) - :gh:`1129`, [Linux]: :func:`sensors_fans` may crash with ``IOError``. (patch by Sebastian Saip) - :gh:`1131`, [SunOS]: fix compilation warnings. (patch by Arnon Yaari) - :gh:`1133`, [Windows]: can't compile on newer versions of Visual Studio 2017 15.4. (patch by Max Bélanger) - :gh:`1138`, [Linux]: can't compile on CentOS 5.0 and RedHat 5.0. (patch by Prodesire) 5.3.1 — 2017-09-10 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`1124`: documentation moved to http://psutil.readthedocs.io **Bug fixes** - :gh:`1105`, [FreeBSD]: psutil does not compile on FreeBSD 12. - :gh:`1125`, [BSD]: :func:`net_connections` raises ``TypeError``. **Compatibility notes** - :gh:`1120`: ``.exe`` files for Windows are no longer uploaded on PyPI as per PEP-527. Only wheels are provided. 5.3.0 — 2017-09-01 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`802`: :func:`disk_io_counters` and :func:`net_io_counters` numbers no longer wrap (restart from 0). Introduced a new ``nowrap`` argument. - :gh:`928`: :func:`net_connections` and :meth:`Process.connections` ``laddr`` and ``raddr`` are now named tuples. - :gh:`1015`: :func:`swap_memory` now relies on ``/proc/meminfo`` instead of ``sysinfo()`` syscall so that it can be used in conjunction with :data:`PROCFS_PATH` in order to retrieve memory info about Linux containers such as Docker and Heroku. - :gh:`1022`: :func:`users` provides a new ``pid`` field. - :gh:`1025`: :func:`process_iter` accepts two new parameters in order to invoke :meth:`Process.as_dict`: ``attrs`` and ``ad_value``. With these you can iterate over all processes in one shot without needing to catch :exc:`NoSuchProcess` and do list/dict comprehensions. - :gh:`1040`: implemented full unicode support. - :gh:`1051`: :func:`disk_usage` on Python 3 is now able to accept bytes. - :gh:`1058`: test suite now enables all warnings by default. - :gh:`1060`: source distribution is dynamically generated so that it only includes relevant files. - :gh:`1079`, [FreeBSD]: :func:`net_connections` ``fd`` number is now being set for real (instead of ``-1``). (patch by Gleb Smirnoff) - :gh:`1091`, [SunOS]: implemented :meth:`Process.environ`. (patch by Oleksii Shevchuk) **Bug fixes** - :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 value of the first call is now cached so that :func:`boot_time` always returns the same value if fluctuation is <= 1 second. - :gh:`1013`, [FreeBSD]: :func:`net_connections` may return incorrect PID. (patch by Gleb Smirnoff) - :gh:`1014`, [Linux]: :class:`Process` class can mask legitimate ``ENOENT`` exceptions as :exc:`NoSuchProcess`. - :gh:`1016`: :func:`disk_io_counters` raises ``RuntimeError`` on a system with no disks. - :gh:`1017`: :func:`net_io_counters` raises ``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 ``UnicodeDecodeError``. - :gh:`1033`, [macOS], [FreeBSD]: memory leak for :func:`net_connections` and :meth:`Process.connections` when retrieving UNIX sockets (``kind='unix'``). - :gh:`1040`: fixed many unicode related issues such as ``UnicodeDecodeError`` on Python 3 + POSIX and invalid encoded data on Windows. - :gh:`1042`, [FreeBSD], **[critical]**: psutil won't compile on FreeBSD 12. - :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:`1047`, [Windows]: :meth:`Process.username`: memory leak in case exception is thrown. - :gh:`1048`, [Windows]: :func:`users` ``host`` field report an invalid IP address. - :gh:`1050`, [Windows]: :meth:`Process.memory_maps` leaks memory. - :gh:`1055`: :func:`cpu_count` is no longer cached. This is useful on systems such as Linux where CPUs can be disabled at runtime. This also reflects on :meth:`Process.cpu_percent` which no longer uses the cache. - :gh:`1058`: fixed Python warnings. - :gh:`1062`: :func:`disk_io_counters` and :func:`net_io_counters` raise ``TypeError`` if no disks or NICs are installed on the system. - :gh:`1063`, [NetBSD]: :func:`net_connections` may list incorrect sockets. - :gh:`1064`, [NetBSD], **[critical]**: :func:`swap_memory` may segfault in case of error. - :gh:`1065`, [OpenBSD], **[critical]**: :meth:`Process.cmdline` may raise ``SystemError``. - :gh:`1067`, [NetBSD]: :meth:`Process.cmdline` leaks memory if process has terminated. - :gh:`1069`, [FreeBSD]: :meth:`Process.cpu_num` may return 255 for certain kernel processes. - :gh:`1071`, [Linux]: :func:`cpu_freq` may raise ``IOError`` on old RedHat distros. - :gh:`1074`, [FreeBSD]: :func:`sensors_battery` raises ``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 Oleksii Shevchuk) - :gh:`1077`, [SunOS]: :func:`net_connections` does not work on SunOS 5.10. (patch by Oleksii Shevchuk) - :gh:`1079`, [FreeBSD]: :func:`net_connections` didn't list locally connected sockets. (patch by Gleb Smirnoff) - :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]: :func:`pid_exists` may lie. Also, all process APIs relying on ``OpenProcess`` Windows API now check whether 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``. **Porting notes** - :gh:`1039`: 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` ``raddr`` is now set to ``""`` instead of ``None`` when retrieving UNIX sockets. - :gh:`1040`: all strings are encoded by using OS fs encoding. - :gh:`1040`: the following Windows APIs on Python 2 now return a string instead of unicode: ``Process.memory_maps().path``, ``WindowsService.bin_path()``, ``WindowsService.description()``, ``WindowsService.display_name()``, ``WindowsService.username()``. 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 Danek Duvall) - :gh:`1004`, [Linux]: :meth:`Process.io_counters` may raise ``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 ``OSError``. - :gh:`1010`, [Linux]: :func:`virtual_memory` may raise ``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 ``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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`971`, [Linux]: Add :func:`sensors_fans` function. (patch by Nicolas Hennion) - :gh:`976`, [Windows]: :meth:`Process.io_counters` has 2 new fields: ``other_count`` and ``other_bytes``. - :gh:`976`, [Linux]: :meth:`Process.io_counters` has 2 new fields: ``read_chars`` and ``write_chars``. **Bug fixes** - :gh:`872`, [Linux]: can now compile on Linux by using MUSL C library. - :gh:`985`, [Windows]: Fix a crash in :meth:`Process.open_files` when the worker thread for ``NtQueryObject`` times out. - :gh:`986`, [Linux]: :meth:`Process.cwd` may raise :exc:`NoSuchProcess` instead of :exc:`ZombieProcess`. 5.1.3 ^^^^^ **Bug fixes** - :gh:`971`, [Linux]: :func:`sensors_temperatures` didn't work on CentOS 7. - :gh:`973`, **[critical]**: :func:`cpu_percent` may raise ``ZeroDivisionError``. 5.1.2 — 2017-02-03 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`966`, [Linux]: :func:`sensors_battery` ``power_plugged`` may erroneously return ``None`` on Python 3. - :gh:`968`, [Linux]: :func:`disk_io_counters` raises ``TypeError`` on Python 3. - :gh:`970`, [Linux]: :func:`sensors_battery` ``name`` and ``label`` fields on Python 3 are bytes instead of str. 5.1.1 — 2017-02-03 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`966`, [Linux]: :func:`sensors_battery` ``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 ``FileNotFoundError``. - :gh:`966`, [Linux]: :func:`sensors_battery` ``power_plugged`` may lie. 5.1.0 — 2017-02-01 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`357`: added :meth:`Process.cpu_num` (what CPU a process is on). - :gh:`371`: added :func:`sensors_temperatures` (Linux only). - :gh:`941`: added :func:`cpu_freq` (CPU frequency). - :gh:`955`: added :func:`sensors_battery` (Linux, Windows, only). - :gh:`956`: :meth:`Process.cpu_affinity` can now be passed ``[]`` argument as an alias to set affinity against all eligible CPUs. **Bug fixes** - :gh:`687`, [Linux]: :func:`pid_exists` no longer returns ``True`` if passed a process thread ID. - :gh:`948`: cannot install psutil with ``PYTHONOPTIMIZE=2``. - :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]: ``WindowsService.description()`` method may fail with ``ERROR_MUI_FILE_NOT_FOUND``. 5.0.1 — 2016-12-21 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`939`: tar.gz distribution went from 1.8M to 258K. - :gh:`811`, [Windows]: provide a more meaningful error message if trying to use psutil on unsupported Windows XP. **Bug fixes** - :gh:`609`, [SunOS], **[critical]**: psutil does not compile on Solaris 10. - :gh:`936`, [Windows]: fix compilation error on VS 2013 (patch by Max Bélanger). - :gh:`940`, [Linux]: :func:`cpu_percent` and :func:`cpu_times_percent` was calculated incorrectly as ``iowait``, ``guest`` and ``guest_nice`` times were not properly taken into account. - :gh:`944`, [OpenBSD]: :func:`pids` was omitting PID 0. 5.0.0 — 2016-11-06 ^^^^^^^^^^^^^^^^^^ **Enhncements** - :gh:`799`: new :meth:`Process.oneshot` context manager making :class:`Process` methods around +2x faster in general and from +2x to +6x faster on Windows. - :gh:`943`: better error message in case of version conflict on import. **Bug fixes** - :gh:`932`, [NetBSD]: :func:`net_connections` and :meth:`Process.connections` may fail without raising an exception. - :gh:`933`, [Windows]: memory leak in :func:`cpu_stats` and ``WindowsService.description()`` method. 4.4.2 — 2016-10-26 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`931`, **[critical]**: psutil no longer compiles on Solaris. 4.4.1 — 2016-10-25 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`927`, **[critical]**: :class:`Popen` ``__del__`` may cause maximum recursion depth error. 4.4.0 — 2016-10-23 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`874`, [Windows]: make :func:`net_if_addrs` also return the ``netmask``. - :gh:`887`, [Linux]: :func:`virtual_memory` ``available`` and ``used`` values are more precise and match ``free`` cmdline utility. ``available`` also takes into account LCX containers preventing ``available`` to overflow ``total``. - :gh:`891`: `procinfo.py`_ script has been updated and provides a lot more info. **Bug fixes** - :gh:`514`, [macOS], **[critical]**: :meth:`Process.memory_maps` can segfault. - :gh:`783`, [macOS]: :meth:`Process.status` may erroneously return ``"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`: ``ValueError`` is raised if a negative integer is passed to :func:`cpu_percent` functions. - :gh:`892`, [Linux], **[critical]**: :meth:`Process.cpu_affinity` with ``[-1]`` as arg raises ``SystemError`` with no error set; now ``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 ``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 ``OSError`` and ``RuntimeError``. - :gh:`909`, [macOS]: :meth:`Process.open_files` and :meth:`Process.connections` methods may raise ``OSError`` with no exception set if process is gone. - :gh:`916`, [macOS]: fix many compilation warnings. 4.3.1 — 2016-09-01 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`881`: ``make install`` now works also when using a virtual env. **Bug fixes** - :gh:`854`: :meth:`Process.as_dict` raises ``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 ``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 :meth:`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). - :gh:`870`, [Windows]: handle leak inside ``psutil_get_process_data``. 4.3.0 — 2016-06-18 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`819`, [Linux]: different speedup improvements: :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:`810`, [Windows]: Windows wheels are incompatible with pip 7.1.2. - :gh:`812`, [NetBSD], **[critical]**: fix compilation on NetBSD-5.x. - :gh:`823`, [NetBSD]: :func:`virtual_memory` raises ``TypeError`` on Python 3. - :gh:`829`, [POSIX]: :func:`disk_usage` ``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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :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 ``shared`` memory field. - :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 ``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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`777`, [Linux]: :meth:`Process.open_files` on Linux return 3 new fields: ``position``, ``mode`` and ``flags``. - :gh:`779`: :meth:`Process.cpu_times` returns two new fields, ``children_user`` and ``children_system`` (always set to 0 on macOS and Windows). - :gh:`789`, [Windows]: :func:`cpu_times` return two new fields: ``interrupt`` and ``dpc``. Same for :func:`cpu_times_percent`. - :gh:`792`: new :func:`cpu_stats` function returning number of CPU ``ctx_switches``, ``interrupts``, ``soft_interrupts`` and ``syscalls``. **Bug fixes** - :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 wxwright) - :gh:`780`, [macOS]: psutil does not compile with some GCC versions. - :gh:`786`: :func:`net_if_addrs` may report incomplete MAC addresses. - :gh:`788`, [NetBSD]: :func:`virtual_memory` ``buffers`` and ``shared`` values were set to 0. - :gh:`790`, [macOS], **[critical]**: psutil won't compile on macOS 10.4. 4.0.0 — 2016-02-17 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`523`, [Linux], [FreeBSD]: :func:`disk_io_counters` return a new ``busy_time`` field. - :gh:`660`, [Windows]: make.bat is smarter in finding alternative VS install locations. (patch by mpderbec) - :gh:`732`: :meth:`Process.environ`. (patch by Frank Benkstein) - :gh:`753`, [Linux], [macOS], [Windows]: process USS and PSS (Linux) "real" memory stats. (patch by Eric Rahm) - :gh:`755`: :meth:`Process.memory_percent` ``memtype`` parameter. - :gh:`758`: tests now live in psutil namespace. - :gh:`760`: expose OS constants (``psutil.LINUX``, ``psutil.OSX``, etc.) - :gh:`756`, [Linux]: :func:`disk_io_counters` return 2 new fields: ``read_merged_count`` and ``write_merged_count``. - :gh:`762`: new `procsmem.py`_ script. **Bug fixes** - :gh:`685`, [Linux]: :func:`virtual_memory` provides wrong results on systems with a lot of physical memory. - :gh:`704`, [SunOS]: psutil does not compile on Solaris sparc. - :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 ``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:`741`, [OpenBSD]: psutil does not compile on mips64. - :gh:`751`, [Linux]: fixed call to ``Py_DECREF`` on possible ``NULL`` object. - :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:`764`, [NetBSD]: fix compilation on NetBSD-6.x. - :gh:`766`, [Linux]: :func:`net_connections` can't handle malformed ``/proc/net/unix`` file. - :gh:`767`, [Linux]: :func:`disk_io_counters` may raise ``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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`728`, [SunOS]: exposed :data:`PROCFS_PATH` constant to change the default location of ``/proc`` filesystem. **Bug fixes** - :gh:`724`, [FreeBSD]: :func:`virtual_memory` ``total`` is incorrect. - :gh:`730`, [FreeBSD], **[critical]**: :func:`virtual_memory` crashes with "OSError: [Errno 12] Cannot allocate memory". 3.4.1 — 2016-01-15 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`557`, [NetBSD]: added NetBSD support. (contributed by Ryo Onodera and Thomas Klausner) - :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. - :gh:`718`: :func:`process_iter` is now thread safe. **Bug fixes** - :gh:`714`, [OpenBSD]: :func:`virtual_memory` ``cached`` value was always set to 0. - :gh:`715`, **[critical]**: don't crash at import time if :func:`cpu_times` fail for some reason. - :gh:`717`, [Linux]: :meth:`Process.open_files` fails if deleted files still visible. - :gh:`722`, [Linux]: :func:`swap_memory` no longer crashes if ``sin`` / ``sout`` can't be determined due to missing ``/proc/vmstat``. - :gh:`724`, [FreeBSD]: :func:`virtual_memory` ``total`` is slightly incorrect. 3.3.0 — 2015-11-25 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`558`, [Linux]: exposed :data:`PROCFS_PATH` constant to change the default location of ``/proc`` filesystem. - :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:`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 dasumin) - :gh:`610`, [SunOS]: fix build and tests on Solaris 10 - :gh:`623`, [Linux]: process or system connections raises ``ValueError`` if IPv6 is not supported by the system. - :gh:`678`, [Linux], **[critical]**: can't install psutil due to bug in setup.py. - :gh:`688`, [Windows]: compilation fails with MSVC 2015, Python 3.5. (patch by Mike Sarahan) 3.2.1 — 2015-09-03 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`677`, [Linux], **[critical]**: can't install psutil due to bug in setup.py. 3.2.0 — 2015-09-02 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`644`, [Windows]: added support for ``CTRL_C_EVENT`` and ``CTRL_BREAK_EVENT`` signals to use with :meth:`Process.send_signal`. - :gh:`648`: CI test integration for macOS. (patch by Jeff Tang) - :gh:`663`, [POSIX]: :func:`net_if_addrs` now returns point-to-point (VPNs) addresses. - :gh:`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: :func:`net_if_addrs`, :func:`net_if_stats`, :func:`net_io_counters`, :meth:`Process.cmdline`, :meth:`Process.name`, :meth:`Process.username`, :func:`users`. **Bug fixes** - :gh:`513`, [Linux]: fixed integer overflow for ``RLIM_INFINITY``. - :gh:`641`, [Windows]: fixed many compilation warnings. (patch by Jeff Tang) - :gh:`652`, [Windows]: :func:`net_if_addrs` ``UnicodeDecodeError`` in case of non-ASCII NIC names. - :gh:`655`, [Windows]: :func:`net_if_stats` ``UnicodeDecodeError`` in case of non-ASCII NIC names. - :gh:`659`, [Linux]: compilation error on Suse 10. (patch by maozguttman) - :gh:`664`, [Linux]: compilation error on Alpine Linux. (patch by Bart van Kleef) - :gh:`670`, [Windows]: segfgault of :func:`net_if_addrs` in case of non-ASCII NIC names. (patch by sk6249) - :gh:`672`, [Windows]: compilation fails if using Windows SDK v8.0. (patch by Steven Winfield) - :gh:`675`, [Linux]: :func:`net_connections`: ``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 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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`534`, [Linux]: :func:`disk_partitions` added support for ZFS filesystems. - :gh:`646`, [Windows]: continuous tests integration for Windows with https://ci.appveyor.com/project/giampaolo/psutil. - :gh:`647`: new dev guide: https://github.com/giampaolo/psutil/blob/master/docs/DEVGUIDE.rst - :gh:`651`: continuous code quality test integration with scrutinizer-ci.com **Bug fixes** - :gh:`340`, [Windows], **[critical]**: :meth:`Process.open_files` no longer hangs. Instead it uses a thread which times out and skips the file handle in case it's taking too long to be retrieved. (patch by Jeff Tang) - :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`. - :gh:`637`, [POSIX]: raise exception if trying to send signal to PID 0 as it will affect ``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:`632`, [Linux]: better error message if cannot parse process UNIX connections. - :gh:`634`, [Linux]: :meth:`Process.cmdline` does not include empty string arguments. - :gh:`635`, [POSIX], **[critical]**: crash on module import if ``enum`` package is installed on Python < 3.4. 3.0.0 — 2015-06-13 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`250`: new :func:`net_if_stats` returning NIC statistics (``isup``, ``duplex``, ``speed``, ``mtu``). - :gh:`376`: new :func:`net_if_addrs` returning all NIC addresses a-la ``ifconfig``. - :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:`581`: add ``.gitignore``. (patch by Gabi Davar) - :gh:`582`: connection constants returned by :func:`net_connections` and :meth:`Process.connections` were turned from int to enums on Python > 3.4. - :gh:`587`: move native extension into the package. - :gh:`589`: :meth:`Process.cpu_affinity` accepts any kind of iterable (set, tuple, ...), not only lists. - :gh:`594`: all deprecated APIs were removed. - :gh:`599`, [Windows]: :meth:`Process.name` can now be determined for all processes even when running as a limited user. - :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:`428`, [POSIX], **[critical]**: correct handling of zombie processes on POSIX. Introduced new :exc:`ZombieProcess` exception class. - :gh:`512`, [BSD], **[critical]**: fix segfault in :func:`net_connections`. - :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 ``KeyError``. - :gh:`586`, [FreeBSD], **[critical]**: :meth:`Process.cpu_affinity` segfaults on set in case an invalid CPU number is provided. - :gh:`593`, [FreeBSD], **[critical]**: :meth:`Process.memory_maps` segfaults. - :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 Bruno Binet) 2.2.0 — 2015-01-06 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`521`: drop support for Python 2.4 and 2.5. - :gh:`553`: new `pstree.py`_ script. - :gh:`564`: C extension version mismatch in case the user messed up with psutil installation or with sys.path is now detected at import time. - :gh:`568`: new `pidof.py`_ script. - :gh:`569`, [FreeBSD]: add support for :meth:`Process.cpu_affinity` on FreeBSD. **Bug fixes** - :gh:`496`, [SunOS], **[critical]**: can't import psutil. - :gh:`547`, [POSIX]: :meth:`Process.username` may raise ``KeyError`` if UID can't be resolved. - :gh:`551`, [Windows]: get rid of the unicode hack for :func:`net_io_counters` NIC names. - :gh:`556`, [Linux]: lots of file handles were left open. - :gh:`561`, [Linux]: :func:`net_connections` might skip some legitimate UNIX sockets. (patch by spacewander) - :gh:`565`, [Windows]: use proper encoding for :meth:`Process.username` and :func:`users`. (patch by Sylvain Mouquet) - :gh:`567`, [Linux]: in the alternative implementation of :meth:`Process.cpu_affinity` ``PyList_Append`` and ``Py_BuildValue`` return values are not checked. - :gh:`569`, [FreeBSD]: fix memory leak in :func:`cpu_count` with ``logical=False``. - :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 ^^^^^^^^^^^^^^^^^^ - :gh:`536`, [Linux], **[critical]**: fix "undefined symbol: CPU_ALLOC" compilation error. 2.1.2 — 2014-09-21 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :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:`505`, [Windows]: distribution as wheel packages. - :gh:`511`: add `ps.py`_ script. **Bug fixes** - :gh:`340`, [Windows]: :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], **[critical]**: Python 2.4 support was broken. - :gh:`522`, [Linux]: :meth:`Process.cpu_affinity` might return ``EINVAL``. (patch by David Daeschler) - :gh:`529`, [Windows]: :meth:`Process.exe` may raise unhandled ``WindowsError`` exception for PIDs 0 and 4. (patch by Jeff Tang) - :gh:`530`, [Linux]: :func:`disk_io_counters` may crash on old Linux distros (< 2.6.5) (patch by Yaolong Huang) - :gh:`533`, [Linux]: :meth:`Process.memory_maps` may raise ``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 Szigeti Gabor Niif) - :gh:`460`, [Windows]: :func:`net_io_counters` wraps after 4G. - :gh:`491`, [Linux]: :func:`net_connections` exceptions. (patch by Alexander Grothe) 2.1.0 — 2014-04-08 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`387`: system-wide open connections a-la ``netstat`` (add :func:`net_connections`). **Bug fixes** - :gh:`421`, [SunOS], **[critical]**: 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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`424`, [Windows]: installer for Python 3.X 64 bit. - :gh:`427`: number of logical CPUs and physical cores (:func:`cpu_count`). - :gh:`447`: :func:`wait_procs` ``timeout`` parameter is now optional. - :gh:`452`: make :class:`Process` instances hashable and usable with ``set()`` s. - :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). - :gh:`463`: make timeout parameter of ``cpu_percent*`` functions default to ``0.0`` 'cause it's a common trap to introduce slowdowns. - :gh:`468`: move documentation to readthedocs.com. - :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. - :gh:`479`: long deprecated ``psutil.error`` module is gone; exception classes now live in psutil namespace only. **Bug fixes** - :gh:`193`: :class:`Popen` constructor can throw an exception if the spawned process terminates quickly. - :gh:`340`, [Windows]: :meth:`Process.open_files` no longer hangs. (patch by jtang@vahna.net) - :gh:`443`, [Linux]: fix a potential overflow issue for :meth:`Process.cpu_affinity` (set) on systems with more than 64 CPUs. - :gh:`448`, [Windows]: :meth:`Process.children` and :meth:`Process.ppid` memory leak (patch by Ulrich Klank). - :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 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`. **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_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() | +---------------+-----------------+ - 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. - :class:`Process` instances' ``retcode`` attribute returned by :func:`wait_procs` has been renamed to ``returncode`` for consistency with ``subprocess.Popen``. 1.2.1 — 2013-11-25 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`348`, [Windows], **[critical]**: fixed "ImportError: DLL load failed" occurring on module import on Windows XP. - :gh:`425`, [SunOS], **[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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`439`: assume ``os.getpid()`` if no argument is passed to :class:`Process` class constructor. - :gh:`440`: new :func:`wait_procs` utility function which waits for multiple processes to terminate. **Bug fixes** - :gh:`348`, [Windows]: fix "ImportError: DLL load failed" occurring on module import on Windows XP / Vista. 1.1.3 — 2013-11-07 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`442`, [Linux], **[critical]**: psutil won't compile on certain version of Linux because of missing ``prlimit(2)`` syscall. 1.1.2 — 2013-10-22 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`442`, [Linux], **[critical]**: psutil won't compile on Debian 6.0 because of missing ``prlimit(2)`` syscall. 1.1.1 — 2013-10-08 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`442`, [Linux], **[critical]**: psutil won't compile on kernels < 2.6.36 due to missing ``prlimit(2)`` syscall. 1.1.0 — 2013-09-28 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`410`: host tar.gz and Windows binary files are on PyPI. - :gh:`412`, [Linux]: get/set process resource limits (:meth:`Process.rlimit`). - :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`. **Bug fixes** - :gh:`391`, [Windows]: :func:`cpu_times_percent` returns negative percentages. - :gh:`408`: ``STATUS_*`` and ``CONN_*`` constants don't properly serialize on JSON. - :gh:`411`, [Windows]: `disk_usage.py`_ may pop-up a GUI error. - :gh:`413`, [Windows]: :meth:`Process.memory_info` leaks memory. - :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. **API changes** - :gh:`408`: turn ``STATUS_*`` and ``CONN_*`` constants into plain Python strings. 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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`18`, [SunOS]: add Solaris support (yay!) (thanks Justin Venus) - :gh:`367`: :meth:`Process.connections` ``status`` strings are now constants. - :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:`374`, [Windows]: negative memory usage reported if process uses a lot of memory. - :gh:`379`, [Linux]: :meth:`Process.memory_maps` may raise ``ValueError``. - :gh:`394`, [macOS]: mapped memory regions of :meth:`Process.memory_maps` report incorrect file name. - :gh:`404`, [Linux]: ``sched_*affinity()`` are implicitly declared. (patch by Arfrever) **API changes** - :meth:`Process.connections` ``status`` field is no longer a string but a constant object (``psutil.CONN_*``). - :meth:`Process.connections` ``local_address`` and ``remote_address`` fields renamed to ``laddr`` and ``raddr``. - psutil.network_io_counters() renamed to :func:`net_io_counters`. 0.7.1 — 2013-05-03 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`325`, [BSD], **[critical]**: :func:`virtual_memory` can raise ``SystemError``. (patch by Jan Beich) - :gh:`370`, [BSD]: :meth:`Process.connections` requires root. (patch by John Baldwin) - :gh:`372`, [BSD]: different process methods raise :exc:`NoSuchProcess` instead of :exc:`AccessDenied`. 0.7.0 — 2013-04-12 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`233`: code migrated to Mercurial (yay!) - :gh:`246`: psutil.error module is deprecated and scheduled for removal. - :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 ``steal``, ``guest`` and ``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). **Bug fixes** - :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:`313`, [Linux], **[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 ``RuntimeWarning`` instead. - :gh:`315`, [macOS]: fix some compilation warnings. - :gh:`317`, [Windows]: cannot set process CPU affinity above 31 cores. - :gh:`319`, [Linux]: :meth:`Process.memory_maps` raises ``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 zombie process. - :gh:`323`, [macOS]: :func:`disk_io_counters` ``read_time`` and ``write_time`` parameters were reporting microseconds not milliseconds. (patch by Gregory Szorc) - :gh:`331`: :meth:`Process.cmdline` is no longer cached after first access as it may change. - :gh:`333`, [macOS]: leak of Mach ports (patch by rsesek@google.com) - :gh:`337`, [Linux], **[critical]**: :class:`Process` methods not working because of a poor ``/proc`` implementation will raise ``NotImplementedError`` rather than ``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:`339`, [FreeBSD]: ``get_pid_list()`` can allocate all the memory on system. - :gh:`341`, [Linux], **[critical]**: psutil might crash on import due to error in retrieving system terminals map. - :gh:`344`, [FreeBSD]: :func:`swap_memory` might return incorrect results due to ``kvm_open(3)`` not being called. (patch by Jean Sebastien) - :gh:`338`, [Linux]: :func:`disk_io_counters` fails to find some disks. - :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], **[critical]**: :meth:`Process.memory_maps`, :meth:`Process.num_fds`, :meth:`Process.open_files` and :meth:`Process.cwd` methods raise ``RuntimeError`` instead of :exc:`AccessDenied`. **API changes** - :meth:`Process.cmdline` property is no longer cached after first access. - :meth:`Process.ppid` property is no longer cached after first access. - [Linux] :class:`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** - :gh:`316`: :meth:`Process.cmdline` property now makes a better job at guessing the process executable from the cmdline. **Bug fixes** - :gh:`316`: :meth:`Process.exe` was resolved in case it was a symlink. - :gh:`318`, **[critical]**: Python 2.4 compatibility was broken. **API changes** - :meth:`Process.exe` can now return an empty string instead of raising :exc:`AccessDenied`. - :meth:`Process.exe` is no longer resolved in case it's a symlink. 0.6.0 — 2012-08-13 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`216`, [POSIX]: :meth:`Process.connections` UNIX sockets support. - :gh:`220`, [FreeBSD]: ``get_connections()`` has been rewritten in C and no longer requires ``lsof``. - :gh:`222`, [macOS]: add support for :meth:`Process.cwd`. - :gh:`261`: per-process extended memory info (:meth:`Process.memory_info_ex`). - :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]: the :class:`Process` methods below were always raising :exc:`AccessDenied` for any process except the current one. Now this is no longer true. Also they are 2.5x faster. :meth:`Process.name`, :meth:`Process.memory_info`, :meth:`Process.memory_percent`, :meth:`Process.cpu_times`, :meth:`Process.cpu_percent`, :meth:`Process.num_threads`. - :gh:`300`: add `pmap.py`_ script. - :gh:`301`: :func:`process_iter` now yields processes sorted by their PIDs. - :gh:`302`: per-process number of voluntary and involuntary context switches (:meth:`Process.num_ctx_switches`). - :gh:`303`, [Windows]: the :class:`Process` methods below were always raising :exc:`AccessDenied` for any process not owned by current user. Now this is no longer true: :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`. - :gh:`305`: add `netstat.py`_ script. - :gh:`311`: system memory functions has been refactorized and rewritten and now provide a more detailed and consistent representation of the system memory. Added new :func:`virtual_memory` and :func:`swap_memory` functions. All old memory-related functions are deprecated. Also two new example scripts were added: `free.py`_ and `meminfo.py`_. - :gh:`312`: ``net_io_counters()`` named tuple includes 4 new fields: ``errin``, ``errout``, ``dropin`` and ``dropout``, reflecting the number of packets dropped and with errors. **Bug fixes** - :gh:`298`, [macOS], [BSD]: memory leak in :meth:`Process.num_fds`. - :gh:`299`: potential memory leak every time ``PyList_New(0)`` is used. - :gh:`303`, [Windows], **[critical]**: potential heap corruption in :meth:`Process.num_threads` and :meth:`Process.status` methods. - :gh:`305`, [FreeBSD], **[critical]**: can't compile on FreeBSD 9 due to removal of ``utmp.h``. - :gh:`306`, **[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:`307`, [FreeBSD]: values returned by :func:`net_io_counters` are wrong. - :gh:`308`, [BSD], [Windows]: ``psutil.virtmem_usage()`` wasn't actually returning information about swap memory usage as it was supposed to do. It does now. - :gh:`309`: :meth:`Process.open_files` might not return files which can not be accessed due to limited permissions. :exc:`AccessDenied` is now raised instead. **API changes** - ``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`) - [Windows], [BSD]: ``psutil.virtmem_usage()`` now returns information about swap memory instead of virtual memory. 0.5.1 — 2012-06-29 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`195`, [Windows]: number of handles opened by process (:meth:`Process.num_handles`). - :gh:`209`: :func:`disk_partitions` now provides also mount options. - :gh:`229`: list users currently connected on the system (:func:`users`). - :gh:`238`, [Linux], [Windows]: process CPU affinity (get and set, :meth:`Process.cpu_affinity`). - :gh:`242`: add ``recursive=True`` to :meth:`Process.children`: return all process descendants. - :gh:`245`, [POSIX]: :meth:`Process.wait` incrementally consumes less CPU cycles. - :gh:`257`, [Windows]: removed Windows 2000 support. - :gh:`258`, [Linux]: :meth:`Process.memory_info` is now 0.5x faster. - :gh:`260`: process's mapped memory regions. (Windows patch by wj32.64, macOS patch by Jeremy Whitlock) - :gh:`262`, [Windows]: :func:`disk_partitions` was slow due to inspecting the floppy disk drive also when parameter is ``all=False``. - :gh:`273`: ``psutil.get_process_list()`` is deprecated. - :gh:`274`: psutil no longer requires ``2to3`` at installation time in order to work with Python 3. - :gh:`278`: new :meth:`Process.as_dict` method. - :gh:`281`: :meth:`Process.ppid`, :meth:`Process.name`, :meth:`Process.exe`, :meth:`Process.cmdline` and :meth:`Process.create_time` properties of :class:`Process` class are now cached after being accessed. - :gh:`282`: ``psutil.STATUS_*`` constants can now be compared by using their string representation. - :gh:`283`: speedup :meth:`Process.is_running` by caching its return value in case the process is terminated. - :gh:`284`, [POSIX]: per-process number of opened file descriptors (:meth:`Process.num_fds`). - :gh:`287`: :func:`process_iter` now caches :class:`Process` instances between calls. - :gh:`290`: :meth:`Process.nice` property is deprecated in favor of new ``get_nice()`` and ``set_nice()`` methods. **Bug fixes** - :gh:`193`: :class:`Popen` constructor can throw an exception if the spawned process terminates quickly. - :gh:`240`, [macOS]: incorrect use of ``free()`` for :meth:`Process.connections`. - :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 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]: ``Process.io_counters()`` erroneously raise :exc:`NoSuchProcess` on old Linux versions. Where not available it now raises ``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. **API changes** - ``Process.nice`` property is deprecated in favor of new ``get_nice()`` and ``set_nice()`` methods. - ``psutil.get_process_list()`` is deprecated. - :meth:`Process.ppid`, :meth:`Process.name`, :meth:`Process.exe`, :meth:`Process.cmdline` and :meth:`Process.create_time` properties of :class:`Process` class are now cached after being accessed, meaning :exc:`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 ^^^^^^^^^^^^^^^^^^ **Bug fixes** - :gh:`228`: some example scripts were not working with Python 3. - :gh:`230`, [Windows], [macOS]: fix memory leak in :meth:`Process.connections`. - :gh:`232`, [Linux]: ``psutil.phymem_usage()`` can report erroneous values which are different than ``free`` command. - :gh:`236`, [Windows]: fix memory/handle leak in :meth:`Process.memory_info`, :meth:`Process.suspend` and :meth:`Process.resume` methods. 0.4.0 — 2011-10-29 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`150`: network I/O counters (:func:`net_io_counters`). (macOS and Windows patch by Jeremy Whitlock) - :gh:`154`, [FreeBSD]: add support for :meth:`Process.cwd`. - :gh:`157`, [Windows]: provide installer for Python 3.2 64-bit. - :gh:`198`: :meth:`Process.wait` with ``timeout=0`` can now be used to make the function return immediately. - :gh:`206`: disk I/O counters (:func:`disk_io_counters`). (macOS and Windows patch by Jeremy Whitlock) - :gh:`213`: add `iotop.py`_ script. - :gh:`217`: :meth:`Process.connections` now has a ``kind`` argument to filter for connections with different criteria. - :gh:`221`, [FreeBSD]: :meth:`Process.open_files` has been rewritten in C and no longer relies on ``lsof``. - :gh:`223`: add `top.py`_ script. - :gh:`227`: add `nettop.py`_ script. **Bug fixes** - :gh:`135`, [macOS]: psutil cannot create :class:`Process` object. - :gh:`144`, [Linux]: no longer support 0 special PID. - :gh:`188`, [Linux]: psutil import error on Linux ARM architectures. - :gh:`194`, [POSIX]: :meth:`Process.cpu_percent` now reports a percentage over 100 on multicore processors. - :gh:`197`, [Linux]: :meth:`Process.connections` is broken on platforms not supporting IPv6. - :gh:`200`, [Linux], **[critical]**: ``psutil.NUM_CPUS`` not working on armel and sparc architectures and causing crash on module import. - :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. - :gh:`218`, [Linux], **[critical]**: crash at import time on Debian 64-bit because of a missing line in ``/proc/meminfo``. - :gh:`226`, [FreeBSD], **[critical]**: crash at import time on FreeBSD 7 and minor. 0.3.0 — 2011-07-08 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`125`: system per-cpu percentage utilization and times (:meth:`Process.cpu_times`, :meth:`Process.cpu_percent`). - :gh:`163`: per-process associated terminal / TTY (:meth:`Process.terminal`). - :gh:`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. - :gh:`172`: disk usage statistics (:func:`disk_usage`). - :gh:`174`: mounted disk partitions (:func:`disk_partitions`). - :gh:`179`: setuptools is now used in setup.py **Bug fixes** - :gh:`159`, [Windows]: ``SetSeDebug()`` does not close handles or unset impersonation on return. - :gh:`164`, [Windows]: wait function raises a ``TimeoutException`` when a process returns ``-1``. - :gh:`165`: :meth:`Process.status` raises an unhandled exception. - :gh:`166`: :meth:`Process.memory_info` leaks handles hogging system resources. - :gh:`168`: :func:`cpu_percent` returns erroneous results when used in non-blocking mode. (patch by Philip Roberts) - :gh:`178`, [macOS]: :meth:`Process.threads` leaks memory. - :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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`64`: per-process I/O counters (:meth:`Process.io_counters`). - :gh:`116`: per-process :meth:`Process.wait` (wait for process to terminate and return its exit code). - :gh:`134`: per-process threads (:meth:`Process.threads`). - :gh:`136`: :meth:`Process.exe` path on FreeBSD is now determined by asking the kernel instead of guessing it from cmdline[0]. - :gh:`137`: per-process real, effective and saved user and group ids (:meth:`Process.gids`). - :gh:`140`: system boot time (:func:`boot_time`). - :gh:`142`: per-process get and set niceness (priority) (:meth:`Process.nice`). - :gh:`143`: per-process status (:meth:`Process.status`). - :gh:`147` [Linux]: per-process I/O niceness / priority (:meth:`Process.ionice`). - :gh:`148`: :class:`Popen` class which tidies up ``subprocess.Popen`` and :class:`Process` class in a single interface. - :gh:`152`, [macOS]: :meth:`Process.open_files` implementation has been rewritten in C and no longer relies on ``lsof`` resulting in a 3x speedup. - :gh:`153`, [macOS]: :meth:`Process.connections` implementation has been rewritten in C and no longer relies on ``lsof`` resulting in a 3x speedup. **Bug fixes** - :gh:`83`, [macOS]: :meth:`Process.cmdline` is empty on macOS 64-bit. - :gh:`130`, [Linux]: a race condition can cause ``IOError`` exception be raised on if process disappears between ``open()`` and the subsequent ``read()`` call. - :gh:`145`, [Windows], **[critical]**: ``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 ``TypeError`` if path contains NULL bytes. - :gh:`151`, [Linux]: :meth:`Process.exe` and :meth:`Process.cwd` for PID 0 return inconsistent data. **API changes** - :class:`Process` ``uid`` and ``gid`` properties are deprecated in favor of ``uids`` and ``gids`` properties. 0.2.0 — 2010-11-13 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`79`: per-process open files (:meth:`Process.open_files`). - :gh:`88`: total system physical cached memory. - :gh:`88`: total system physical memory 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`: per-process children (:meth:`Process.children`). - :gh:`98`: :meth:`Process.cpu_times` and :meth:`Process.memory_info` now return a named tuple instead of a tuple. - :gh:`103`: per-process opened TCP and UDP connections (:meth:`Process.connections`). - :gh:`107`, [Windows]: add support for Windows 64 bit. (patch by cjgohlke) - :gh:`111`: per-process executable name (:meth:`Process.exe`). - :gh:`113`: exception messages now include :meth:`Process.name` and :attr:`Process.pid`. - :gh:`114`, [Windows]: :meth:`Process.username` 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 dependency. (patch by wj32) - :gh:`117`, [Windows]: added support for Windows 2000. - :gh:`123`: :func:`cpu_percent` and :meth:`Process.cpu_percent` accept a new ``interval`` parameter. - :gh:`129`: per-process threads (:meth:`Process.threads`). **Bug fixes** - :gh:`80`: fixed warnings when installing psutil with easy_install. - :gh:`81`, [Windows]: psutil fails to compile with Visual Studio. - :gh:`94`: :meth:`Process.suspend` raises ``OSError`` instead of :exc:`AccessDenied`. - :gh:`86`, [FreeBSD]: psutil didn't compile against FreeBSD 6.x. - :gh:`102`, [Windows]: orphaned process handles obtained by using ``OpenProcess`` in C were left behind every time :class:`Process` class was instantiated. - :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. **API changes** - ``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. - :meth:`Process.memory_info` returns a nametuple instead of a tuple. - :func:`cpu_times` returns a nametuple instead of a tuple. - New :class:`Process` methods: :meth:`Process.open_files`, :meth:`Process.connections`, :meth:`Process.send_signal` and :meth:`Process.terminate`. - :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 raise :exc:`NoSuchProcess` exception if process disappears. - :func:`cpu_percent` no longer returns immediately (see issue 123). - :meth:`Process.cpu_percent` and :func:`cpu_percent` no longer returns immediately by default (see issue :gh:`123`). 0.1.3 — 2010-03-02 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`14`: :meth:`Process.username`. - :gh:`51`, [Linux], [Windows]: per-process current working directory (:meth:`Process.cwd`). - :gh:`59`: :meth:`Process.is_running` is now 10 times faster. - :gh:`61`, [FreeBSD]: added supoprt for FreeBSD 64 bit. - :gh:`71`: per-process suspend and resume (:meth:`Process.suspend` and :meth:`Process.resume`). - :gh:`75`: Python 3 support. **Bug fixes** - :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:`49`, [FreeBSD]: possible memory leak due to missing ``free()`` on error condition in ``getcmdpath()``. - :gh:`50`, [BSD]: 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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`32`: Per-process CPU user/kernel times (:meth:`Process.cpu_times`). - :gh:`33`: Per-process create time (:meth:`Process.create_time`). - :gh:`34`: Per-process CPU utilization percentage (:meth:`Process.cpu_percent`). - :gh:`38`: Per-process memory usage (bytes) (:meth:`Process.memory_info`). - :gh:`41`: Per-process memory percent (:meth:`Process.memory_percent`). - :gh:`39`: System uptime (: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 ^^^^^^^^^^^^^^^^^^ **Enhancements** - :gh:`4`, [FreeBSD]: support for all functions of psutil. - :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:`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. - :gh:`21`, [Windows]: :exc:`AccessDenied` exception created for raising access denied errors from ``OSError`` or ``WindowsError`` on individual platforms. - :gh:`26`: :func:`process_iter` function to iterate over processes as :class:`Process` objects with a generator. - :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], **[critical]**: :meth:`Process.kill` for PID 0 now raises :exc:`AccessDenied` exception instead of ``WindowsError``. - :gh:`30`: psutil.get_pid_list() was returning two 0 PIDs. .. _`cpu_distribution.py`: https://github.com/giampaolo/psutil/blob/master/scripts/cpu_distribution.py .. _`disk_usage.py`: https://github.com/giampaolo/psutil/blob/master/scripts/disk_usage.py .. _`free.py`: https://github.com/giampaolo/psutil/blob/master/scripts/free.py .. _`iotop.py`: https://github.com/giampaolo/psutil/blob/master/scripts/iotop.py .. _`meminfo.py`: https://github.com/giampaolo/psutil/blob/master/scripts/meminfo.py .. _`netstat.py`: https://github.com/giampaolo/psutil/blob/master/scripts/netstat.py .. _`nettop.py`: https://github.com/giampaolo/psutil/blob/master/scripts/nettop.py .. _`pidof.py`: https://github.com/giampaolo/psutil/blob/master/scripts/pidof.py .. _`pmap.py`: https://github.com/giampaolo/psutil/blob/master/scripts/pmap.py .. _`procinfo.py`: https://github.com/giampaolo/psutil/blob/master/scripts/procinfo.py .. _`procsmem.py`: https://github.com/giampaolo/psutil/blob/master/scripts/procsmem.py .. _`ps.py`: https://github.com/giampaolo/psutil/blob/master/scripts/ps.py .. _`pstree.py`: https://github.com/giampaolo/psutil/blob/master/scripts/pstree.py .. _`top.py`: https://github.com/giampaolo/psutil/blob/master/scripts/top.py ================================================ FILE: docs/conf.py ================================================ # 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 config file.""" # See doc at: # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output import datetime import pathlib import sys PROJECT_NAME = "psutil" AUTHOR = "Giampaolo Rodola" THIS_YEAR = str(datetime.datetime.now().year) HERE = pathlib.Path(__file__).resolve().parent ROOT_DIR = HERE.parent sys.path.insert(0, str(ROOT_DIR)) from _bootstrap import get_version # noqa: E402 VERSION = get_version() sys.path.insert(0, str(HERE / '_ext')) extensions = [ "sphinx.ext.extlinks", "sphinx.ext.intersphinx", "sphinx.ext.viewcode", "sphinx_copybutton", # custom extensions in _ext/ dir "availability", "add_home_link", "changelog_anchors", "check_python_syntax", ] project = PROJECT_NAME copyright = f"2009-{THIS_YEAR}, {AUTHOR}" author = AUTHOR version = VERSION release = VERSION intersphinx_mapping = { 'python': ('https://docs.python.org/3', None), } extlinks = { 'gh': ('https://github.com/giampaolo/psutil/issues/%s', '#%s'), } templates_path = ['_templates'] html_static_path = ['_static'] exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] html_theme = 'sphinx_rtd_theme' htmlhelp_basename = f"{PROJECT_NAME}-doc" copybutton_exclude = '.linenos, .gp' html_css_files = [ 'https://media.readthedocs.org/css/sphinx_rtd_theme.css', 'https://media.readthedocs.org/css/readthedocs-doc-embed.css', 'css/custom.css', ] ================================================ FILE: docs/credits.rst ================================================ .. currentmodule:: psutil 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 Top contributors ---------------- * `Giampaolo Rodola`_: creator, primary author and long-time maintainer * `Jay Loden`_: original co-author, initial design and bootstrap, original macOS / Windows / FreeBSD implementations * `Arnon Yaari`_: AIX implementation * `Landry Breuil`_: original OpenBSD implementation * `Ryo Onodera`_ and `Thomas Klausner`_: original 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: * `Alex Laird`_ * Alexander Kaftan * `Alexey Vazhnov`_ * Amit Kulkarni * Andrew Bays * `Artyom Vancyan`_ * Brett Harris * `c0m4r`_ * Carver Koella * `Chenyoo Hao`_ * `Coşkun Deniz`_ * `cybersecgeek`_ * `Daniel Widdis`_ * `Eugenio E Breijo`_ * `Evan Allrich`_ * Florian Bruhin * `great-work-told-is`_ * Gyula Áfra * HTB Industries * `inarikami`_ * `JeremyGrosser`_ * `Johannes Maron`_ * `Jakob P. Liljenberg`_ * `Karthik Kumar`_ * Kahntent * Kristjan Võrk * Mahmut Dumlupinar * Marco Schrank * Matthew Callow * Mindview LLC * `Maximilian Wu`_ * Mehver * mirko * Morgan Heijdemann * Oche Ejembi * `Ofek Lev`_ * Olivier Grisel * Pavan Maddamsetti * `PySimpleGUI`_ * Peter Friedland * Praveen Bhamidipati * Remi Chateauneu * `roboflow.com`_ * Rodion Stratov * Russell Robinson * `Sašo Živanović`_ * `scoutapm-sponsorships`_ * Sigmund Vik * `trashnothing.com`_ * Thomas Guettler * Willem de Groot * Wompasoft * `Valeriy Abramov`_ * Григорьев Андрей 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 ~~~~ * `Amaan Qureshi`_ - :gh:`2770` * `Felix Yan`_ - :gh:`2732` * `Sergey Fedorov`_ - :gh:`2701` 2025 ~~~~ * `Ben Peddell`_ - :gh:`2495`, :gh:`2568` * `Ben Raz`_ - :gh:`2643` * `Eli Wenig`_ - :gh:`2638` * `Fabien Bousquet`_ - :gh:`2529` * `Irene Sheen`_ - :gh:`2606` * `Isaac K. Ko`_ - :gh:`2612` * `Jonathan Kohler`_ - :gh:`2527` * `Lysandros Nikolaou`_ - :gh:`2565`, :gh:`2588`, :gh:`2589`, :gh:`2590`, :gh:`2591`, :gh:`2609`, :gh:`2615`, :gh:`2627`, :gh:`2659` (wheels for free-threaded Python) * `Marcel Telka`_ - :gh:`2469`, :gh:`2545`, :gh:`2546`, :gh:`2592`, :gh:`2594` * `Matthieu Darbois`_ - :gh:`2503`, :gh:`2581` (Windows ARM64 wheels) * `Sergey Fedorov`_ - :gh:`2694` * `Will Hawes`_ - :gh:`2496` * `Xianpeng Shen`_ - :gh:`2640` 2024 ~~~~ * `Aleksey Lobanov`_ - :gh:`2457` * `Cristian Vîjdea`_ - :gh:`2442` * `Matthieu Darbois`_ - :gh:`2370`, :gh:`2375`, :gh:`2417`, :gh:`2425`, :gh:`2429`, :gh:`2450`, :gh:`2479`, :gh:`2486` (macOS and Linux ARM64 wheels) * `Mayank Jha`_ - :gh:`2379` * `Oliver Tomé`_ - :gh:`2222` * `Ryan Carsten Schmidt`_ - :gh:`2361`, :gh:`2364`, :gh:`2365` * `Sam Gross`_ - :gh:`2401`, :gh:`2402`, :gh:`2427`, :gh:`2428` (free-threading Python) * `Shade Gladden`_ - :gh:`2376` 2023 ~~~~ * `Amir Rossert`_ - :gh:`2346` * `Matthieu Darbois`_ - :gh:`2211`, :gh:`2216`, :gh:`2246`, :gh:`2247`, :gh:`2252`, :gh:`2269`, :gh:`2270`, :gh:`2315` * `Po-Chuan Hsieh`_ - :gh:`2186`, :gh:`1646` * `Thomas Klausner`_ - :gh:`2241` * `Xuehai Pan`_ - :gh:`2266` 2022 ~~~~ * `Amir Rossert`_ - :gh:`2156`, :gh:`2345` * `Bernhard Urban-Forster`_ - :gh:`2135` * `Chris Lalancette`_ - :gh:`2037` (:func:`net_if_stats` flags arg on POSIX) * `Daniel Li`_ - :gh:`2150` * `Daniel Widdis`_ - :gh:`2077`, :gh:`2160` * `Garrison Carter`_ - :gh:`2096` * `Hiroyuki Tanaka`_ - :gh:`2086` * `Hugo van Kemenade`_ - :gh:`2099` (Drop Python 2.6 support) * `Lawrence D'Anna`_ - :gh:`2010` * `Matthieu Darbois`_ - :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` * `Steve Dower`_ - :gh:`2080` * `Thomas Klausner`_ - :gh:`2088`, :gh:`2128` * Torsten Blum - :gh:`2114` 2021 ~~~~ * `David Knaack`_ - :gh:`1921` * `Guillermo`_ - :gh:`1913` * `Martin Liška`_ - :gh:`1851` * `MaWe2019`_ - :gh:`1953` * `Nikita Radchenko`_ - :gh:`1940` * `Oleksii Shevchuk`_ - :gh:`1904` * `Olivier Dormond`_ - :gh:`1956` * `Pablo Baeyens`_ - :gh:`1598` * `PetrPospisil`_ - :gh:`1980` * `Saeed Rasooli`_ - :gh:`1996` * `Wilfried Goesgens`_ - :gh:`1990` * `Xuehai Pan`_ - :gh:`1949` 2020 ~~~~ * `Anselm Kruis`_ - :gh:`1695` * `Armin Gruner`_ - :gh:`1800` (:meth:`Process.environ` on BSD) * `Chris Burger`_ - :gh:`1830` * `vser1`_ - :gh:`1637` * `Grzegorz Bokota`_ - :gh:`1758`, :gh:`1762` * `Jake Omann`_ - :gh:`1876` * `Jakob P. Liljenberg`_ - :gh:`1837`, :gh:`1838` * `Javad Karabi`_ - :gh:`1648` * `Julien Lebot`_ - :gh:`1768` (Windows Nano server support) * `Michał Górny`_ - :gh:`1726` * `Mike Hommey`_ - :gh:`1665` * `Po-Chuan Hsieh`_ - :gh:`1646` * `Riccardo Schirone`_ - :gh:`1616` * `Tim Schlueter`_ - :gh:`1708` * `Vincent A. Arcila`_ - :gh:`1620`, :gh:`1727` 2019 ~~~~ * `qcha0`_ - :gh:`1491` * `Alex Manuskin`_ - :gh:`1487` * `Ammar Askar`_ - :gh:`1485` (:func:`getloadavg` on Windows) * `Arnon Yaari`_ - :gh:`607`, :gh:`1349`, :gh:`1409`, :gh:`1500`, :gh:`1505`, :gh:`1507`, :gh:`1533` * `Athos Ribeiro`_ - :gh:`1585` * `Benjamin Drung`_ - :gh:`1462` * `Bernát Gábor`_ - :gh:`1565` * `Cedric Lamoriniere`_ - :gh:`1470` * `Daniel Beer`_ - :gh:`1471` * `David Brochart`_ - :gh:`1493`, :gh:`1496` * `EccoTheFlintstone`_ - :gh:`1368`, :gh:`1348` * `Erwan Le Pape`_ - :gh:`1570` * `Ghislain Le Meur`_ - :gh:`1379` * `Kamil Rytarowski`_ - :gh:`1526`, :gh:`1530` (:meth:`Process.cwd` for NetBSD) * `Nathan Houghton`_ - :gh:`1619` * `Samer Masterson`_ - :gh:`1480` * `Xiaoling Bao`_ - :gh:`1223` * Mozilla Foundation - Sample code for process USS memory 2018 ~~~~ * `Alex Manuskin`_ - :gh:`1284`, :gh:`1345`, :gh:`1350`, :gh:`1369` (:func:`sensors_temperatures` for macOS, FreeBSD, Linux) * `Arnon Yaari`_ - :gh:`1214` * `Dan Vinakovsky`_ - :gh:`1216` * `Denis Krienbühl`_ - :gh:`1260` * `Ilya Yanok`_ - :gh:`1332` * `janderbrain`_ - :gh:`1169` * `Jaime Fullaondo`_ - :gh:`1320` * `Jean-Luc Migot`_ - :gh:`1258`, :gh:`1289` * `Koen Kooi`_ - :gh:`1360` * `Lawrence Ye`_ - :gh:`1321` * `Maxime Mouial`_ - :gh:`1239` * `Nikhil Marathe`_ - :gh:`1278` * `stswandering`_ - :gh:`1243` * `Sylvain Duchesne`_ - :gh:`1294` 2017 ~~~~ * `Adrian Page`_ - :gh:`1160` * `Akos Kiss`_ - :gh:`1150` * `Alexander Hasselhuhn`_ - :gh:`1022` * `Antoine Pitrou`_ - :gh:`1186` * `Arnon Yaari`_ - :gh:`1130`, :gh:`1137`, :gh:`1145`, :gh:`1156`, :gh:`1164`, :gh:`1174`, :gh:`1177`, :gh:`1123` (AIX implementation) * `Baruch Siach`_ - :gh:`872` * `Danek Duvall`_ - :gh:`1002` * `Gleb Smirnoff`_ - :gh:`1070`, :gh:`1076`, :gh:`1079` * `Himanshu Shekhar`_ - :gh:`1036` * `Jakub Bacic`_ - :gh:`1127` * `Matthew Long`_ - :gh:`1167` * `Nicolas Hennion`_ - :gh:`974` * `Oleksii Shevchuk`_ - :gh:`1091`, :gh:`1093`, :gh:`1220`, :gh:`1346` * `Pierre Fersing`_ - :gh:`950` * `Sebastian Saip`_ - :gh:`1141` * `Thiago Borges Abdnur`_ - :gh:`959` * `Yannick Gingras`_ - :gh:`1057` 2016 ~~~~ * `Andre Caron`_ - :gh:`880` * `Arcadiy Ivanov`_ - :gh:`919` * `ewedlund`_ - :gh:`874` * `Farhan Khan`_ - :gh:`823` * `Frank Benkstein`_ - :gh:`732`, :gh:`733`, :gh:`736`, :gh:`738`, :gh:`739`, :gh:`740` * `Ilya Georgievsky`_ - :gh:`870` * `Jake Omann`_ - :gh:`816`, :gh:`775`, :gh:`1874` * `Jeremy Humble`_ - :gh:`863` * `Landry Breuil`_ - :gh:`741` * `Mark Derbecker`_ - :gh:`660` * `Max Bélanger`_ - :gh:`936`, :gh:`1133` * `Patrick Welche`_ - :gh:`812` * `Syohei YOSHIDA`_ - :gh:`730` * `Timmy Konick`_ - :gh:`751` * `Yago Jesus`_ - :gh:`798` 2015 ~~~~ * `Arnon Yaari`_ - :gh:`680`, :gh:`679`, :gh:`610` * `Bruno Binet`_ - :gh:`572` * `Denis`_ - :gh:`541` * `Fabian Groffen`_ - :gh:`611`, :gh:`618` * `Gabi Davar`_ - :gh:`578`, :gh:`581`, :gh:`587` * `Jeff Tang`_ - :gh:`616`, :gh:`648`, :gh:`653`, :gh:`654` * `John Burnett`_ - :gh:`614` * `karthik`_ - :gh:`568` * `Landry Breuil`_ - :gh:`713`, :gh:`709` (OpenBSD implementation) * `Mike Sarahan`_ - :gh:`690` * `Sebastian-Gabriel Brestin`_ - :gh:`704` * `sk6249`_ - :gh:`670` * `spacewander`_ - :gh:`561`, :gh:`603`, :gh:`555` * `Steven Winfield`_ - :gh:`672` * `Sylvain Mouquet`_ - :gh:`565` * `Árni Már Jónsson`_ - :gh:`634` * `Ryo Onodera`_: `e124acba `_ (NetBSD implementation) 2014 ~~~~ * `Alexander Grothe`_ - :gh:`497` * `Anders Chrigström`_ - :gh:`548` * Francois Charron - :gh:`474` * `Guido Imperiale`_ - :gh:`470`, :gh:`477` * `Jeff Tang`_ - :gh:`340`, :gh:`519`, :gh:`529`, :gh:`654` * `Marc Abramowitz`_ - :gh:`492` * Naveed Roudsari - :gh:`421` * `Yaolong Huang`_ - :gh:`530` 2013 ~~~~ * Arfrever.FTA - :gh:`404` * danudey - :gh:`386` * Jason Kirtland - backward compatible implementation of collections.defaultdict * John Baldwin - :gh:`370` * John Pankov - :gh:`435` * `Josiah Carlson`_ - :gh:`451`, :gh:`452` * m.malycha - :gh:`351` * `Matt Good`_ - :gh:`438` * `Thomas Klausner`_ - :gh:`557` (NetBSD implementation) * Ulrich Klank - :gh:`448` 2012 ~~~~ * Amoser - :gh:`266`, :gh:`267`, :gh:`340` * `Florent Xicluna`_ - :gh:`319` * `Gregory Szorc`_ - :gh:`323` * Jan Beich - :gh:`344` * Youngsik Kim - :gh:`317` 2011 ~~~~ * Jeremy Whitlock - :gh:`125`, :gh:`150`, :gh:`206`, :gh:`217`, :gh:`260` (:func:`net_io_counters` and :func:`disk_io_counters` on macOS) 2010 ~~~~ * cjgohlke - :gh:`107` * `Wen Jia Liu (wj32)`_ - :gh:`114`, :gh:`115` 2009 ~~~~ * Yan Raber: `c861c08b `_ (Windows :func:`cpu_times`), `15159111 `_ (Windows :meth:`Process.username`) * `Jay Loden`_ - `79128baa `_ (first commit of FreeBSD implementation) 2008 ~~~~ * `Jay Loden`_ - `efe9236a `_ (first commit of macOS implementation) * Dave Daeschler - `71875761 `_ (first commit of Windows implementation) * `Giampaolo Rodola`_ - `6296c2ab `_ (first commit of Linux implementation) * `Giampaolo Rodola`_ - `8472a17f `_ (inception / initial directory structure) .. People Donors .. ============================================================================ .. _`Alex Laird`: https://github.com/alexdlaird .. _`Alexey Vazhnov`: https://opencollective.com/alexey-vazhnov .. _`Artyom Vancyan`: https://github.com/ArtyomVancyan .. _`c0m4r`: https://github.com/c0m4r .. _`Chenyoo Hao`: https://opencollective.com/chenyoo-hao .. _`Coşkun Deniz`: https://github.com/coskundeniz .. _`cybersecgeek`: https://github.com/cybersecgeek .. _`Eugenio E Breijo`: https://github.com/u93 .. _`Evan Allrich`: https://github.com/eallrich .. _`great-work-told-is`: https://github.com/great-work-told-is .. _`inarikami`: https://github.com/inarikami .. _`JeremyGrosser`: https://github.com/JeremyGrosser .. _`Johannes Maron`: https://github.com/codingjoe .. _`Karthik Kumar`: https://github.com/guilt .. _`Maximilian Wu`: https://github.com/maxesisn .. _`PySimpleGUI`: https://github.com/PySimpleGUI .. _`roboflow.com`: https://github.com/roboflow .. _`sansec.io`: https://github.com/sansecio .. _`Sašo Živanović`: https://github.com/sasozivanovic .. _`scoutapm-sponsorships`: https://github.com/scoutapm-sponsorships .. _`trashnothing.com`: https://github.com/Trash-Nothing .. _`Valeriy Abramov`: https://github.com/abramov-v .. 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 .. Code contributors .. ============================================================================ .. _`Adrian Page`: https://github.com/adpag .. _`Amaan Qureshi`: https://github.com/amaanq .. _`qcha0`: https://github.com/qcha0 .. _`Akos Kiss`: https://github.com/akosthekiss .. _`Aleksey Lobanov`: https://github.com/AlekseyLobanov .. _`Alex Manuskin`: https://github.com/amanusk .. _`Alexander Grothe`: https://github.com/agrethe .. _`Alexander Hasselhuhn`: https://github.com/alexanha .. _`Amir Rossert`: https://github.com/arossert .. _`Ammar Askar`: https://github.com/ammaraskar .. _`Anders Chrigström`: https://github.com/anders-chrigstrom .. _`Andre Caron`: https://github.com/AndreLouisCaron .. _`Anselm Kruis`: https://github.com/akruis .. _`Antoine Pitrou`: https://github.com/pitrou .. _`Arcadiy Ivanov`: https://github.com/arcivanov .. _`Armin Gruner`: https://github.com/ArminGruner .. _`Arnon Yaari`: https://github.com/wiggin15 .. _`Athos Ribeiro`: https://github.com/athos-ribeiro .. _`Baruch Siach`: https://github.com/baruchsiach .. _`Ben Peddell`: https://github.com/klightspeed .. _`Ben Raz`: https://github.com/ben9923 .. _`Benjamin Drung`: https://github.com/bdrung .. _`Bernhard Urban-Forster`: https://github.com/lewurm .. _`Bernát Gábor`: https://github.com/gaborbernat .. _`Bruno Binet`: https://github.com/bbinet .. _`Cedric Lamoriniere`: https://github.com/clamoriniere .. _`Chris Burger`: https://github.com/phobozad .. _`Chris Lalancette`: https://github.com/clalancette .. _`Cristian Vîjdea`: https://github.com/cvijdea-bd .. _`Dan Vinakovsky`: https://github.com/hexaclock .. _`Danek Duvall`: https://github.com/dhduvall .. _`Daniel Beer`: https://github.com/dbeer1 .. _`Daniel Li`: https://github.com/li-dan .. _`Daniel Widdis`: https://github.com/dbwiddis .. _`Denis`: https://github.com/denis-sumin .. _`David Brochart`: https://github.com/davidbrochart .. _`David Knaack`: https://github.com/davidkna .. _`Denis Krienbühl`: https://github.com/href .. _`EccoTheFlintstone`: https://github.com/EccoTheFlintstone .. _`Eli Wenig`: https://github.com/elisw93 .. _`Erwan Le Pape`: https://github.com/erwan-le-pape .. _`ewedlund`: https://github.com/ewedlund .. _`Fabian Groffen`: https://github.com/fabian .. _`Fabien Bousquet`: https://github.com/fafanoulele .. _`Farhan Khan`: https://github.com/khanzf .. _`Felix Yan`: https://github.com/felixonmars .. _`Florent Xicluna`: https://github.com/florentx .. _`Frank Benkstein`: https://github.com/fbenkstein .. _`Gabi Davar`: https://github.com/mindw .. _`Garrison Carter`: https://github.com/garrisoncarter .. _`Ghislain Le Meur`: https://github.com/gigi206 .. _`Giampaolo Rodola`: https://github.com/giampaolo .. _`Gleb Smirnoff`: https://github.com/glebius .. _`Gregory Szorc`: https://github.com/indygreg .. _`Grzegorz Bokota`: https://github.com/Czaki .. _`Guido Imperiale`: https://github.com/crusaderky .. _`Guillermo`: https://github.com/guille .. _`Himanshu Shekhar`: https://github.com/himanshub16 .. _`Hiroyuki Tanaka`: https://github.com/myheroyuki .. _`Hugo van Kemenade`: https://github.com/hugovk .. _`Ilya Georgievsky`: https://github.com/xBeAsTx .. _`Ilya Yanok`: https://github.com/yanok .. _`Irene Sheen`: https://github.com/ceda-ei .. _`Isaac K. Ko`: https://github.com/1saac-k .. _`Jaime Fullaondo`: https://github.com/truthbk .. _`Jake Omann`: https://github.com/jomann09 .. _`Jakob P. Liljenberg`: https://github.com/aristocratos .. _`Jakub Bacic`: https://github.com/jakub-bacic .. _`janderbrain`: https://github.com/janderbrain .. _`Javad Karabi`: https://github.com/karabijavad .. _`Jay Loden`: https://github.com/jloden .. _`Jean-Luc Migot`: https://github.com/jmigot-tehtris .. _`Jeff Tang`: https://github.com/mrjefftang .. _`Jeremy Humble`: https://github.com/jhumble .. _`John Burnett`: https://github.com/johnburnett .. _`Jonathan Kohler`: https://github.com/kohlerjl .. _`Josiah Carlson`: https://github.com/josiahcarlson .. _`Julien Lebot`: https://github.com/julien-lebot .. _`Kamil Rytarowski`: https://github.com/krytarowski .. _`karthik`: https://github.com/karthikrev .. _`Koen Kooi`: https://github.com/koenkooi .. _`Landry Breuil`: https://github.com/landryb .. _`Lawrence D'Anna`: https://github.com/smoofra .. _`Lawrence Ye`: https://github.com/LEAFERx .. _`Lysandros Nikolaou`: https://github.com/lysnikolaou .. _`Marc Abramowitz`: https://github.com/msabramo .. _`Marcel Telka`: https://github.com/mtelka .. _`Mark Derbecker`: https://github.com/mpderbec .. _`Martin Liška`: https://github.com/marxin .. _`Matt Good`: https://github.com/mgood .. _`Matthew Long`: https://github.com/matray .. _`Matthieu Darbois`: https://github.com/mayeut .. _`MaWe2019`: https://github.com/MaWe2019 .. _`Max Bélanger`: https://github.com/maxbelanger .. _`Maxime Mouial`: https://github.com/hush-hush .. _`Mayank Jha`: https://github.com/maynk27 .. _`Michał Górny`: https://github.com/mgorny .. _`Mike Hommey`: https://github.com/glandium .. _`Mike Sarahan`: https://github.com/msarahan .. _`Nathan Houghton`: https://github.com/n1000 .. _`Nicolas Hennion`: https://github.com/nicolargo .. _`Nikhil Marathe`: https://github.com/nikhilm .. _`Nikita Radchenko`: https://github.com/nradchenko .. _`Ofek Lev`: https://github.com/ofek .. _`Oleksii Shevchuk`: https://github.com/alxchk .. _`Oliver Tomé`: https://github.com/snom3ad .. _`Olivier Dormond`: https://github.com/odormond .. _`Pablo Baeyens`: https://github.com/mx-psi .. _`Patrick Welche`: https://github.com/prlw1 .. _`PetrPospisil`: https://github.com/PetrPospisil .. _`Pierre Fersing`: https://github.com/PierreF .. _`Po-Chuan Hsieh`: https://github.com/sunpoet .. _`Riccardo Schirone`: https://github.com/ret2libc .. _`Ryan Carsten Schmidt`: https://github.com/ryandesign .. _`Ryo Onodera`: https://github.com/ryoon .. _`Saeed Rasooli`: https://github.com/ilius .. _`Sam Gross`: https://github.com/colesbury .. _`Samer Masterson`: https://github.com/samertm .. _`Sebastian Saip`: https://github.com/ssaip .. _`Sebastian-Gabriel Brestin`: https://github.com/bsebi .. _`Sergey Fedorov`: https://github.com/barracuda156 .. _`Shade Gladden`: https://github.com/shadeyg56 .. _`sk6249`: https://github.com/sk6249 .. _`spacewander`: https://github.com/spacewander .. _`Steve Dower`: https://github.com/zooba .. _`Steven Winfield`: https://github.com/stevenwinfield .. _`stswandering`: https://github.com/stswandering .. _`Sylvain Duchesne`: https://github.com/sylvainduchesne .. _`Sylvain Mouquet`: https://github.com/sylvainmouquet .. _`Syohei YOSHIDA`: https://github.com/syohex .. _`Thiago Borges Abdnur`: https://github.com/bolaum .. _`Thomas Klausner`: https://github.com/tklauser .. _`Tim Schlueter`: https://github.com/modelrockettier .. _`Timmy Konick`: https://github.com/tijko .. _`Vincent A. Arcila`: https://github.com/jandrovins .. _`Wen Jia Liu (wj32)`: https://github.com/wj32 .. _`Wilfried Goesgens`: https://github.com/dothebart .. _`Will Hawes`: https://github.com/wdh .. _`Xianpeng Shen`: https://github.com/shenxianpeng .. _`Xiaoling Bao`: https://github.com/xiaolingbao .. _`Xuehai Pan`: https://github.com/XuehaiPan .. _`Yago Jesus`: https://github.com/YJesus .. _`Yannick Gingras`: https://github.com/ygingras .. _`Yaolong Huang`: http://airekans.github.io/ .. _`Árni Már Jónsson`: https://github.com/arnimarj .. _`vser1`: https://github.com/vser1 ================================================ FILE: docs/devguide.rst ================================================ Development guide ================= Build, setup and running tests ------------------------------ - psutil makes extensive use of C extension modules, meaning a C compiler is required, see :doc:`install instructions `. Once you have a compiler installed run: .. code-block:: bash git clone git@github.com:giampaolo/psutil.git make install-sysdeps # install gcc and python headers make install-pydeps-test # install python deps necessary to run unit tests make build make install make test - ``make`` (and the accompanying `Makefile`_) is the designated tool to build, install, run tests and do pretty much anything that involves development, including on Windows. Some useful commands: .. code-block:: bash make clean # remove build files make install-pydeps-dev # install all development deps (ruff, black, coverage, ...) make test # run tests make test-parallel # run tests in parallel (faster) make test-memleaks # run memory leak tests make test-coverage # run test coverage make lint-all # run linters make fix-all # fix linters errors make uninstall make help - To run a specific unit test: .. code-block:: make test ARGS=tests/test_system.py - Do not use ``sudo``. ``make install`` installs psutil as a limited user in "edit" / development mode, meaning you can edit psutil code on the fly while you develop. - If you want to target a specific Python version: .. code-block:: make test PYTHON=python3.8 Windows ------- - The recommended way to develop on Windows is using ``make``, just like on UNIX systems. - First, install `Git for Windows`_ and launch a **Git Bash shell**. This provides a Unix-like environment where ``make`` works. - Once inside Git Bash, you can run the usual ``make`` commands: .. code-block:: bash make build make test-parallel Debug mode ---------- If you want to debug unusual situations or want to report a bug, it may be useful to enable debug mode via ``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. On UNIX: :: $ PSUTIL_DEBUG=1 python3 script.py psutil-debug [psutil/_psutil_linux.c:150]> setmntent() failed (ignored) On Windows: :: set PSUTIL_DEBUG=1 && python.exe script.py psutil-debug [psutil/arch/windows/proc.c:90]> NtWow64ReadVirtualMemory64(pbi64.PebBaseAddress) -> 998 (Unknown error) (ignored) Coding style ------------ All style and formatting checks are automatically enforced both **locally on each `git commit`** and **remotely via a GitHub Actions pipeline**. - **Python** code follows the `PEP-8`_ style guide. We use `black` and `ruff` for formatting and linting. - **C** code generally follows the `PEP-7`_ style guide, with formatting enforced by `clang-format`. - **Other files** (`.rst`, `.toml`, `.md`, `.yml`) are also validated by dedicated command-line linters. - The **GitHub Actions pipeline** re-runs all these checks to ensure consistency (via ``make lint-all``). Code organization ----------------- .. code-block:: bash psutil/__init__.py # Main API namespace ("import psutil") psutil/_common.py # Generic utilities psutil/_ntuples.py # Named tuples returned by psutil APIs psutil/_enums.py # Enum containers backing psutil constants psutil/_ps{platform}.py # Platform-specific python wrappers psutil/_psutil_{platform}.c # Platform-specific C extensions (entry point) psutil/arch/all/*.c # C code common to all platforms psutil/arch/{platform}/*.c # Platform-specific C extension tests/test_process|system.py # Main system/process API tests tests/test_{platform}.py # Platform-specific tests Adding a new API ---------------- Typically, this is what you do: - Define the new API in `psutil/__init__.py`_. - Write the platform specific implementation in ``psutil/_ps{platform}.py`` (e.g. `psutil/_pslinux.py`_). - If the change requires C code, write the C implementation in ``psutil/arch/{platform}/file.c`` (e.g. `psutil/arch/linux/disk.c`_). - Write a generic test in `tests/test_system.py`_ or `tests/test_process.py`_. - If possible, write a platform-specific test in ``tests/test_{platform}.py`` (e.g. `tests/test_linux.py`_). This usually means testing the return value of the new API against a system CLI tool. - Update the doc in ``docs/api.rst``. - Update `changelog.rst`_ and `credits.rst`_ files. - Make a pull request. Make a pull request ------------------- - Fork psutil (go to https://github.com/giampaolo/psutil and click on "fork") - Git clone the fork locally: ``git clone git@github.com:YOUR-USERNAME/psutil.git`` - Create a branch: ``git checkout -b new-feature`` - Commit your changes: ``git commit -am 'add some feature'`` - Push the branch: ``git push origin new-feature`` - Create a new PR via the GitHub web interface and sign-off your work (see `CONTRIBUTING.md`_ guidelines) Continuous integration ---------------------- Unit tests are automatically run on every ``git push`` on all platforms except AIX. See config files in the `.github/workflows `_ directory. Documentation ------------- - doc is under ``docs/``. - doc can be built with ``make install-pydeps-dev; cd docs; make html``. - public doc is hosted at https://psutil.readthedocs.io. .. _`changelog.rst`: https://github.com/giampaolo/psutil/blob/master/docs/changelog.rst .. _`CONTRIBUTING.md`: https://github.com/giampaolo/psutil/blob/master/CONTRIBUTING.md .. _`credits.rst`: https://github.com/giampaolo/psutil/blob/master/docs/credits.rst .. _`Git for Windows`: https://git-scm.com/install/windows .. _`Makefile`: https://github.com/giampaolo/psutil/blob/master/Makefile .. _`PEP-7`: https://www.python.org/dev/peps/pep-0007/ .. _`PEP-8`: https://www.python.org/dev/peps/pep-0008/ .. _`psutil/__init__.py`: https://github.com/giampaolo/psutil/blob/master/psutil/__init__.py .. _`psutil/_pslinux.py`: https://github.com/giampaolo/psutil/blob/master/psutil/_pslinux.py .. _`psutil/arch/linux/disk.c`: https://github.com/giampaolo/psutil/blob/master/psutil/arch/linux/disk.c .. _`tests/test_linux.py`: https://github.com/giampaolo/psutil/blob/master/tests/test_linux.py .. _`tests/test_process.py`: https://github.com/giampaolo/psutil/blob/master/tests/test_process.py .. _`tests/test_system.py`: https://github.com/giampaolo/psutil/blob/master/tests/test_system.py ================================================ FILE: docs/faq.rst ================================================ .. currentmodule:: psutil FAQ === This section answers common questions and pitfalls when using psutil. .. contents:: :local: :depth: 3 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. If fetching an attribute raises :exc:`AccessDenied` internally, its value in ``p.info`` is set to ``None`` (or to the ``ad_value`` argument, if specified): .. code-block:: python import psutil for p in psutil.process_iter(["name", "username"], ad_value="N/A"): print(p.info["username"]) # may print "N/A" .. _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 TOCTOU (time-of-check / time-of-use) race condition: a process can die between the moment its PID is obtained and the moment it is queried. The following 2 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.info["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 An even simpler pattern is to 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 .. _faq_zombie_process: What is ZombieProcess? ^^^^^^^^^^^^^^^^^^^^^^^ :exc:`ZombieProcess` is a subclass of :exc:`NoSuchProcess` raised on UNIX for a :term:`zombie process`. **What you can and cannot do with a zombie:** - A zombie 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 other 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 detect zombies:** .. code-block:: python import psutil for p in psutil.process_iter(["status"]): if p.info["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. ---- 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`. .. _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 ` 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. ---- Memory ------ .. _faq_virtual_memory_available: What is the difference between virtual_memory() available and free? ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ :func:`virtual_memory` returns both ``free`` and ``available``, but they measure different things: - ``free``: memory that is not being used at all. - ``available``: how much memory can be given to processes without swapping. This includes reclaimable caches and buffers that the OS can reclaim under pressure. In practice, ``available`` is almost always the metric you want when monitoring memory. ``free`` can be misleadingly low on systems where the OS aggressively uses RAM for caches (which is normal and healthy). On Windows, ``free`` and ``available`` are the same value. .. _faq_memory_rss_vs_vms: What is the difference between RSS and VMS? ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - ``rss`` (Resident Set Size): the amount of physical memory (RAM) currently mapped into the process. - ``vms`` (Virtual Memory Size): the total virtual address space of the process, including memory that has been swapped out, shared libraries, and memory-mapped files. ``rss`` is the go-to metric for answering "how much RAM is this process using?". Note that it includes shared memory, so it may overestimate actual usage when compared across processes. ``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 ``rss``, which includes shared libraries 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 ``rss``. :meth:`Process.memory_footprint` returns USS (Unique Set Size), i.e. memory private to the process. It represents the amount of memory that would be freed if the process were terminated right now. It is more accurate than RSS, but substantially slower and requires higher privileges. On Linux it also returns PSS (Proportional Set Size) and swap. .. _faq_used_plus_free: Why does virtual_memory().used + free != total? ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Because some memory (like cache and buffers) is reclaimable and accounted separately: .. code-block:: pycon >>> import psutil >>> m = psutil.virtual_memory() >>> m.used + m.free == m.total False The ``available`` field already includes this reclaimable memory and is the best indicator of memory pressure. See :ref:`faq_virtual_memory_available`. ================================================ FILE: docs/glossary.rst ================================================ .. currentmodule:: psutil 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 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 swap if evicted. Visible in the ``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 swap. This is the right field to watch for memory pressure, not ``free``. ``free`` is often deceptively low because the OS keeps recently freed pages as reclaimable cache; those pages are counted in ``available`` but not in ``free``. A monitoring alert should fire on ``available`` (or ``percent``) falling below a threshold, not on ``free``. See :func:`virtual_memory`. busy_time A :term:`cumulative counter` (milliseconds) tracking the time a disk device spent actually performing I/O, as reported in the ``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 utilisation percentage (analogous to CPU percent but for disks). When it approaches 100% the disk queue is growing and I/O latency will spike. Unlike ``read_bytes``/``write_bytes``, ``busy_time`` reveals saturation even when throughput looks modest (e.g. many small random I/Os). CPU affinity A property of a process (or thread) that restricts which logical CPUs 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. See :meth:`Process.cpu_affinity`. CPU percent The fraction of CPU time consumed by a process or the whole system over a measurement interval, expressed as a percentage. A value of 100 % means one full logical CPU core was busy for the entire interval. Values above 100 % are possible on multi-core systems when multiple threads run in parallel. See :func:`cpu_percent` and :meth:`Process.cpu_percent`. CPU times :term:`Cumulative counters ` (in seconds) recording how much time a CPU or process spent in different modes: **user** (normal code), **system** (kernel code on behalf of the process), **idle**, **iowait**, etc. These always increase monotonically. See :func:`cpu_times` and :meth:`Process.cpu_times`. context switch Occurs whenever the CPU stops executing one process or thread and starts executing another. Frequent context switching can indicate high system load or excessive thread contention. See :func:`cpu_stats` and :meth:`Process.num_ctx_switches`. The ``voluntary`` and ``involuntary`` fields of :meth:`Process.num_ctx_switches` tell you *why* the process was switched out. A **voluntary** switch means the process gave up the CPU itself (waiting for I/O, a lock, or a timer); a high rate is normal for I/O-bound processes. An **involuntary** switch means the OS forcibly took the CPU away (time slice expired, higher-priority process woke up); a high rate means the process wants to run but keeps getting interrupted — a sign it is competing for CPU. If involuntary switches dominate, adding CPU capacity or reducing other load will directly speed up the process; if voluntary switches dominate, the bottleneck is I/O or locking, not CPU. 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). dropin / dropout Fields in :func:`net_io_counters` counting packets dropped at the NIC level before they could be processed (``dropin``) or sent (``dropout``). Unlike transmission errors, drops indicate the interface or kernel buffer was overwhelmed. A non-zero and growing count is a sign of network saturation or misconfiguration. 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 *handles*. 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, mutex, or registry key. Handles are the Windows equivalent of UNIX :term:`file descriptors `. 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, NIC, keyboard) to the CPU to request attention. Each interrupt briefly preempts whatever the CPU was doing. Reported as the ``interrupts`` field of :func:`cpu_stats` and ``irq`` field of :func:`cpu_times`. A very high rate may indicate a misbehaving device driver or a heavily loaded NIC. Also see :term:`soft interrupt`. 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. ionice An I/O scheduling priority that controls how much disk bandwidth a process receives. On Linux three scheduling classes are supported: ``IOPRIO_CLASS_RT`` (real-time), ``IOPRIO_CLASS_BE`` (best-effort, the default), and ``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`. load average Three floating-point values representing the average number of processes in a *runnable* or *uninterruptible* state over the last 1, 5, and 15 minutes. A load average equal to the number of logical CPUs means the system is fully saturated. See :func:`getloadavg`. 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 priority classes. See :meth:`Process.nice`. page cache RAM used by the kernel to cache file data read from or written to disk. When a process reads a file, the data stays in the page cache. Subsequent reads are served from RAM without any disk I/O. The OS reclaims page cache memory automatically under pressure, so a large cache is healthy. Shown as the ``cached`` field of :func:`virtual_memory` on Linux/BSD. See also :term:`available memory`. 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_info_ex` (Linux, macOS). Useful for capacity planning and leak detection: if ``peak_rss`` keeps growing across successive runs or over time, the process is likely leaking memory. page fault An event that occurs when a process accesses a virtual memory page that is not currently mapped in physical RAM. A **minor** fault is resolved without disk I/O (e.g. the page is already in RAM but not yet mapped, or it is copy-on-write). A **major** fault requires reading the page from disk (e.g. from a memory-mapped file or the swap area) and is significantly more expensive. Many major faults may indicate memory pressure or excessive swapping. See :meth:`Process.page_faults`. 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)``. PSS *Proportional Set Size*, the amount of RAM used by a process, where shared 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`. RSS *Resident Set Size*, the amount of physical RAM currently occupied by a process, including shared library pages. It is the most commonly reported memory metric (shown as ``RES`` in ``top``), but it can be misleading because shared pages are counted in full for every process that maps them. See :meth:`Process.memory_info`. status (process) The scheduling state of a process at a given instant. Common values are: - ``running``: actively executing on a CPU. - ``sleeping``: waiting for an event (interruptible sleep). - ``disk-sleep``: waiting for I/O (uninterruptible sleep). - ``stopped``: suspended via ``SIGSTOP`` or a debugger. - ``zombie``: exited but not yet reaped by its parent. - ``idle``: doing nothing. See :meth:`Process.status` and the ``STATUS_*`` constants. 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 ``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. swap-in A page moved from swap space on disk back into RAM. Reported as the ``sin`` :term:`cumulative counter` of :func:`swap_memory`. On its own a non-zero ``sin`` rate is not alarming — it may just mean the system is reloading pages that were quietly evicted during idle time. It becomes a concern when it coincides with a high :term:`swap-out` rate, meaning the system is continuously trading pages in and out. See also :term:`swap-out`. swap-out A page evicted from RAM to swap space on disk to free memory. Reported as the ``sout`` :term:`cumulative counter` of :func:`swap_memory`. A sustained non-zero rate is the clearest sign of memory pressure: the system is running out of RAM and actively offloading pages to disk. Compute the rate of change over an interval rather than reading the absolute value. See also :term:`swap-in`. swap memory Disk space used as an overflow extension of physical RAM. When the OS runs low on RAM it *swaps out* memory pages to disk and restores them on demand. Heavy swapping significantly degrades performance. See :func:`swap_memory`. 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`. resource limit A per-process cap on a system resource enforced by the kernel (POSIX :data:`RLIMIT_* ` 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`. USS *Unique Set Size*, the amount of RAM that belongs exclusively to a process and would be freed if it exited. It excludes shared 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, shared libraries, stack, heap, and swap. 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. See :ref:`faq_zombie_process`. ================================================ FILE: docs/index.rst ================================================ .. module:: psutil :synopsis: psutil module .. moduleauthor:: Giampaolo Rodola psutil documentation ==================== .. image:: https://img.shields.io/badge/GitHub-repo-blue :target: https://github.com/giampaolo/psutil :alt: GitHub repo .. image:: https://readthedocs.org/projects/psutil/badge/?version=latest :target: https://app.readthedocs.org/projects/psutil/builds/ :alt: ReadTheDocs .. image:: https://img.shields.io/pypi/v/psutil.svg?label=pypi&color=red :target: https://pypi.org/project/psutil :alt: Latest version .. image:: https://img.shields.io/pypi/dm/psutil.svg :target: https://clickpy.clickhouse.com/dashboard/psutil :alt: Downloads psutil (Python system and process utilities) 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 tools such as *ps, top, free, iotop, netstat, ifconfig, lsof* and others (see :doc:`shell equivalents `). psutil currently supports the following platforms, from **Python 3.7** onwards: - **Linux** - **Windows** - **macOS** - **FreeBSD, OpenBSD**, **NetBSD** - **Sun Solaris** - **AIX** psutil is used by `many notable projects `__ including TensorFlow, PyTorch, Home Assistant, Ansible, and Celery. Sponsors -------- .. raw:: html
         add your logo

    Funding ------- While psutil is free software and will always be, the project would benefit immensely from some funding. psutil is among the `top 100 `_ most-downloaded Python packages, and keeping up with bug reports, user support, and ongoing maintenance has become increasingly difficult to sustain as a one-person effort. If you're a company that's making significant use of psutil you can consider becoming a sponsor via `GitHub `_, `Open Collective `_ or `PayPal `_. Sponsors can have their logo displayed here and in the psutil `documentation `_. Security -------- To report a security vulnerability, please use the `Tidelift security contact`_. Tidelift will coordinate the fix and disclosure. Table of contents ----------------- .. toctree:: :maxdepth: 2 Install API Reference FAQ Recipes Shell equivalents Glossary Platform support Who uses psutil Alternatives Migration Development guide Credits Timeline .. toctree:: :titlesonly: Changelog .. _`Tidelift security contact`: https://tidelift.com/security .. ================================================ FILE: docs/install.rst ================================================ Install psutil ============== Linux, Windows, macOS (wheels) ------------------------------ Pre-compiled wheels are distributed for these platforms, so you usually won't need a C compiler. All you have to do is:: pip install psutil If wheels are not available for your platform or architecture, or you wish to build & install psutil from sources, keep reading. Compile psutil from source -------------------------- UNIX ^^^^ On all UNIX systems you can use the `install-sysdeps.sh `_ script. This will install the system dependencies necessary to compile psutil from sources. You can invoke this script from the Makefile as:: make install-sysdeps After system deps are installed, you can compile and install psutil with:: make build make install ...or this, which will fetch the latest source distribution from `PyPI `_:: pip install --no-binary :all: psutil Linux ^^^^^ Debian / Ubuntu:: sudo apt install gcc python3-dev pip install --no-binary :all: psutil RedHat / CentOS:: sudo yum install gcc python3-devel pip install --no-binary :all: psutil Arch:: sudo pacman -S gcc python pip install --no-binary :all: psutil Alpine:: sudo apk add gcc python3-dev musl-dev linux-headers pip install --no-binary :all: psutil Windows ^^^^^^^ - To build or install psutil from source on Windows, you need to have `Visual Studio 2017 `_ or later installed. For detailed instructions, see the `CPython Developer Guide `_. - MinGW is not supported for building psutil on Windows. - To build directly from the source tarball (.tar.gz) on PYPI, run:: pip install --no-binary :all: psutil - If you want to clone psutil's Git repository and build / develop locally, first install: `Git for Windows `_ and launch a Git Bash shell. This provides a Unix-like environment where ``make`` works. - Once inside Git Bash, you can run the usual ``make`` commands:: make build make install macOS ^^^^^ Install Xcode first: :: xcode-select --install pip install --no-binary :all: psutil FreeBSD ^^^^^^^ :: pkg install python3 gcc python3 -m pip install psutil OpenBSD ^^^^^^^ :: export PKG_PATH=https://cdn.openbsd.org/pub/OpenBSD/`uname -r`/packages/`uname -m`/ pkg_add -v python3 gcc pip install psutil NetBSD ^^^^^^ Assuming Python 3.11: :: export PKG_PATH="https://ftp.netbsd.org/pub/pkgsrc/packages/NetBSD/`uname -m`/`uname -r`/All" pkg_add -v pkgin pkgin install python311-* gcc12-* py311-setuptools-* py311-pip-* python3.11 -m pip install psutil Sun Solaris ^^^^^^^^^^^ If ``cc`` compiler is not installed create a symbolic link to ``gcc``:: sudo ln -s /usr/bin/gcc /usr/local/bin/cc Install:: pkg install gcc pip install psutil Troubleshooting --------------- Install pip ^^^^^^^^^^^ If you don't have pip you can install it with wget:: wget https://bootstrap.pypa.io/get-pip.py -O - | python3 ...or with curl:: python3 < <(curl -s https://bootstrap.pypa.io/get-pip.py) On Windows, `download pip `_, open cmd.exe and install it with:: py get-pip.py "pip not found" ^^^^^^^^^^^^^^^ Sometimes pip is installed but it's not available in your ``PATH`` ("pip command not found" or similar). Try this:: python3 -m pip install psutil Permission errors (UNIX) ^^^^^^^^^^^^^^^^^^^^^^^^ If you want to install psutil system-wide and you bump into permission errors either run as root user or prepend ``sudo``:: sudo pip install psutil ================================================ FILE: docs/migration.rst ================================================ .. currentmodule:: psutil .. include:: _links.rst 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) never contain breaking changes. Only major releases are listed here. .. contents:: :local: :depth: 2 .. _migration-8.0: Migrating to 8.0 ----------------- Named tuple field order changed ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - :func:`cpu_times`: ``user, system, 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. ``nice``) following. Positional access (e.g. ``cpu_times()[3]``) will silently return the wrong field. Always use attribute access instead (e.g. ``cpu_times().idle``). .. 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. Positional access (e.g. ``p.memory_info()[3]`` or ``a, b, c = p.memory_info()``) may break or silently return the wrong field. Always use attribute access instead (e.g. ``p.memory_info().rss``). Also, ``lib`` and ``dirty`` on Linux were removed and turned into aliases emitting `DeprecationWarning`. .. code-block:: python # Linux before rss, vms, shared, text, lib, data, dirty = p.memory_info() # Linux after t = p.memory_info() rss, vms, shared, text, data = t.rss, t.vms, t.shared, t.text, t.data - macOS: ``pfaults`` and ``pageins`` fields were removed with **no backward-compatible aliases**. Use :meth:`page_faults` instead. .. code-block:: python # before rss, vms, pfaults, pageins = p.memory_info() # after rss, vms = p.memory_info() minor, major = p.page_faults() - Windows: eliminated old aliases: ``wset`` → ``rss``, ``peak_wset`` → ``peak_rss``, ``pagefile`` / ``private`` → ``vms``, ``peak_pagefile`` → ``peak_vms``, ``num_page_faults`` → :meth:`page_faults` method. At the same time ``paged_pool``, ``nonpaged_pool``, ``peak_paged_pool``, ``peak_nonpaged_pool`` were moved to :meth:`memory_info_ex`. All these old names still work but raise `DeprecationWarning`. - BSD: a new ``peak_rss`` field was added. - :func:`virtual_memory`: on Windows, new ``cached`` and ``wired`` fields were added. Code using positional unpacking will break: .. code-block:: python # before total, avail, percent, used, free = psutil.virtual_memory() # after m = psutil.virtual_memory() total, avail, percent, used, free = m.total, m.available, m.percent, m.used, m.free cpu_times() interrupt renamed to irq on Windows ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The ``interrupt`` field of :func:`cpu_times` on Windows was renamed to ``irq`` to match the name used on Linux and BSD. The old name still works but raises :exc:`DeprecationWarning`: .. code-block:: python # before t = psutil.cpu_times() print(t.interrupt) # after t = psutil.cpu_times() print(t.irq) Status and connection fields are now enums ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - :meth:`Process.status` now returns a :class:`psutil.ProcessStatus` member instead of a plain ``str``. - :meth:`Process.net_connections` and :func:`net_connections` ``status`` field now returns a :class:`psutil.ConnectionStatus` member instead of a plain ``str``. Because both are :class:`enum.StrEnum` subclasses they compare equal to their string values, so existing comparisons continue to work unchanged: .. code-block:: python # these still work p.status() == "running" p.status() == psutil.STATUS_RUNNING # repr() and type() differ, so code inspecting these may need updating The individual constants (e.g. :data:`psutil.STATUS_RUNNING`) are kept as aliases for the enum members, and should be preferred over accessing them via the enum class: .. code-block:: python # prefer this p.status() == psutil.STATUS_RUNNING # not this p.status() == psutil.ProcessStatus.STATUS_RUNNING memory_full_info() is deprecated ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ :meth:`Process.memory_full_info` is deprecated. Use the new :meth:`Process.memory_footprint` instead: .. code-block:: python # before mem = p.memory_full_info() uss = mem.uss # after mem = p.memory_footprint() uss = mem.uss Python 3.6 dropped ^^^^^^^^^^^^^^^^^^^^ Python 3.6 is no longer supported. Minimum version is Python 3.7. ---- .. _migration-7.0: Migrating to 7.0 ----------------- Process.memory_info_ex() removed ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The long-deprecated :meth:`Process.memory_info_ex` was removed (it was deprecated since 4.0.0 in 2016). 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 to support Python 2.7 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 triggers a ``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 ``maxfile`` and ``maxpath`` fields were removed from the named tuple returned by :func:`disk_partitions`. Code unpacking the tuple positionally 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 pre-emptively checks whether yielded PIDs have been reused (this made it ~20× faster). If you need 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.info["name"]) ---- .. _migration-5.0: Migrating to 5.0 ----------------- 5.0.0 was the largest renaming in psutil history. All ``get_*`` and ``set_*`` :class:`Process` methods lost their prefix, and several module-level names were changed. Old :class:`Process` method names still worked but raised ``DeprecationWarning``. They were fully removed in 6.0. Process methods ^^^^^^^^^^^^^^^^ .. list-table:: :header-rows: 1 :widths: 40 40 * - Old (< 5.0) - New (>= 5.0) * - ``p.get_children()`` - ``p.children()`` * - ``p.get_connections()`` - ``p.connections()`` → ``p.net_connections()`` in 6.0 * - ``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.memory_full_info()`` in 4.0 * - ``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()`` * - ``p.set_nice(v)`` - ``p.nice(v)`` * - ``p.set_ionice(cls)`` - ``p.ionice(cls)`` * - ``p.set_cpu_affinity(cpus)`` - ``p.cpu_affinity(cpus)`` Module-level renames ^^^^^^^^^^^^^^^^^^^^^ .. list-table:: :header-rows: 1 :widths: 40 40 * - Old (< 5.0) - New (>= 5.0) * - ``psutil.NUM_CPUS`` - ``psutil.cpu_count()`` * - ``psutil.BOOT_TIME`` - ``psutil.boot_time()`` * - ``psutil.TOTAL_PHYMEM`` - ``psutil.virtual_memory().total`` * - ``psutil.get_pid_list()`` - ``psutil.pids()`` * - ``psutil.get_users()`` - ``psutil.users()`` * - ``psutil.get_boot_time()`` - ``psutil.boot_time()`` * - ``psutil.network_io_counters()`` - ``psutil.net_io_counters()`` * - ``psutil.phymem_usage()`` - ``psutil.virtual_memory()`` * - ``psutil.virtmem_usage()`` - ``psutil.swap_memory()`` ================================================ FILE: docs/platform.rst ================================================ Platform support ================ Python ^^^^^^ **Current Python:** 3.7 and PyPy3. **Python 2.7**: latest psutil version supporting it is `psutil 6.1.1 `_ (Dec 2024). The 6.1.X series may still receive critical bug-fixes but no new features. To install psutil on Python 2.7 run: :: python2 -m pip install psutil==6.1.* Operating systems ^^^^^^^^^^^^^^^^^ ================ ================ ==== ================================================= ========= Platform Minimum version Year How enforced CI tested ================ ================ ==== ================================================= ========= Linux 2.6.13 (soft) 2005 graceful fallbacks; no hard check yes Windows Vista 2007 hard check at import + build time yes macOS 10.7 (Lion) 2011 ``MAC_OS_X_VERSION_MIN_REQUIRED`` in C 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 unknown memleak tests only AIX unknown no ================ ================ ==== ================================================= ========= Note: psutil may work on older versions of the above platforms but it is not guaranteed. Architectures ^^^^^^^^^^^^^ Supported CPU architectures and platforms tested in CI or with prebuilt wheels: ================ =========================== =========================== Architecture CI-tested platforms Wheel builds ================ =========================== =========================== x86_64 Linux, macOS, Windows Linux, macOS, Windows aarch64 / ARM64 Linux, macOS, Windows Linux, macOS, Windows ================ =========================== =========================== Notes: - Linux wheels are built for both glibc (manylinux) and musl. - macOS wheels are universal2 (include both x86_64 and arm64 slices). - Windows wheels are labeled AMD64 or ARM64 according to architecture. - Other architectures (i686, ppc64le, s390x, riscv64, ...) are supported but not CI-tested. They can be compiled from the source tarball (``pip install psutil --no-binary psutil``). Support history ^^^^^^^^^^^^^^^ * psutil 8.0.0 (2026-XX): drop Python 3.6 * psutil 7.2.0 (2025-12): publish wheels for **Linux musl** * psutil 7.1.2 (2025-10): publish wheels for **free-threaded Python** * psutil 7.1.2 (2025-10): no longer publish wheels for 32-bit Python (Linux and Windows) * psutil 7.1.1 (2025-10): drop **SunOS 10** * psutil 7.1.0 (2025-09): drop **FreeBSD 8** * psutil 7.0.0 (2025-02): drop Python 2.7 * psutil 5.9.6 (2023-10): drop Python 3.4 and 3.5 * psutil 5.9.1 (2022-05): drop Python 2.6 * psutil 5.9.0 (2021-12): add **MidnightBSD** * psutil 5.8.0 (2020-12): add **PyPy 2** on Windows * psutil 5.7.1 (2020-07): add **Windows Nano** * psutil 5.7.0 (2020-02): drop Windows XP & Windows Server 2003 * psutil 5.7.0 (2020-02): add **PyPy 3** on Windows * psutil 5.4.0 (2017-11): add **AIX** * psutil 3.4.1 (2016-01): add **NetBSD** * psutil 3.3.0 (2015-11): add **OpenBSD** * psutil 1.0.0 (2013-07): add **Solaris** * psutil 0.1.1 (2009-03): add **FreeBSD** * psutil 0.1.0 (2009-01): add **Linux, Windows, macOS** ================================================ FILE: docs/recipes.rst ================================================ 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. .. contents:: :local: :depth: 3 Processes --------- Finding processes ^^^^^^^^^^^^^^^^^ 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.info["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 import psutil def find_procs_by_name_ex(name): ls = [] for p in psutil.process_iter(["name", "exe", "cmdline"]): if ( name == p.info["name"] or (p.info["exe"] and os.path.basename(p.info["exe"]) == name) or (p.info["cmdline"] and p.info["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.info["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 >>> import psutil >>> from pprint import pprint as pp >>> pp([(p.pid, p.info["name"]) for p in psutil.process_iter(["name", "username"]) if p.info["username"] == getpass.getuser()]) (16832, 'bash'), (19772, 'ssh'), (20492, 'python')] ---- Processes actively running: .. code-block:: python >>> pp([(p.pid, p.info) for p in psutil.process_iter(["name", "status"]) if p.info["status"] == psutil.STATUS_RUNNING]) [(1150, {'name': 'Xorg', 'status': }), (1776, {'name': 'unity-panel-service', 'status': }), (20492, {'name': 'python', 'status': })] ---- Processes using log files: .. code-block:: python >>> for p in psutil.process_iter(["name", "open_files"]): ... for file in p.info["open_files"] or []: ... if file.path.endswith(".log"): ... print("{:<5} {:<10} {}".format(p.pid, p.info["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 >>> pp([(p.pid, p.info["name"], p.info["memory_info"].rss) for p in psutil.process_iter(["name", "memory_info"]) if p.info["memory_info"].rss > 500 * 1024 * 1024]) [(2650, 'chrome', 532324352), (3038, 'chrome', 1120088064), (21915, 'sublime_text', 615407616)] ---- Top 3 processes which consumed the most CPU time: .. code-block:: python >>> pp([(p.pid, p.info["name"], sum(p.info["cpu_times"])) for p in sorted(psutil.process_iter(["name", "cpu_times"]), key=lambda p: sum(p.info["cpu_times"][:2]))][-3:]) [(2721, 'chrome', 10219.73), (1150, 'Xorg', 11116.989999999998), (2650, 'chrome', 18451.97)] ---- Top N processes by cumulative 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"]): try: io = p.io_counters() except psutil.Error: pass else: 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(): try: procs.append((p.num_fds(), p)) except (psutil.NoSuchProcess, psutil.AccessDenied): pass 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 import 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 import signal import 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) 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) ---- Find zombie (defunct) processes: .. code-block:: python import psutil for p in psutil.process_iter(["status"]): if p.info["status"] == psutil.STATUS_ZOMBIE: print(f"zombie: pid={p.pid}") ---- Terminate all processes matching a given name: .. code-block:: python import psutil def terminate_procs_by_name(name): for p in psutil.process_iter(["name"]): if p.info["name"] == name: p.terminate() ---- 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() ---- Restart a process: .. code-block:: python import subprocess import psutil def restart_process(pid): p = psutil.Process(pid) cmd = p.cmdline() p.terminate() p.wait() return subprocess.Popen(cmd) ---- Temporarily pause and resume a process using a context manager: .. code-block:: python import contextlib import 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 import 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 import time import 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. This ``bytes2human()`` utility function used in the examples below converts them to a human-readable string: .. code-block:: python def bytes2human(n): """ >>> 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 abs(n) >= prefix[s]: value = float(n) / prefix[s] return "{:.1f}{}".format(value, s) return "{}B".format(n) Memory ^^^^^^ Show both RAM and swap usage in human-readable form: .. code-block:: python import psutil def print_memory(): ram = psutil.virtual_memory() swap = psutil.swap_memory() print( "RAM: total={}, used={}, free={}, percent={}%".format( bytes2human(ram.total), bytes2human(ram.used), bytes2human(ram.available), ram.percent, ) ) print( "Swap: total={}, used={}, free={}, percent={}%".format( bytes2human(swap.total), bytes2human(swap.used), bytes2human(swap.free), swap.percent, ) ) .. code-block:: none RAM: total=8.0G, used=4.5G, free=3.0G, percent=56.2% Swap: total=2.0G, used=0.1G, free=1.9G, percent=4.1% 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% ---- For each CPU core: .. code-block:: python import psutil while True: for i, pct in enumerate(psutil.cpu_percent(percpu=True, interval=1)): print("CPU-{}: {}%".format(i, pct)) print() .. code-block:: none CPU-0: 1.0% CPU-1: 2.1% CPU-2: 3.0% Disks ^^^^^ Show disk usage for all mounted partitions: .. code-block:: python import psutil def print_disk_usage(): for part in psutil.disk_partitions(): usage = psutil.disk_usage(part.mountpoint) print("{:<20} total={:<8} used={:<8} free={:<8} percent={}%".format( part.mountpoint, bytes2human(usage.total), bytes2human(usage.used), bytes2human(usage.free), usage.percent)) .. code-block:: none / total=47.8G used=17.4G free=27.9G percent=38.4% /boot/efi total=256.0M used=73.6M free=182.4M percent=28.8% /home total=878.7G used=497.5G free=336.5G percent=59.7% ---- 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(bytes2human(r), bytes2human(w))) .. code-block:: none Read: 1.2M/s, Write: 256.0K/s Read: 0.0B/s, Write: 128.0K/s Network ^^^^^^^ List IP addresses for each network interface: .. code-block:: python import psutil, socket def print_net_addrs(): for iface, addrs in psutil.net_if_addrs().items(): for addr in addrs: if addr.family == socket.AF_INET: print( "{:<15} address={:<15} netmask={}".format( iface, addr.address, addr.netmask ) ) .. code-block:: none lo address=127.0.0.1 netmask=255.0.0.0 eth0 address=10.0.0.4 netmask=255.255.255.0 ---- 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, bytes2human(s) + "/s", 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 ================================================ FILE: docs/requirements.txt ================================================ sphinx sphinx_rtd_theme sphinx_copybutton sphinxcontrib-googleanalytics ================================================ FILE: docs/shell_equivalents.rst ================================================ .. currentmodule:: psutil 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. System-wide functions --------------------- CPU ~~~ .. list-table:: :header-rows: 1 * - psutil function - Linux - macOS - BSD - Windows * - :func:`cpu_percent` - ``top`` - same - same - * - :func:`cpu_count(logical=True) ` - ``nproc`` - ``sysctl hw.logicalcpu`` - ``sysctl hw.ncpu`` - * - :func:`cpu_count(logical=False) ` - ``lscpu | grep '^Core(s)'`` - ``sysctl hw.physicalcpu`` - - * - :func:`cpu_times(percpu=False) ` - ``cat /proc/stat | grep '^cpu\s'`` - - ``systat -vmstat`` - * - :func:`cpu_times(percpu=True) ` - ``cat /proc/stat | grep '^cpu'`` - - ``systat -vmstat`` - * - :func:`cpu_times_percent(percpu=False) ` - ``mpstat`` - - - * - :func:`cpu_times_percent(percpu=True) ` - ``mpstat -P ALL`` - - - * - :func:`cpu_freq` - ``cpufreq-info``, ``lscpu | grep "MHz"`` - ``sysctl hw.cpufrequency`` - ``sysctl dev.cpu.0.freq`` - ``systeminfo`` * - :func:`cpu_stats` - - - ``sysctl vm.stats.sys`` - * - :func:`getloadavg` - ``uptime`` - same - same - Memory ~~~~~~ .. list-table:: :header-rows: 1 * - psutil function - Linux - macOS - BSD - Windows * - :func:`virtual_memory` - ``free``, ``vmstat``, ``cat /proc/meminfo`` - ``vm_stat`` - ``sysctl vm.stats`` - ``systeminfo`` * - :func:`swap_memory` - ``free``, ``vmstat``, ``swapon`` - ``sysctl vm.swapusage`` - ``swapinfo`` - * - :func:`heap_info` - - - - * - :func:`heap_trim` - - - - Disks ~~~~~ .. list-table:: :header-rows: 1 * - psutil function - Linux - macOS - BSD - Windows * - :func:`disk_usage` - ``df`` - same - same - ``fsutil volume diskfree C:\`` * - :func:`disk_partitions` - ``findmnt``, ``mount`` - ``mount`` - ``mount`` - * - :func:`disk_io_counters` - ``iostat -dx`` - ``iostat`` - ``iostat -x`` - Network ~~~~~~~ .. list-table:: :header-rows: 1 * - 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 * - 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 * - 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 -eo pid`` - same - same - ``tasklist`` * - :func:`pid_exists` - ``kill -0 PID`` - same - same - Process methods --------------- Identity ~~~~~~~~ .. list-table:: :header-rows: 1 * - psutil method - Linux - macOS - BSD - Windows * - :meth:`Process.name` - ``ps -o comm -p PID`` - same - ``procstat -b PID`` - * - :meth:`Process.exe` - ``readlink /proc/PID/exe`` - ``lsof -p PID`` - ``procstat -b PID`` - * - :meth:`Process.cmdline` - ``ps -o args -p PID`` - same - ``procstat -c PID`` - * - :meth:`Process.status` - ``ps -o stat -p PID`` - same - same - * - :meth:`Process.create_time` - ``ps -o lstart -p PID`` - same - same - * - :meth:`Process.is_running` - ``kill -0 PID`` - same - same - * - :meth:`Process.environ` - ``xargs -0 -a /proc/PID/environ`` - - ``procstat -e PID`` - * - :meth:`Process.cwd` - ``pwdx PID`` - ``lsof -p PID -a -d cwd`` - - Process tree ~~~~~~~~~~~~ .. list-table:: :header-rows: 1 * - psutil method - Linux - macOS - BSD - Windows * - :meth:`Process.ppid` - ``ps -o ppid= -p PID`` - same - same - * - :meth:`Process.parent` - ``ps -p $(ps -o ppid= -p PID)`` - same - same - * - :meth:`Process.parents` - ``pstree -s PID`` - same - same - * - :meth:`Process.children(recursive=False) ` - ``pgrep -P PID`` - same - same - * - :meth:`Process.children(recursive=True) ` - ``pstree -p PID`` - same - same - Credentials ~~~~~~~~~~~ .. list-table:: :header-rows: 1 * - psutil method - Linux - macOS - BSD - Windows * - :meth:`Process.uids` - ``ps -o uid,ruid,suid -p PID`` - same - ``procstat -s PID`` - * - :meth:`Process.gids` - ``ps -o gid,rgid,sgid -p PID`` - same - ``procstat -s PID`` - * - :meth:`Process.username` - ``ps -o user -p PID`` - same - same - * - :meth:`Process.terminal` - ``ps -o tty -p PID`` - same - same - CPU / scheduling ~~~~~~~~~~~~~~~~ .. list-table:: :header-rows: 1 * - psutil method - Linux - macOS - BSD - Windows * - :meth:`Process.cpu_percent` - ``ps -o %cpu -p PID`` - same - same - * - :meth:`Process.cpu_times` - ``ps -o cputime -p PID`` - same - ``procstat -r PID`` - * - :meth:`Process.cpu_num` - ``ps -o psr -p PID`` - - - * - :meth:`Process.num_ctx_switches` - ``pidstat -w -p PID`` - - ``procstat -r PID`` - * - :meth:`Process.cpu_affinity() ` - ``taskset -p PID`` - - ``cpuset -g -p PID`` - * - :meth:`Process.cpu_affinity(CPUS) ` - ``taskset -p MASK PID`` - - ``cpuset -s -p PID -l CPUS`` - * - :meth:`Process.ionice() ` - ``ionice -p PID`` - - - * - :meth:`Process.ionice(CLASS) ` - ``ionice -c CLASS -p PID`` - - - * - :meth:`Process.nice() ` - ``ps -o nice -p PID`` - same - same - * - :meth:`Process.nice(VALUE) ` - ``renice -n VALUE -p PID`` - same - same - * - :meth:`Process.rlimit(RES) ` - ``prlimit --pid PID`` - - ``procstat rlimit PID`` - * - :meth:`Process.rlimit(RES, LIMITS) ` - ``prlimit --pid PID --RES=SOFT:HARD`` - - - Memory ~~~~~~ .. list-table:: :header-rows: 1 * - psutil method - Linux - macOS - BSD - Windows * - :meth:`Process.memory_info` - ``ps -o rss,vsz -p PID`` - same - same - * - :meth:`Process.memory_info_ex` - ``cat /proc/PID/status`` - - - * - :meth:`Process.memory_percent` - ``ps -o %mem -p PID`` - same - same - * - :meth:`Process.memory_maps` - ``pmap PID`` - ``vmmap PID`` - ``procstat -v PID`` - * - :meth:`Process.memory_footprint` - ``smem``, ``smemstat`` - - - * - :meth:`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 * - psutil method - Linux - macOS - BSD - Windows * - :meth:`Process.num_threads` - ``ps -o nlwp -p PID`` - same - same - * - :meth:`Process.threads` - ``ps -T -p PID`` - - - Files and connections ~~~~~~~~~~~~~~~~~~~~~ .. list-table:: :header-rows: 1 * - psutil method - Linux - macOS - BSD - Windows * - :meth:`Process.net_connections` - ``ss -p``, ``lsof -p PID -i`` - ``lsof -p PID -i`` - - ``netstat -ano | findstr PID`` * - :meth:`Process.open_files` - ``lsof -p PID`` - same - ``procstat -f PID`` - ``handle.exe -p PID`` * - :meth:`Process.io_counters` - ``cat /proc/PID/io`` - - - * - :meth:`Process.num_fds` - ``ls /proc/PID/fd | wc -l`` - - - * - :meth:`Process.num_handles` - - - - Signals ~~~~~~~ .. list-table:: :header-rows: 1 * - psutil method - Linux - macOS - BSD - Windows * - :meth:`Process.send_signal` - ``kill -SIG PID`` - same - same - * - :meth:`Process.suspend` - ``kill -STOP PID`` - same - same - * - :meth:`Process.resume` - ``kill -CONT PID`` - same - same - * - :meth:`Process.terminate` - ``kill -TERM PID`` - same - same - ``taskkill /PID PID`` * - :meth:`Process.kill` - ``kill -KILL PID`` - same - same - ``taskkill /F /PID PID`` * - :meth:`Process.wait` - ``tail --pid=PID -f /dev/null`` - ``lsof -p PID +r 1`` - ``pwait PID`` - ================================================ FILE: docs/timeline.rst ================================================ Timeline ======== - 2026-02-08: `7.2.3 `_ - `what's new `_ - `diff `_ - 2026-01-28: `7.2.2 `_ - `what's new `_ - `diff `_ - 2025-12-29: `7.2.1 `_ - `what's new `_ - `diff `_ - 2025-12-23: `7.2.0 `_ - `what's new `_ - `diff `_ - 2025-11-02: `7.1.3 `_ - `what's new `_ - `diff `_ - 2025-10-25: `7.1.2 `_ - `what's new `_ - `diff `_ - 2025-10-19: `7.1.1 `_ - `what's new `_ - `diff `_ - 2025-09-17: `7.1.0 `_ - `what's new `_ - `diff `_ - 2025-02-13: `7.0.0 `_ - `what's new `_ - `diff `_ - 2024-12-19: `6.1.1 `_ - `what's new `_ - `diff `_ - 2024-10-17: `6.1.0 `_ - `what's new `_ - `diff `_ - 2024-06-18: `6.0.0 `_ - `what's new `_ - `diff `_ - 2024-01-19: `5.9.8 `_ - `what's new `_ - `diff `_ - 2023-12-17: `5.9.7 `_ - `what's new `_ - `diff `_ - 2023-10-15: `5.9.6 `_ - `what's new `_ - `diff `_ - 2023-04-17: `5.9.5 `_ - `what's new `_ - `diff `_ - 2022-11-07: `5.9.4 `_ - `what's new `_ - `diff `_ - 2022-10-18: `5.9.3 `_ - `what's new `_ - `diff `_ - 2022-09-04: `5.9.2 `_ - `what's new `_ - `diff `_ - 2022-05-20: `5.9.1 `_ - `what's new `_ - `diff `_ - 2021-12-29: `5.9.0 `_ - `what's new `_ - `diff `_ - 2020-12-19: `5.8.0 `_ - `what's new `_ - `diff `_ - 2020-10-24: `5.7.3 `_ - `what's new `_ - `diff `_ - 2020-07-15: `5.7.2 `_ - `what's new `_ - `diff `_ - 2020-07-15: `5.7.1 `_ - `what's new `_ - `diff `_ - 2020-02-18: `5.7.0 `_ - `what's new `_ - `diff `_ - 2019-11-26: `5.6.7 `_ - `what's new `_ - `diff `_ - 2019-11-25: `5.6.6 `_ - `what's new `_ - `diff `_ - 2019-11-06: `5.6.5 `_ - `what's new `_ - `diff `_ - 2019-11-04: `5.6.4 `_ - `what's new `_ - `diff `_ - 2019-06-11: `5.6.3 `_ - `what's new `_ - `diff `_ - 2019-04-26: `5.6.2 `_ - `what's new `_ - `diff `_ - 2019-03-11: `5.6.1 `_ - `what's new `_ - `diff `_ - 2019-03-05: `5.6.0 `_ - `what's new `_ - `diff `_ - 2019-02-15: `5.5.1 `_ - `what's new `_ - `diff `_ - 2019-01-23: `5.5.0 `_ - `what's new `_ - `diff `_ - 2018-10-30: `5.4.8 `_ - `what's new `_ - `diff `_ - 2018-08-14: `5.4.7 `_ - `what's new `_ - `diff `_ - 2018-06-07: `5.4.6 `_ - `what's new `_ - `diff `_ - 2018-04-13: `5.4.5 `_ - `what's new `_ - `diff `_ - 2018-04-13: `5.4.4 `_ - `what's new `_ - `diff `_ - 2018-01-01: `5.4.3 `_ - `what's new `_ - `diff `_ - 2017-12-07: `5.4.2 `_ - `what's new `_ - `diff `_ - 2017-11-08: `5.4.1 `_ - `what's new `_ - `diff `_ - 2017-10-12: `5.4.0 `_ - `what's new `_ - `diff `_ - 2017-09-10: `5.3.1 `_ - `what's new `_ - `diff `_ - 2017-09-01: `5.3.0 `_ - `what's new `_ - `diff `_ - 2017-04-10: `5.2.2 `_ - `what's new `_ - `diff `_ - 2017-03-24: `5.2.1 `_ - `what's new `_ - `diff `_ - 2017-03-05: `5.2.0 `_ - `what's new `_ - `diff `_ - 2017-02-07: `5.1.3 `_ - `what's new `_ - `diff `_ - 2017-02-03: `5.1.2 `_ - `what's new `_ - `diff `_ - 2017-02-03: `5.1.1 `_ - `what's new `_ - `diff `_ - 2017-02-01: `5.1.0 `_ - `what's new `_ - `diff `_ - 2016-12-21: `5.0.1 `_ - `what's new `_ - `diff `_ - 2016-11-06: `5.0.0 `_ - `what's new `_ - `diff `_ - 2016-10-25: `4.4.2 `_ - `what's new `_ - `diff `_ - 2016-10-23: `4.4.1 `_ - `what's new `_ - `diff `_ - 2016-10-05: `4.4.0 `_ - `what's new `_ - `diff `_ - 2016-09-01: `4.3.1 `_ - `what's new `_ - `diff `_ - 2016-06-18: `4.3.0 `_ - `what's new `_ - `diff `_ - 2016-05-14: `4.2.0 `_ - `what's new `_ - `diff `_ - 2016-03-12: `4.1.0 `_ - `what's new `_ - `diff `_ - 2016-02-17: `4.0.0 `_ - `what's new `_ - `diff `_ - 2016-01-20: `3.4.2 `_ - `what's new `_ - `diff `_ - 2016-01-15: `3.4.1 `_ - `what's new `_ - `diff `_ - 2015-11-25: `3.3.0 `_ - `what's new `_ - `diff `_ - 2015-10-04: `3.2.2 `_ - `what's new `_ - `diff `_ - 2015-09-03: `3.2.1 `_ - `what's new `_ - `diff `_ - 2015-09-02: `3.2.0 `_ - `what's new `_ - `diff `_ - 2015-07-15: `3.1.1 `_ - `what's new `_ - `diff `_ - 2015-07-15: `3.1.0 `_ - `what's new `_ - `diff `_ - 2015-06-18: `3.0.1 `_ - `what's new `_ - `diff `_ - 2015-06-13: `3.0.0 `_ - `what's new `_ - `diff `_ - 2015-02-02: `2.2.1 `_ - `what's new `_ - `diff `_ - 2015-01-06: `2.2.0 `_ - `what's new `_ - `diff `_ - 2014-09-26: `2.1.3 `_ - `what's new `_ - `diff `_ - 2014-09-21: `2.1.2 `_ - `what's new `_ - `diff `_ - 2014-04-30: `2.1.1 `_ - `what's new `_ - `diff `_ - 2014-04-08: `2.1.0 `_ - `what's new `_ - `diff `_ - 2014-03-10: `2.0.0 `_ - `what's new `_ - `diff `_ - 2013-11-25: `1.2.1 `_ - `what's new `_ - `diff `_ - 2013-11-20: `1.2.0 `_ - `what's new `_ - `diff `_ - 2013-10-22: `1.1.2 `_ - `what's new `_ - `diff `_ - 2013-10-08: `1.1.1 `_ - `what's new `_ - `diff `_ - 2013-09-28: `1.1.0 `_ - `what's new `_ - `diff `_ - 2013-07-12: `1.0.1 `_ - `what's new `_ - `diff `_ - 2013-07-10: `1.0.0 `_ - `what's new `_ - `diff `_ - 2013-05-03: `0.7.1 `_ - `what's new `_ - `diff `_ - 2013-04-12: `0.7.0 `_ - `what's new `_ - `diff `_ - 2012-08-16: `0.6.1 `_ - `what's new `_ - `diff `_ - 2012-08-13: `0.6.0 `_ - `what's new `_ - `diff `_ - 2012-06-29: `0.5.1 `_ - `what's new `_ - `diff `_ - 2012-06-27: `0.5.0 `_ - `what's new `_ - `diff `_ - 2011-12-14: `0.4.1 `_ - `what's new `_ - `diff `_ - 2011-10-29: `0.4.0 `_ - `what's new `_ - `diff `_ - 2011-07-08: `0.3.0 `_ - `what's new `_ - `diff `_ - 2011-03-20: `0.2.1 `_ - `what's new `_ - `diff `_ - 2010-11-13: `0.2.0 `_ - `what's new `_ - `diff `_ - 2010-03-02: `0.1.3 `_ - `what's new `_ - `diff `_ - 2009-05-06: `0.1.2 `_ - `what's new `_ - `diff `_ - 2009-03-06: `0.1.1 `_ - `what's new `_ - `diff `_ - 2009-01-27: `0.1.0 `_ - `diff `_ ================================================ FILE: psutil/__init__.py ================================================ # 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, sensors) in Python. Supported platforms: - Linux - Windows - macOS - FreeBSD - OpenBSD - NetBSD - Sun Solaris - AIX Supported Python versions are cPython 3.7+ and PyPy. """ from __future__ import annotations import collections import contextlib import datetime import functools import os import signal import socket import subprocess import sys import threading import time import warnings from typing import TYPE_CHECKING as _TYPE_CHECKING try: import pwd except ImportError: pwd = None from . import _common from . import _ntuples as _ntp 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 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 debug from ._common import memoize_when_activated 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 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_ex 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 if LINUX: # This is public API and it will be retrieved from _pslinux.py # via sys.modules. PROCFS_PATH = "/proc" from . import _pslinux as _psplatform from ._enums import ProcessIOPriority from ._enums import ProcessRlimit elif WINDOWS: from . import _pswindows as _psplatform 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 # 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 msg = f"platform {sys.platform} is not supported" raise NotImplementedError(msg) # fmt: off __all__ = [ # exceptions "Error", "NoSuchProcess", "ZombieProcess", "AccessDenied", "TimeoutExpired", # constants "version_info", "__version__", "AF_LINK", "BSD", "FREEBSD", "LINUX", "NETBSD", "OPENBSD", "MACOS", "OSX", "POSIX", "SUNOS", "WINDOWS", "AIX", # classes "Process", "Popen", # functions "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", "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 ] # fmt: on __all__.extend(_psplatform.__extra__all__) _globals = globals() def _export_enum(cls): __all__.append(cls.__name__) for name, member in cls.__members__.items(): if name not in _globals: # noqa: F821 _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 __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 # up importing a python module using a C extension module which # 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 = f"version conflict: {_psplatform.cext.__file__!r} C extension " msg += "module was built for another version of psutil" if hasattr(_psplatform.cext, 'version'): v = ".".join(list(str(_psplatform.cext.version))) msg += f" ({v} instead of {__version__})" else: msg += f" (different than {__version__})" what = getattr( _psplatform.cext, "__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) # ===================================================================== # --- Utils # ===================================================================== if hasattr(_psplatform, 'ppid_map'): # Faster version (Windows and Linux). _ppid_map = _psplatform.ppid_map else: # pragma: no cover 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 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) 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) # ===================================================================== # --- Process class # ===================================================================== class Process: """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 that the PID of the process being queried has been reused. That means that you may end up retrieving information for another process. 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. """ 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 pid < 0: msg = f"pid must be a positive integer (got {pid})" raise ValueError(msg) try: _psplatform.cext.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 # implementation class self._proc = _psplatform.Process(pid) self._last_sys_cpu_times = None self._last_proc_cpu_times = None self._exitcode = _SENTINEL self._ident = (self.pid, None) try: self._ident = self._get_ident() except AccessDenied: # 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: # 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 = "process PID not found" raise NoSuchProcess(pid, msg=msg) from None self._gone = True 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 process 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. """ 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: return (self.pid, self.create_time()) def __str__(self): info = {} info["pid"] = self.pid if self._name: info['name'] = self._name with self.oneshot(): if self._pid_reused: info["status"] = "terminated + PID reused" else: try: info["name"] = self.name() info["status"] = self.status() except ZombieProcess: info["status"] = "zombie" except NoSuchProcess: info["status"] = "terminated" except AccessDenied: pass 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__ def __eq__(self, other): # Test for equality with another Process object based # on PID and creation time. if not isinstance(other, Process): return NotImplemented if OPENBSD or NETBSD or SUNOS: # pragma: no cover # Zombie processes on Open/NetBSD/illumos/Solaris have a # creation time of 0.0. This covers the case when a process # started normally (so it has a ctime), then it turned into a # zombie. It's important to do this because is_running() # depends on __eq__. pid1, ident1 = self._ident pid2, ident2 = other._ident if pid1 == pid2: if ident1 and not ident2: try: return self.status() == ProcessStatus.STATUS_ZOMBIE except Error: pass return self._ident == other._ident def __ne__(self, other): return not self == other def __hash__(self): if self._hash is None: self._hash = hash(self._ident) return self._hash def _raise_if_pid_reused(self): """Raises 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 # --- utility methods @contextlib.contextmanager def oneshot(self) -> Generator[None, None, None]: """Utility context manager which considerably speeds up the retrieval of multiple process information at the same time. Internally different process info (e.g. name, ppid, uids, gids, ...) may be fetched by using the same routine, but only one information is returned and the others are discarded. When using this context manager the internal routine is executed once (in the example below on name()) and the other info are cached. The cache is cleared when exiting the context manager block. The advice is to use this every time you retrieve more than one information about the process. If you're lucky, you'll get a hell of a speedup. >>> 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: # cached in case cpu_percent() is used 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: list[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. *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 if attrs is not None: if not isinstance(attrs, (list, tuple, set, frozenset)): msg = f"invalid attrs type {type(attrs)}" raise TypeError(msg) attrs = set(attrs) invalid_names = attrs - valid_names - _as_dict_attrnames_deprecated if invalid_names: msg = "invalid attr name{} {}".format( "s" if len(invalid_names) > 1 else "", ", ".join(map(repr, invalid_names)), ) raise ValueError(msg) retdict = {} ls = attrs or valid_names with self.oneshot(): 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 return retdict def parent(self) -> Process | None: """Return the parent process as a Process object pre-emptively 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: # 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() <= proc_ctime: return parent # ...else ppid has been reused by another process except NoSuchProcess: pass 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 it will remove the process from `process_iter()` internal cache and return False. """ 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. Process identity / # uniqueness over time is guaranteed by (PID + creation # time) and that is verified in __eq__. self._pid_reused = self != Process(self.pid) if self._pid_reused: _pids_reused.add(self.pid) raise NoSuchProcess(self.pid) return True except ZombieProcess: # We should never get here as it's already handled in # Process.__init__; here just for extra safety. return True except NoSuchProcess: self._gone = True return False # --- actual API @memoize_when_activated def ppid(self) -> int: """The process parent PID. On Windows the return value is cached after first call. """ # On POSIX we don't want to cache the ppid as it may unexpectedly # 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: # pragma: no cover self._ppid = self._ppid or self._proc.ppid() return self._ppid 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: # https://github.com/giampaolo/psutil/issues/692 if WINDOWS and self._name is not None: return self._name name = self._proc.name() if POSIX and len(name) >= 15: # On UNIX the name gets truncated to the first 15 characters. # If it matches the first part of the cmdline we return that # one instead because it's usually more explicative. # Examples are "gnome-keyring-d" vs. "gnome-keyring-daemon". try: cmdline = self.cmdline() 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: extended_name = os.path.basename(cmdline[0]) if extended_name.startswith(name): name = extended_name self._name = name self._proc._name = name return name 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. """ def guess_it(fallback): # try to guess exe from cmdline[0] in absence of a native # exe representation cmdline = self.cmdline() if cmdline and hasattr(os, 'access') and hasattr(os, 'X_OK'): exe = cmdline[0] # the possible exe # 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) ): return exe if isinstance(fallback, AccessDenied): raise fallback return fallback if self._exe is None: try: exe = self._proc.exe() except AccessDenied as err: return guess_it(fallback=err) else: if not exe: # underlying implementation can legitimately return an # empty string; if that's the case we don't want to # raise AD while guessing from the cmdline try: exe = guess_it(fallback=exe) except AccessDenied: pass self._exe = exe return self._exe def cmdline(self) -> list[str]: """The command line this process has been called with.""" return self._proc.cmdline() def status(self) -> ProcessStatus | str: """The process current status as a STATUS_* constant.""" try: return self._proc.status() except ZombieProcess: return ProcessStatus.STATUS_ZOMBIE def username(self) -> str: """The name of the user that owns the process. On UNIX this is calculated by using *real* process uid. """ if POSIX: if pwd is None: # might happen if python was installed from sources msg = "requires pwd module shipped with standard python" raise ImportError(msg) real_uid = self.uids().real try: return pwd.getpwuid(real_uid).pw_name except KeyError: # the uid can't be resolved by the system return str(real_uid) else: return self._proc.username() def create_time(self) -> float: """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 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) -> str: """Process current working directory as an absolute path.""" return self._proc.cwd() 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: self._raise_if_pid_reused() self._proc.nice_set(value) if POSIX: @memoize_when_activated def uids(self) -> puids: """Return process UIDs as a (real, effective, saved) named tuple. """ return self._proc.uids() def gids(self) -> pgids: """Return process GIDs as a (real, effective, saved) named tuple. """ return self._proc.gids() def terminal(self) -> str | None: """The terminal associated with this process, if any, else None. """ return self._proc.terminal() def num_fds(self) -> int: """Return the number of file descriptors opened by this process (POSIX only). """ return self._proc.num_fds() # Linux, BSD, AIX and Windows only if hasattr(_psplatform.Process, "io_counters"): def io_counters(self) -> pio: """Return process I/O statistics as a (read_count, write_count, read_bytes, write_bytes) named tuple. Those are the number of read/write calls performed and the amount of bytes read and written by the process. """ return self._proc.io_counters() # Linux and Windows if hasattr(_psplatform.Process, "ionice_get"): 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 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). Available on Linux and Windows > Vista only. """ if ioclass is None: if value is not None: 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 / FreeBSD only if hasattr(_psplatform.Process, "rlimit"): 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. See "man prlimit" for further info. Available on Linux and FreeBSD only. """ 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: 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]). If an empty list is passed, all egible CPUs are assumed (and set). (Windows, Linux and BSD only). """ if cpus is None: 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, FreeBSD, SunOS if hasattr(_psplatform.Process, "cpu_num"): def cpu_num(self) -> int: """Return what CPU this process is currently running on. The returned number should be <= psutil.cpu_count() and <= len(psutil.cpu_percent(percpu=True)). It may be used in conjunction with psutil.cpu_percent(percpu=True) to observe the system workload distributed across CPUs. """ return self._proc.cpu_num() # All platforms has it, but maybe not in the future. if hasattr(_psplatform.Process, "environ"): 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) -> int: """Return the number of handles opened by this process (Windows only). """ return self._proc.num_handles() 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) -> int: """Return the number of threads used by this process.""" return self._proc.num_threads() if hasattr(_psplatform.Process, "threads"): def threads(self) -> list[pthread]: """Return threads opened by process as a list of (id, user_time, system_time) named tuples representing thread id and thread CPU times (user/system). On OpenBSD this method requires root access. """ return self._proc.threads() 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. Example (A == this process): A ─┐ │ ├─ B (child) ─┐ │ └─ X (grandchild) ─┐ │ └─ Y (great grandchild) ├─ C (child) └─ D (child) >>> import psutil >>> p = psutil.Process() >>> 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 listed as the reference to process A is lost. """ 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: 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 proc_ctime <= child.create_time(): ret.append(child) except (NoSuchProcess, ZombieProcess): pass else: # 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 = proc_ctime <= child.create_time() if intime: ret.append(child) stack.append(child_pid) except (NoSuchProcess, ZombieProcess): pass return ret 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 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. 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 >>> p = psutil.Process(os.getpid()) >>> # blocking >>> p.cpu_percent(interval=1) 2.0 >>> # non-blocking (percentage since last call) >>> p.cpu_percent(interval=None) 2.9 >>> """ 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 def timer(): return _timer() * num_cpus if blocking: st1 = timer() pt1 = self._proc.cpu_times() time.sleep(interval) st2 = timer() pt2 = self._proc.cpu_times() else: st1 = self._last_sys_cpu_times pt1 = self._last_proc_cpu_times st2 = timer() pt2 = self._proc.cpu_times() if st1 is None or pt1 is None: self._last_sys_cpu_times = st2 self._last_proc_cpu_times = pt2 return 0.0 delta_proc = (pt2.user - pt1.user) + (pt2.system - pt1.system) delta_time = st2 - st1 # reset values for next call in case of interval == None self._last_sys_cpu_times = st2 self._last_proc_cpu_times = pt2 try: # 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 except ZeroDivisionError: # interval was too low return 0.0 else: # 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. # # Note 2: # taskmgr.exe on Windows differs in that it will show 50% # instead. # # 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: # http://stackoverflow.com/questions/1032357 # https://github.com/giampaolo/psutil/issues/474 single_cpu_percent = overall_cpus_percent * num_cpus return round(single_cpu_percent, 1) @memoize_when_activated def cpu_times(self) -> pcputimes: """Return a (user, system, children_user, children_system) named tuple representing the accumulated process time, in seconds. This is similar to os.times() but per-process. On macOS and Windows children_user and children_system are always set to 0. """ return self._proc.cpu_times() @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 platforms are `rss` and `vms`. All numbers are expressed in bytes. """ return self._proc.memory_info() @memoize_when_activated def memory_info_ex(self) -> pmem_ex: """Return a named tuple extending memory_info() with extra metrics. All numbers are expressed in bytes. """ base = self.memory_info() if hasattr(self._proc, "memory_info_ex"): extras = self._proc.memory_info_ex() return _ntp.pmem_ex(**base._asdict(), **extras) return base # Linux, macOS, Windows if hasattr(_psplatform.Process, "memory_footprint"): def memory_footprint(self) -> pfootprint: """Return a named tuple with USS, PSS and swap memory metrics. These provide a better representation of actual process memory usage. 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_info_ex() 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 hasattr(self, "memory_footprint"): fp = self.memory_footprint() return _ntp.pfullmem(*basic_mem + fp) return _ntp.pfullmem(*basic_mem) 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') """ valid_types = list(_ntp.pmem._fields) if hasattr(_ntp, "pmem_ex"): valid_types += [ f for f in _ntp.pmem_ex._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: 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, "pfootprint") and memtype in _ntp.pfootprint._fields ): fun = self.memory_footprint else: fun = self.memory_info_ex metrics = fun() 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 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"): 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' 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 named tuple will also include the mapped region's address space ('addr') and permission set ('perms'). """ it = self._proc.memory_maps() if grouped: d = {} for tupl in it: path = tupl[2] nums = tupl[3:] try: d[path] = list(map(lambda x, y: x + y, d[path], nums)) except KeyError: d[path] = nums return [_ntp.pmmap_grouped(path, *d[path]) for path in d] else: return [_ntp.pmmap_ext(*x) for x in it] 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. Both counters are cumulative since process creation. """ return self._proc.page_faults() 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. """ return self._proc.open_files() 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 | +------------+----------------------------------------------------+ """ _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): 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" 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" ) raise ValueError(msg) try: 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 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(). """ if POSIX: self._send_signal(sig) else: # pragma: no cover 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 pre-emptively checking whether PID has been reused. 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() def resume(self) -> None: """Resume process execution with SIGCONT pre-emptively 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() def terminate(self) -> None: """Terminate the process with SIGTERM pre-emptively checking whether PID has been reused. 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() def kill(self) -> None: """Kill the current process with SIGKILL pre-emptively 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: float | None = None) -> int | None: """Wait for process to terminate, and if process is a children of os.getpid(), also return its 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 NoSuchProcess. 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 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(). # fmt: off _as_dict_attrnames = { 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'} } # fmt: on # Deprecated attrs: not returned by default but still accepted if # explicitly requested via as_dict(attrs=[...]). _as_dict_attrnames_deprecated = {'memory_full_info'} # ===================================================================== # --- Popen class # ===================================================================== class Popen(Process): """Same as subprocess.Popen, but in addition it provides all psutil.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' >>> p.uids() user(real=1000, effective=1000, saved=1000) >>> p.username() 'giampaolo' >>> p.communicate() ('hi', None) >>> p.terminate() >>> p.wait(timeout=2) 0 >>> """ def __init__(self, *args, **kwargs): # Explicitly avoid to raise NoSuchProcess in case the process # spawned by subprocess.Popen terminates too quickly, see: # https://github.com/giampaolo/psutil/issues/193 self.__subproc = subprocess.Popen(*args, **kwargs) self._init(self.__subproc.pid, _ignore_nsp=True) 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) except AttributeError: try: return object.__getattribute__(self.__subproc, name) except AttributeError: msg = f"{self.__class__!r} has no attribute {name!r}" raise AttributeError(msg) from None def wait(self, timeout: float | None = None) -> int | None: if self.__subproc.returncode is not None: return self.__subproc.returncode ret = super().wait(timeout) self.__subproc.returncode = ret return ret # ===================================================================== # --- system processes related functions # ===================================================================== def pids() -> list[int]: """Return a list of current running PIDs.""" global _LOWEST_PID ret = sorted(_psplatform.pids()) _LOWEST_PID = ret[0] return ret def pid_exists(pid: int) -> bool: """Return True if given PID exists in the current process list. This is faster than doing "pid in psutil.pids()" and should be preferred. """ if pid < 0: return False elif pid == 0 and POSIX: # On POSIX we use os.kill() to determine PID existence. # According to "man 2 kill" PID 0 has a special meaning # though: it refers to <> and that is not we want # to do here. return pid in pids() else: return _psplatform.pid_exists(pid) _pmap = {} _pids_reused = set() def process_iter( attrs: list[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 into an internal table which is updated every time this is used. 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 as_dict() is called and the resulting dict is stored as a 'info' attribute attached to returned Process instance. If *attrs* is an empty list it will retrieve all process info (slow). """ global _pmap def add(pid): proc = Process(pid) pmap[proc.pid] = proc return proc def remove(pid): pmap.pop(pid, None) pmap = _pmap.copy() a = set(pids()) b = set(pmap) new_pids = a - b gone_pids = b - a for pid in gone_pids: remove(pid) 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) if attrs is not None: proc.info = proc.as_dict(attrs=attrs, ad_value=ad_value) yield proc 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: 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 are gone and which ones are still alive. 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). Function will return as soon as all processes terminate or when *timeout* occurs. Differently from Process.wait() it will not raise TimeoutExpired if *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: >>> def on_terminate(proc): ... print("process {} terminated".format(proc)) ... >>> for p in procs: ... p.terminate() ... >>> gone, alive = wait_procs(procs, timeout=3, callback=on_terminate) >>> for p in alive: ... p.kill() """ def check_gone(proc, timeout): try: returncode = proc.wait(timeout=timeout) 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 = 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 timeout is not None: deadline = _timer() + timeout while alive: if timeout is not None and timeout <= 0: break for proc in alive: # Make sure that every complete iteration (all processes) # will last max 1 sec. # We do this because we don't want to wait too long on a # single process: in case it terminates too late other # processes may disappear in the meantime and their PID # reused. max_timeout = 1.0 / len(alive) if timeout is not None: timeout = min((deadline - _timer()), max_timeout) if timeout <= 0: break check_gone(proc, timeout) else: check_gone(proc, max_timeout) 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 # noqa: PLR6104 return (list(gone), list(alive)) # ===================================================================== # --- CPU related functions # ===================================================================== def cpu_count(logical: bool = True) -> int | None: """Return the number of logical CPUs in the system (same as os.cpu_count()). If *logical* is False return the number of physical cores only (e.g. hyper thread CPUs are excluded). Return None if undetermined. The return value is cached after first call. If desired cache can be cleared like this: >>> psutil.cpu_count.cache_clear() """ if logical: ret = _psplatform.cpu_count_logical() else: 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. The named tuple's fields availability varies depending on the platform: - user - system - idle - nice (UNIX) - iowait (Linux) - irq (Linux, FreeBSD) - softirq (Linux) - steal (Linux) - guest (Linux) - guest_nice (Linux) When *percpu* is True return a list of named tuples 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. """ if not percpu: return _psplatform.cpu_times() else: return _psplatform.per_cpu_times() try: _last_cpu_times = {threading.current_thread().ident: cpu_times()} except Exception: # noqa: BLE001 # Don't want to crash at import time. _last_cpu_times = {} try: _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 = {} def _cpu_tot_time(times): """Given a cpu_time() ntuple 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() ntuple calculates the busy CPU time. We do so 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 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 (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 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. Examples: >>> # blocking, system-wide >>> psutil.cpu_percent(interval=1) 2.0 >>> >>> # blocking, per-cpu >>> psutil.cpu_percent(interval=1, percpu=True) [2.0, 1.0] >>> >>> # non-blocking (percentage since last call) >>> psutil.cpu_percent(interval=None) 2.9 >>> """ 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): times_delta = _cpu_times_deltas(t1, t2) all_delta = _cpu_tot_time(times_delta) busy_delta = _cpu_busy_time(times_delta) try: busy_perc = (busy_delta / all_delta) * 100 except ZeroDivisionError: return 0.0 else: return round(busy_perc, 1) # system-wide usage if not percpu: if blocking: t1 = cpu_times() time.sleep(interval) else: 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 = [] if blocking: tot1 = cpu_times(percpu=True) time.sleep(interval) else: 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 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(). For instance, on Linux we'll get: >>> cpu_times_percent() cpupercent(user=4.8, nice=0.0, system=4.8, idle=90.5, iowait=0.0, 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(). """ 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 = [] 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) # 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 _ntp.scputimes(*nums) # system-wide usage if not percpu: if blocking: t1 = cpu_times() time.sleep(interval) else: 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 = [] if blocking: tot1 = cpu_times(percpu=True) time.sleep(interval) else: 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() -> 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 only) 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 Linux if /proc/cpuinfo is used min/max are set # to None. if LINUX and cpu.min 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() -> svmem: """Return statistics about system memory usage as a named tuple including the following fields, expressed in bytes: - total: total physical memory available. - available: 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 - used: memory used, calculated differently depending on the platform and designed for informational purposes only: macOS: active + wired BSD: active + wired + cached Linux: total - free - 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 (BSD, Linux): cache for things like file system metadata. - cached (BSD, macOS): cache for various things. - wired (macOS, 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. """ global _TOTAL_PHYMEM ret = _psplatform.virtual_memory() # cached for later use in Process.memory_percent() _TOTAL_PHYMEM = ret.total return ret def swap_memory() -> sswap: """Return system swap memory statistics as a named tuple 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 - 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. """ return _psplatform.swap_memory() # ===================================================================== # --- disks/partitions related functions # ===================================================================== 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: bool = False) -> list[sdiskpart]: """Return mounted partitions as a list of (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 all others. """ return _psplatform.disk_partitions(all) def disk_io_counters( perdisk: bool = False, nowrap: bool = True ) -> sdiskio | dict[str, sdiskio]: """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 ms) - write_time: time spent writing to disk (in ms) Platform specific: - 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 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 named tuple described above as the values. If *nowrap* is True it detects and adjust the numbers which overflow and wrap (restart from 0) and add "old value" to "new value" so that the returned numbers will always be increasing or remain the same, but never decrease. "disk_io_counters.cache_clear()" can be used to invalidate the cache. On recent Windows versions 'diskperf -y' command may need to be executed first otherwise this function won't find any disk. """ kwargs = dict(perdisk=perdisk) if LINUX else {} rawdict = _psplatform.disk_io_counters(**kwargs) if not rawdict: 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] = _ntp.sdiskio(*fields) return rawdict else: 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" # ===================================================================== # --- network related functions # ===================================================================== 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 - 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 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 named tuple described above as the values. If *nowrap* is True it detects and adjust the numbers which overflow and wrap (restart from 0) and add "old value" to "new value" so that the returned numbers will always be increasing or remain the same, but never decrease. "net_io_counters.cache_clear()" can be used to invalidate the cache. """ rawdict = _psplatform.net_io_counters() if not rawdict: 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] = _ntp.snetio(*fields) return rawdict else: 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: 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 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 macOS this function requires root privileges. """ _check_conn_kind(kind) return _psplatform.net_connections(kind) def net_if_addrs() -> dict[str, list[snicaddr]]: """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 named tuples for each address assigned to the NIC. Each named tuple includes 5 fields: - 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. """ 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: 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 += f"{separator}00" nt = _ntp.snicaddr(fam, addr, mask, broadcast, ptp) # On Windows broadcast is None, so we determine it via # ipaddress module. if WINDOWS and fam in {socket.AF_INET, socket.AF_INET6}: try: broadcast = _common.broadcast_addr(nt) except Exception as err: # noqa: BLE001 debug(err) else: if broadcast is not None: nt._replace(broadcast=broadcast) ret[name].append(nt) return dict(ret) 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 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 - 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. """ 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_UNLIMITED. - 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() -> 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() -> list[suser]: """Return users currently connected on the system as a list of 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. """ return _psplatform.users() # ===================================================================== # --- Windows services # ===================================================================== if WINDOWS: 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) -> WindowsService: """Get a Windows service by *name*. Raise NoSuchProcess if no service with such name exists. """ return _psplatform.win_service_get(name) # ===================================================================== # --- malloc / heap # ===================================================================== # 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 psutil._common psutil._common.PSUTIL_DEBUG = bool(value) _psplatform.cext.set_debug(bool(value)) del memoize_when_activated ================================================ FILE: psutil/_common.py ================================================ # 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. """Common objects shared by __init__.py and _ps*.py modules. Note: this module is imported by setup.py, so it should not import psutil or third-party modules. """ import collections import functools import os import socket import stat import sys import threading import warnings from socket import AF_INET from socket import SOCK_DGRAM from socket import SOCK_STREAM try: from socket import AF_INET6 except ImportError: AF_INET6 = None try: from socket import AF_UNIX except ImportError: AF_UNIX = None PSUTIL_DEBUG = bool(os.getenv('PSUTIL_DEBUG')) _DEFAULT = object() # fmt: off __all__ = [ # OS constants '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', 'parse_environ_block', 'path_exists_strict', 'usage_percent', 'supports_ipv6', 'sockfam_to_enum', 'socktype_to_enum', "wrap_numbers", 'open_text', 'open_binary', 'cat', 'bcat', 'bytes2human', 'conn_to_ntuple', 'debug', # shell utils 'hilite', 'term_supports_colors', 'print_color', ] # fmt: on # =================================================================== # --- OS constants # =================================================================== POSIX = os.name == "posix" WINDOWS = os.name == "nt" LINUX = sys.platform.startswith("linux") 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", "solaris")) AIX = sys.platform.startswith("aix") ENCODING = sys.getfilesystemencoding() ENCODING_ERRS = sys.getfilesystemencodeerrors() # =================================================================== # --- Process.net_connections() 'kind' parameter mapping # =================================================================== conn_tmap = { "all": ([AF_INET, AF_INET6, AF_UNIX], [SOCK_STREAM, SOCK_DGRAM]), "tcp": ([AF_INET, AF_INET6], [SOCK_STREAM]), "tcp4": ([AF_INET], [SOCK_STREAM]), "udp": ([AF_INET, AF_INET6], [SOCK_DGRAM]), "udp4": ([AF_INET], [SOCK_DGRAM]), "inet": ([AF_INET, AF_INET6], [SOCK_STREAM, SOCK_DGRAM]), "inet4": ([AF_INET], [SOCK_STREAM, SOCK_DGRAM]), "inet6": ([AF_INET6], [SOCK_STREAM, SOCK_DGRAM]), } if AF_INET6 is not None: conn_tmap.update({ "tcp6": ([AF_INET6], [SOCK_STREAM]), "udp6": ([AF_INET6], [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` info = self._infodict(("pid", "ppid", "name")) if info: 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. """ __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)) # =================================================================== # --- utils # =================================================================== def usage_percent(used, total, round_=None): """Calculate percentage usage of 'used' against 'total'.""" try: ret = (float(used) / total) * 100 except ZeroDivisionError: return 0.0 else: if round_ is not None: ret = round(ret, round_) return ret 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. >>> class Foo: ... @memoize_when_activated ... def foo() ... print(1) ... >>> f = Foo() >>> # deactivated (default) >>> foo() 1 >>> foo() 1 >>> >>> # activated >>> foo.cache_activate(self) >>> foo() 1 >>> foo() >>> foo() >>> """ @functools.wraps(fun) def wrapper(self): try: # 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: # 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_deactivate(proc): """Deactivate and clear cache.""" try: del proc._cache except AttributeError: pass 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. """ try: st = os.stat(path) except PermissionError: raise except OSError: return False else: return stat.S_ISREG(st.st_mode) 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. """ try: os.stat(path) except PermissionError: raise except OSError: return False else: return True def supports_ipv6(): """Return True if IPv6 is supported on this platform.""" if not socket.has_ipv6 or AF_INET6 is None: return False try: with socket.socket(AF_INET6, socket.SOCK_STREAM) as sock: sock.bind(("::1", 0)) return True except OSError: return False def parse_environ_block(data): """Parse a C environ block of environment variables into a dictionary.""" # The block is usually raw data from the target process. It might contain # trailing garbage and lines that do not look like assignments. ret = {} pos = 0 # localize global variable to speed up access. WINDOWS_ = WINDOWS while True: next_pos = data.find("\0", pos) # nul byte at the beginning or double nul byte means finish if next_pos <= pos: break # there might not be an equals sign equal_pos = data.find("=", pos, next_pos) if equal_pos > pos: key = data[pos:equal_pos] value = data[equal_pos + 1 : next_pos] # Windows expects environment variables to be uppercase only if WINDOWS_: key = key.upper() ret[key] = value pos = next_pos + 1 return ret 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. """ try: return socket.AddressFamily(num) except ValueError: 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. """ try: return socket.SocketKind(num) except ValueError: 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. """ import ipaddress if not addr.address or not addr.netmask: return None if addr.family == socket.AF_INET: return str( ipaddress.IPv4Network( f"{addr.address}/{addr.netmask}", strict=False ).broadcast_address ) if addr.family == socket.AF_INET6: return str( ipaddress.IPv6Network( f"{addr.address}/{addr.netmask}", strict=False ).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. """ def outer(fun): msg = ( f"{fun.__name__}() is deprecated and will be removed; use" f" {replacement}() instead" ) if fun.__doc__ is None: fun.__doc__ = msg @functools.wraps(fun) def inner(self, *args, **kwargs): warnings.warn(msg, category=DeprecationWarning, stacklevel=2) return getattr(self, replacement)(*args, **kwargs) return inner return outer class deprecated_property: """A descriptor which can be used to mark a property as deprecated. 'replacement' is the attribute name to use instead. Usage:: class Foo: bar = deprecated_property("baz") """ def __init__(self, replacement): self.replacement = replacement self._msg = None def __set_name__(self, owner, name): self._msg = ( f"{name} is deprecated and will be removed; use" f" {self.replacement} instead" ) def __get__(self, obj, objtype=None): if obj is None: return self warnings.warn(self._msg, category=DeprecationWarning, stacklevel=2) return getattr(obj, self.replacement) 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, format="%(value).1f%(symbol)s"): """Used by various scripts. See: https://code.activestate.com/recipes/578019-bytes-to-human-human-to-bytes-converter/?in=user-4178764. >>> 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 format % locals() return format % dict(symbol=symbols[0], value=n) 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 ) ================================================ FILE: psutil/_enums.py ================================================ # 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: from . import _psutil_windows as cext elif LINUX: from . import _psutil_linux as cext elif FREEBSD: from . import _psutil_bsd as cext else: cext = 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 = cext.ABOVE_NORMAL_PRIORITY_CLASS BELOW_NORMAL_PRIORITY_CLASS = cext.BELOW_NORMAL_PRIORITY_CLASS HIGH_PRIORITY_CLASS = cext.HIGH_PRIORITY_CLASS IDLE_PRIORITY_CLASS = cext.IDLE_PRIORITY_CLASS NORMAL_PRIORITY_CLASS = cext.NORMAL_PRIORITY_CLASS REALTIME_PRIORITY_CLASS = cext.REALTIME_PRIORITY_CLASS if LINUX or FREEBSD: # psutil.Process.rlimit() ProcessRlimit = enum.IntEnum( "ProcessRlimit", ( (name, getattr(cext, name)) for name in dir(cext) if name.startswith("RLIM") and name.isupper() ), ) ================================================ FILE: psutil/_ntuples.py ================================================ # 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 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_info_ex() / 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_info_ex() pmem_ex = namedtuple( "pmem_ex", pmem._fields + ( "peak_rss", "peak_vms", "rss_anon", "rss_file", "rss_shmem", "swap", "hugetlb", ), ) # 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_info_ex() 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_info_ex() pmem_ex = namedtuple( "pmem_ex", pmem._fields + ( "virtual", "peak_virtual", "paged_pool", "nonpaged_pool", "peak_paged_pool", "peak_nonpaged_pool", ), ) # 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_info_ex() class pmem_ex(NamedTuple): rss: int vms: int peak_rss: int rss_anon: int rss_file: int wired: int compressed: int phys_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_info_ex() pmem_ex = pmem # 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_info_ex() pmem_ex = pmem # psutil.Process.memory_full_info() pfullmem = pmem ================================================ FILE: psutil/_psaix.py ================================================ # 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_aix as cext 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(cext, "proc_threads") HAS_NET_IO_COUNTERS = hasattr(cext, "net_io_counters") HAS_PROC_IO_COUNTERS = hasattr(cext, "proc_io_counters") PAGE_SIZE = cext.getpagesize() AF_LINK = cext.AF_LINK PROC_STATUSES = { cext.SIDL: ProcessStatus.STATUS_IDLE, cext.SZOMB: ProcessStatus.STATUS_ZOMBIE, cext.SACTIVE: ProcessStatus.STATUS_RUNNING, cext.SSWAP: ProcessStatus.STATUS_RUNNING, # TODO what status is this? cext.SSTOP: ProcessStatus.STATUS_STOPPED, } TCP_STATUSES = { cext.TCPS_ESTABLISHED: ConnectionStatus.CONN_ESTABLISHED, cext.TCPS_SYN_SENT: ConnectionStatus.CONN_SYN_SENT, cext.TCPS_SYN_RCVD: ConnectionStatus.CONN_SYN_RECV, cext.TCPS_FIN_WAIT_1: ConnectionStatus.CONN_FIN_WAIT1, cext.TCPS_FIN_WAIT_2: ConnectionStatus.CONN_FIN_WAIT2, cext.TCPS_TIME_WAIT: ConnectionStatus.CONN_TIME_WAIT, cext.TCPS_CLOSED: ConnectionStatus.CONN_CLOSE, cext.TCPS_CLOSE_WAIT: ConnectionStatus.CONN_CLOSE_WAIT, cext.TCPS_LAST_ACK: ConnectionStatus.CONN_LAST_ACK, cext.TCPS_LISTEN: ConnectionStatus.CONN_LISTEN, cext.TCPS_CLOSING: ConnectionStatus.CONN_CLOSING, cext.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 = cext.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 = cext.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 = cext.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 [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 = cext.cpu_stats() return ntp.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls) # ===================================================================== # --- disks # ===================================================================== disk_io_counters = cext.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 = cext.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 = cext.net_if_addrs if HAS_NET_IO_COUNTERS: net_io_counters = cext.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 = cext.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 = cext.net_if_mtu(name) flags = cext.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 cext.boot_time() def users(): """Return currently connected users as a list of named tuples.""" retlist = [] rawlist = cext.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 cext.proc_oneshot(self.pid, self._procfs_path) @wrap_exceptions @memoize_when_activated def _proc_cred(self): return cext.proc_cred(self.pid, self._procfs_path) @wrap_exceptions def name(self): if self.pid == 0: return "swapper" # note: max 16 characters return cext.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 cext.proc_args(self.pid) @wrap_exceptions def environ(self): return cext.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 = cext.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 cext.proc_priority_get(self.pid) @wrap_exceptions def nice_set(self, value): return cext.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 = cext.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(*cext.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 = cext.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) ================================================ FILE: psutil/_psbsd.py ================================================ # 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. """FreeBSD, OpenBSD and NetBSD platforms implementation.""" import contextlib import errno import functools import os from collections import defaultdict from collections import namedtuple from xml.etree import ElementTree # noqa: ICN001 from . import _ntuples as ntp from . import _psposix from . import _psutil_bsd as cext from ._common import FREEBSD from ._common import NETBSD from ._common import OPENBSD 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 ._enums import BatteryTime from ._enums import ConnectionStatus from ._enums import NicDuplex from ._enums import ProcessStatus __extra__all__ = [] # ===================================================================== # --- globals # ===================================================================== if FREEBSD: PROC_STATUSES = { cext.SIDL: ProcessStatus.STATUS_IDLE, cext.SRUN: ProcessStatus.STATUS_RUNNING, cext.SSLEEP: ProcessStatus.STATUS_SLEEPING, cext.SSTOP: ProcessStatus.STATUS_STOPPED, cext.SZOMB: ProcessStatus.STATUS_ZOMBIE, cext.SWAIT: ProcessStatus.STATUS_WAITING, cext.SLOCK: ProcessStatus.STATUS_LOCKED, } elif OPENBSD: PROC_STATUSES = { cext.SIDL: ProcessStatus.STATUS_IDLE, cext.SSLEEP: ProcessStatus.STATUS_SLEEPING, cext.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: ProcStatus.STATUS_ZOMBIE, cext.SDEAD: ProcessStatus.STATUS_ZOMBIE, cext.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. # SONPROC indicates that the process is actually executing on # 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: ProcessStatus.STATUS_WAKING, cext.SONPROC: ProcessStatus.STATUS_RUNNING, } elif NETBSD: PROC_STATUSES = { cext.SIDL: ProcessStatus.STATUS_IDLE, cext.SSLEEP: ProcessStatus.STATUS_SLEEPING, cext.SSTOP: ProcessStatus.STATUS_STOPPED, cext.SZOMB: ProcessStatus.STATUS_ZOMBIE, cext.SRUN: ProcessStatus.STATUS_WAKING, cext.SONPROC: ProcessStatus.STATUS_RUNNING, } TCP_STATUSES = { cext.TCPS_ESTABLISHED: ConnectionStatus.CONN_ESTABLISHED, cext.TCPS_SYN_SENT: ConnectionStatus.CONN_SYN_SENT, cext.TCPS_SYN_RECEIVED: ConnectionStatus.CONN_SYN_RECV, cext.TCPS_FIN_WAIT_1: ConnectionStatus.CONN_FIN_WAIT1, cext.TCPS_FIN_WAIT_2: ConnectionStatus.CONN_FIN_WAIT2, cext.TCPS_TIME_WAIT: ConnectionStatus.CONN_TIME_WAIT, cext.TCPS_CLOSED: ConnectionStatus.CONN_CLOSE, cext.TCPS_CLOSE_WAIT: ConnectionStatus.CONN_CLOSE_WAIT, cext.TCPS_LAST_ACK: ConnectionStatus.CONN_LAST_ACK, cext.TCPS_LISTEN: ConnectionStatus.CONN_LISTEN, cext.TCPS_CLOSING: ConnectionStatus.CONN_CLOSING, cext.PSUTIL_CONN_NONE: ConnectionStatus.CONN_NONE, } PAGESIZE = cext.getpagesize() AF_LINK = cext.AF_LINK HAS_PROC_NUM_THREADS = hasattr(cext, "proc_num_threads") # ===================================================================== # --- memory # ===================================================================== def virtual_memory(): d = cext.virtual_mem() return ntp.svmem(**d) def swap_memory(): """System swap memory as a (total, used, free, percent, sin, sout) named tuple. sin and sout are always 0 on OpenBSD """ d = cext.swap_mem() return ntp.sswap(**d) # malloc / heap functions (FreeBSD / NetBSD) if hasattr(cext, "heap_info"): heap_info = cext.heap_info heap_trim = cext.heap_trim # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """Return system per-CPU times as a named tuple.""" user, nice, system, idle, irq = cext.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 cext.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() if OPENBSD or NETBSD: def cpu_count_cores(): # OpenBSD and NetBSD do not implement this. return 1 if cpu_count_logical() == 1 else None else: def cpu_count_cores(): """Return the number of CPU cores 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_topology() if s is not None: # get rid of padding chars appended at the end of the string index = s.rfind("") if index != -1: s = s[: index + 9] root = ElementTree.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 == 1 it's obvious we' have only 1 core. if cpu_count_logical() == 1: return 1 return ret 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 (?). # # 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 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 = cext.cpu_freq(cpu) except NotImplementedError: continue 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(cext.cpu_freq()) return [ntp.scpufreq(curr, 0.0, 0.0)] # ===================================================================== # --- disks # ===================================================================== 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() for partition in partitions: device, mountpoint, fstype, opts = partition ntuple = ntp.sdiskpart(device, mountpoint, fstype, opts) retlist.append(ntuple) return retlist disk_usage = _psposix.disk_usage disk_io_counters = cext.disk_io_counters # ===================================================================== # --- network # ===================================================================== net_io_counters = cext.net_io_counters net_if_addrs = cext.net_if_addrs def net_if_stats(): """Get NIC stats (isup, duplex, speed, mtu).""" names = net_io_counters().keys() ret = {} for name in names: try: mtu = cext.net_if_mtu(name) flags = cext.net_if_flags(name) duplex, speed = cext.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): """System-wide network connections.""" families, types = conn_tmap[kind] ret = set() if OPENBSD: rawlist = cext.net_connections(-1, families, types) elif NETBSD: rawlist = cext.net_connections(-1, kind) else: # FreeBSD rawlist = cext.net_connections(families, types) for item in rawlist: fd, fam, type, laddr, raddr, status, pid = item 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 = cext.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 = cext.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 # ===================================================================== def boot_time(): """The system boot time expressed in seconds since the epoch.""" return cext.boot_time() if NETBSD: try: INIT_BOOT_TIME = boot_time() except Exception as err: # noqa: BLE001 # Don't want to crash at import time. debug(f"ignoring exception 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() for item in rawlist: user, tty, hostname, tstamp, pid = item if tty == '~': continue # reboot or shutdown nt = ntp.suser(user, tty or None, hostname, tstamp, pid) retlist.append(nt) return retlist # ===================================================================== # --- processes # ===================================================================== @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 = cext.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: def pid_exists(pid): exists = _psposix.pid_exists(pid) if not exists: # We do this because _psposix.pid_exists() lies in case of # zombie processes. return pid in pids() else: return True 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 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 cext.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 cext.ZombieProcessError as err: raise ZombieProcess(pid, name, ppid) from err except OSError as err: if pid == 0 and 0 in pids(): raise AccessDenied(pid, name) from err raise err from None return wrapper @contextlib.contextmanager def wrap_exceptions_procfs(inst): """Same as above, for routines relying on reading /proc fs.""" pid, name, ppid = inst.pid, inst._name, inst._ppid try: yield except (ProcessLookupError, FileNotFoundError) 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 cext.proc_is_zombie(inst.pid): raise ZombieProcess(pid, name, ppid) from err else: raise NoSuchProcess(pid, name) from err except PermissionError as err: raise AccessDenied(pid, name) from err class Process: """Wrapper class around underlying C implementation.""" __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. cext.proc_name(self.pid) @wrap_exceptions @memoize_when_activated def oneshot(self): """Retrieves multiple process info in one shot as a raw dict.""" return cext.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): name = self.oneshot()["name"] return name if name is not None else cext.proc_name(self.pid) @wrap_exceptions def exe(self): if FREEBSD: if self.pid == 0: return '' # else NSP return cext.proc_exe(self.pid) elif NETBSD: if self.pid == 0: # /proc/0 dir exists but /proc/0/exe doesn't return "" with wrap_exceptions_procfs(self): return os.readlink(f"/proc/{self.pid}/exe") else: # OpenBSD: exe cannot be determined; references: # 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 shutil.which(cmdline[0]) or "" else: return "" @wrap_exceptions def cmdline(self): if OPENBSD and self.pid == 0: return [] # ...else it crashes elif NETBSD: # 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) except OSError as err: if err.errno == errno.EINVAL: pid, name, ppid = self.pid, self._name, self._ppid if cext.proc_is_zombie(self.pid): raise ZombieProcess(pid, name, ppid) from err if not pid_exists(self.pid): raise NoSuchProcess(pid, name, ppid) from err # XXX: this happens with unicode tests. It means the C # routine is unable to decode invalid unicode chars. debug(f"ignoring {err!r} and returning an empty list") return [] else: raise else: return cext.proc_cmdline(self.pid) @wrap_exceptions def environ(self): return cext.proc_environ(self.pid) @wrap_exceptions def terminal(self): tty_nr = self.oneshot()["ttynr"] tmap = _psposix.get_terminal_map() try: return tmap[tty_nr] except KeyError: return None @wrap_exceptions def ppid(self): self._ppid = self.oneshot()["ppid"] return self._ppid @wrap_exceptions def uids(self): d = self.oneshot() return ntp.puids(d["real_uid"], d["effective_uid"], d["saved_uid"]) @wrap_exceptions def gids(self): d = self.oneshot() return ntp.pgids(d["real_gid"], d["effective_gid"], d["saved_gid"]) @wrap_exceptions def cpu_times(self): 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): 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, 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 HAS_PROC_NUM_THREADS: # FreeBSD / NetBSD return cext.proc_num_threads(self.pid) else: return len(self.threads()) @wrap_exceptions def num_ctx_switches(self): 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) retlist = [] for thread_id, utime, stime in rawlist: ntuple = ntp.pthread(thread_id, utime, stime) retlist.append(ntuple) if OPENBSD: self._assert_alive() return retlist @wrap_exceptions def net_connections(self, kind='inet'): families, types = conn_tmap[kind] ret = [] if NETBSD: rawlist = cext.net_connections(self.pid, kind) elif OPENBSD: rawlist = cext.net_connections(self.pid, families, types) else: rawlist = cext.proc_net_connections(self.pid, families, types) for item in rawlist: 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) self._assert_alive() return ret @wrap_exceptions def wait(self, timeout=None): return _psposix.wait_pid(self.pid, timeout) @wrap_exceptions def nice_get(self): return cext.proc_priority_get(self.pid) @wrap_exceptions def nice_set(self, value): return cext.proc_priority_set(self.pid, value) @wrap_exceptions def status(self): 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): d = self.oneshot() return ntp.pio(d["read_io_count"], d["write_io_count"], -1, -1) @wrap_exceptions def cwd(self): """Return process current working directory.""" # sometimes we get an empty string, in which case we turn # it into None if OPENBSD and self.pid == 0: return "" # ...else it would raise EINVAL return cext.proc_cwd(self.pid) nt_mmap_grouped = namedtuple( 'mmap', 'path rss, private, ref_count, shadow_count' ) nt_mmap_ext = namedtuple( 'mmap', 'addr, perms path rss, private, ref_count, shadow_count' ) @wrap_exceptions def open_files(self): """Return files opened by process as a list of named tuples.""" rawlist = cext.proc_open_files(self.pid) return [ntp.popenfile(path, fd) for path, fd in rawlist] @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: self._assert_alive() return ret # --- FreeBSD only APIs if FREEBSD: @wrap_exceptions def cpu_affinity_get(self): return cext.proc_cpu_affinity_get(self.pid) @wrap_exceptions def cpu_affinity_set(self, cpus): # Pre-emptively 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 = set(range(len(per_cpu_times()))) for cpu in cpus: if cpu not in allcpus: msg = f"invalid CPU {cpu!r} (choose between {allcpus})" raise ValueError(msg) try: cext.proc_cpu_affinity_set(self.pid, cpus) except OSError as err: # 'man cpuset_setaffinity' about EDEADLK: # <> if err.errno in {errno.EINVAL, errno.EDEADLK}: for cpu in cpus: if cpu not in 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) @wrap_exceptions def rlimit(self, resource, limits=None): if limits is None: return cext.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 cext.proc_setrlimit(self.pid, resource, soft, hard) ================================================ FILE: psutil/_pslinux.py ================================================ # 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 platform implementation.""" 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 warnings from collections import defaultdict from . import _ntuples as ntp from . import _psposix from . import _psutil_linux as cext 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_when_activated from ._common import open_binary from ._common import open_text from ._common import parse_environ_block from ._common import path_exists_strict from ._common import socktype_to_enum from ._common import supports_ipv6 from ._common import usage_percent from ._enums import BatteryTime from ._enums import ConnectionStatus from ._enums import NicDuplex from ._enums import ProcessIOPriority from ._enums import ProcessStatus __extra__all__ = ['PROCFS_PATH'] # ===================================================================== # --- globals # ===================================================================== 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(cext, "proc_ioprio_get") HAS_CPU_AFFINITY = hasattr(cext, "proc_cpu_affinity_get") # Number of clock ticks per second CLOCK_TICKS = os.sysconf("SC_CLK_TCK") PAGESIZE = cext.getpagesize() LITTLE_ENDIAN = sys.byteorder == 'little' UNSET = object() # "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": 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, } # https://github.com/torvalds/linux/blob/master/include/net/tcp_states.h TCP_STATUSES = { "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, } # ===================================================================== # --- utils # ===================================================================== def readlink(path): """Wrapper around os.readlink().""" 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 # bytes, not str" errors when the string is passed to other # fs-related functions (os.*, open(), ...). # Apparently everything after '\x00' is garbage (we can have # ' (deleted)', 'new' and possibly others), see: # https://github.com/giampaolo/psutil/issues/717 path = path.split('\x00')[0] # Certain paths have ' (deleted)' appended. Usually this is # bogus as the file actually exists. Even if it doesn't we # don't care. if path.endswith(' (deleted)') and not path_exists_strict(path): path = path[:-10] return 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: mode = mode.replace('w', 'a', 1) mode = mode.replace('w+', 'r+') # possible values: r, w, a, r+, a+ return mode 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) # ===================================================================== # --- 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 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 """ # 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 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(): """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: fields = line.split() mems[fields[0]] = int(fields[1]) * 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 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 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(): """Return swap memory metrics.""" mems = {} with open_binary(f"{get_procfs_path()}/meminfo") as f: for line in f: fields = line.split() mems[fields[0]] = int(fields[1]) * 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 = cext.linux_sysinfo() total *= unit_multiplier free *= unit_multiplier used = total - free percent = usage_percent(used, total, round_=1) # get pgin/pgouts try: 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 " f"be determined and were set to 0 ({err})" ) warnings.warn(msg, RuntimeWarning, stacklevel=2) sin = sout = 0 else: with f: sin = sout = None for line in f: # values are expressed in 4 kilo bytes, we want # bytes instead if line.startswith(b'pswpin'): sin = int(line.split(b' ')[1]) * 4 * 1024 elif line.startswith(b'pswpout'): sout = int(line.split(b' ')[1]) * 4 * 1024 if sin is not None and sout is not None: break else: # 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 " msg += "be determined and were set to 0" warnings.warn(msg, RuntimeWarning, stacklevel=2) sin = sout = 0 return ntp.sswap(total, used, free, percent, sin, sout) # malloc / heap functions; require glibc if hasattr(cext, "heap_info"): heap_info = cext.heap_info heap_trim = cext.heap_trim # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """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() with open_binary(f"{procfs_path}/stat") as f: values = f.readline().split() 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 named tuples representing the CPU times for every CPU available on the system. """ procfs_path = get_procfs_path() cpus = [] 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() 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 cpu_count_logical(): """Return the number of logical CPUs in the system.""" try: return os.sysconf("SC_NPROCESSORS_ONLN") except ValueError: # as a second fallback we try to parse /proc/cpuinfo num = 0 with open_binary(f"{get_procfs_path()}/cpuinfo") as f: for line in f: if line.lower().startswith(b'processor'): num += 1 # unknown format (e.g. amrel/sparc architectures), see: # https://github.com/giampaolo/psutil/issues/200 # try to parse /proc/stat as a last resort if num == 0: 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): num += 1 if num == 0: # mimic os.cpu_count() return None return num 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(f"{get_procfs_path()}/cpuinfo") as f: for line in f: line = line.strip().lower() if not line: # new section try: mapping[current_info[b'physical id']] = current_info[ b'cpu cores' ] except KeyError: pass current_info = {} elif line.startswith((b'physical id', b'cpu cores')): # ongoing section key, value = line.split(b':', 1) current_info[key.strip()] = int(value) result = sum(mapping.values()) return result or None # mimic os.cpu_count() def cpu_stats(): """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 for line in f: if line.startswith(b'ctxt'): ctx_switches = int(line.split()[1]) elif line.startswith(b'intr'): 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 ): break syscalls = 0 return ntp.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls) def _cpu_get_cpuinfo_freq(): """Return current CPU frequency from cpuinfo if available.""" with open_binary(f"{get_procfs_path()}/cpuinfo") as f: return [ float(line.split(b':', 1)[1]) for line in f if line.lower().startswith(b'cpu mhz') ] 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. """ 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") paths.sort(key=lambda x: int(re.search(r"[0-9]+", x).group())) ret = [] pjoin = os.path.join for i, path in enumerate(paths): if len(paths) == 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{i}/online" # if cpu core is offline, set to all zeroes if cat(online_path, fallback=None) == "0\n": ret.append(ntp.scpufreq(0.0, 0.0, 0.0)) 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 None. """ return [ntp.scpufreq(x, 0.0, 0.0) for x in _cpu_get_cpuinfo_freq()] # ===================================================================== # --- network # ===================================================================== net_if_addrs = cext.net_if_addrs class _Ipv6UnsupportedError(Exception): pass 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". Note: in case of UNIX sockets we're only able to determine the local endpoint/path, not the one it's connected to. According to [1] it would be possible but not easily. [1] http://serverfault.com/a/417946 """ 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) udp6 = ("udp6", socket.AF_INET6, socket.SOCK_DGRAM) unix = ("unix", socket.AF_UNIX, None) self.tmap = { "all": (tcp4, tcp6, udp4, udp6, unix), "tcp": (tcp4, tcp6), "tcp4": (tcp4,), "tcp6": (tcp6,), "udp": (udp4, udp6), "udp4": (udp4,), "udp6": (udp6,), "unix": (unix,), "inet": (tcp4, tcp6, udp4, udp6), "inet4": (tcp4, udp4), "inet6": (tcp6, udp6), } self._procfs_path = None def get_proc_inodes(self, pid): inodes = defaultdict(list) for fd in os.listdir(f"{self._procfs_path}/{pid}/fd"): try: inode = readlink(f"{self._procfs_path}/{pid}/fd/{fd}") except (FileNotFoundError, ProcessLookupError): # ENOENT == file which is gone in the meantime; # os.stat(f"/proc/{self.pid}") will be done later # to force NSP (if it's the case) continue except OSError as err: if err.errno == errno.EINVAL: # not a link continue if err.errno == errno.ENAMETOOLONG: # file name too long debug(err) continue raise else: if inode.startswith('socket:['): # the process is using a socket inode = inode[8:][:-1] inodes[inode].append((pid, int(fd))) return inodes def get_all_inodes(self): inodes = {} for pid in pids(): try: inodes.update(self.get_proc_inodes(pid)) 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 # and fd set to None anyway. # 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. continue return inodes @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: "0500000A:0016" -> ("10.0.0.5", 22) "0000000000000000FFFF00000100007F:9E49" -> ("::ffff:127.0.0.1", 40521) The IP address portion is a little or big endian four-byte hexadecimal number; that is, the least significant byte is listed first, so we need to reverse the order of the bytes to convert it to an IP address. The port is represented as a two-byte hexadecimal number. Reference: http://linuxdevcenter.com/pub/a/linux/2000/11/16/LinuxAdmin.html """ ip, port = addr.split(':') port = int(port, 16) # this usually refers to a local socket in listen mode with # no end-points connected if not port: return () ip = ip.encode('ascii') if family == socket.AF_INET: # see: https://github.com/giampaolo/psutil/issues/201 if LITTLE_ENDIAN: ip = socket.inet_ntop(family, base64.b16decode(ip)[::-1]) else: ip = socket.inet_ntop(family, base64.b16decode(ip)) else: # IPv6 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)), ) else: ip = socket.inet_ntop( socket.AF_INET6, struct.pack('<4I', *struct.unpack('<4I', ip)), ) except ValueError: # see: https://github.com/giampaolo/psutil/issues/623 if not supports_ipv6(): raise _Ipv6UnsupportedError from None raise return ntp.addr(ip, port) @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) as f: f.readline() # skip the first line for lineno, line in enumerate(f, 1): try: _, laddr, raddr, status, _, _, _, _, _, inode = ( line.split()[:10] ) except ValueError: 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("ambiguous inode with multiple " # "PIDs references") pid, fd = inodes[inode][0] else: pid, fd = None, -1 if filter_pid is not None and filter_pid != pid: continue else: if type_ == socket.SOCK_STREAM: status = TCP_STATUSES[status] else: status = ConnectionStatus.CONN_NONE try: laddr = NetConnections.decode_address(laddr, family) raddr = NetConnections.decode_address(raddr, family) except _Ipv6UnsupportedError: continue yield (fd, family, type_, laddr, raddr, status, pid) @staticmethod def process_unix(file, family, inodes, filter_pid=None): """Parse /proc/net/unix files.""" with open_text(file) as f: f.readline() # skip the first line for line in f: tokens = line.split() try: _, _, _, _, type_, _, inode = tokens[0:7] except ValueError: if ' ' not in line: # see: https://github.com/giampaolo/psutil/issues/766 continue 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] else: pairs = [(None, -1)] for pid, fd in pairs: if filter_pid is not None and filter_pid != pid: continue else: 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): self._procfs_path = get_procfs_path() if pid is not None: inodes = self.get_proc_inodes(pid) if not inodes: # no connections for this process return [] else: inodes = self.get_all_inodes() ret = set() 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( path, family, type_, inodes, filter_pid=pid ) else: ls = self.process_unix(path, family, inodes, filter_pid=pid) for fd, family, type_, laddr, raddr, status, bound_pid in ls: if pid: conn = ntp.pconn(fd, family, type_, laddr, raddr, status) else: conn = ntp.sconn( fd, family, type_, laddr, raddr, status, bound_pid ) ret.add(conn) return list(ret) _net_connections = NetConnections() def net_connections(kind='inet'): """Return system-wide open connections.""" 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(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() ( # 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: NicDuplex.NIC_DUPLEX_FULL, cext.DUPLEX_HALF: NicDuplex.NIC_DUPLEX_HALF, cext.DUPLEX_UNKNOWN: NicDuplex.NIC_DUPLEX_UNKNOWN, } names = net_io_counters().keys() ret = {} for name in names: try: mtu = cext.net_if_mtu(name) flags = cext.net_if_flags(name) duplex, speed = cext.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 # ===================================================================== # --- disks # ===================================================================== disk_usage = _psposix.disk_usage def disk_io_counters(perdisk=False): """Return disk I/O statistics for every disk installed on the system as a dict of raw tuples. """ 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.: # "3 0 8 hda 8 8 8 8 8 8 8 8 8 8 8" # On Linux 2.6+ each line *usually* has 14 fields, and the disk # name is in another position, like this: # "3 0 hda 8 8 8 8 8 8 8 8 8 8 8" # ...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 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 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="): name = line.strip().rpartition("DEVNAME=")[2] if name: # just for extra safety 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 named tuples.""" fstypes = set() procfs_path = get_procfs_path() if not all: 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") # 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(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 not device or fstype not in fstypes: continue 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 named tuples.""" retlist = [] rawlist = cext.users() for item in rawlist: 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.""" path = f"{get_procfs_path()}/stat" with open_binary(path) as f: for line in f: if line.startswith(b'btime'): return float(line.strip().split()[1]) msg = f"line 'btime' not found in {path}" raise RuntimeError(msg) # ===================================================================== # --- processes # ===================================================================== def pids(): """Returns a list of PIDs currently running on the system.""" 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. 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 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 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: """Linux process implementation.""" __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 and return a dict with various process info. Using "man proc" as a reference: where "man proc" refers to 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. """ 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 occurrence of ")". rpar = data.rfind(b')') 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): """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(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): # XXX - gets changed later and probably needs refactoring return decode(self._parse_stat_file()['name']) @wrap_exceptions def exe(self): return self._readlink( f"{self._procfs_path}/{self.pid}/exe", fallback="" ) @wrap_exceptions def cmdline(self): 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 [] # '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] 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(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()['ttynr']) tmap = _psposix.get_terminal_map() try: return tmap[tty_nr] except KeyError: return None # May not be available on old kernels. if os.path.exists(f"/proc/{os.getpid()}/io"): @wrap_exceptions def io_counters(self): fname = f"{self._procfs_path}/{self.pid}/io" fields = {} with open_binary(fname) as f: for line in f: # 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['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): return _psposix.wait_pid(self.pid, timeout) @wrap_exceptions 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): # ============================================================ # | FIELD | DESCRIPTION | AKA | TOP | # ============================================================ # | rss | resident set size | | RES | # | vms | total program size | size | VIRT | # | shared | shared pages (from shared mappings) | | SHR | # | text | text ('code') | trs | CODE | # | lib | library (unused in Linux 2.6) | lrs | | # | data | data + stack | drs | DATA | # | dirty | dirty pages (unused in Linux 2.6) | dt | | # ============================================================ 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) @wrap_exceptions def memory_info_ex( 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 which provides peak RSS/VMS and a # cheaper way to get swap (no smaps parsing needed). # 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 { "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": 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 _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. # # You might be tempted to calculate USS by subtracting # the "shared" value from the "resident" value in # /proc//statm. But at least on Linux, statm's "shared" # value actually counts pages backed by files, which has # little to do with whether the pages are actually shared. # /proc/self/smaps on the other hand appears to give us the # correct information. smaps_data = self._read_smaps_file() # Note: smaps file can be empty for certain processes. # The code below will not crash though and will result to 0. 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 (uss, pss, swap) @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_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: 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: fields = line.split(None, 5) if not fields[0].endswith(b':'): # new block section yield (current_block.pop(), data) current_block.append(line) else: try: data[fields[0]] = int(fields[1]) * 1024 except (ValueError, IndexError): if fields[0].startswith(b'VmFlags:'): # see issue #369 continue 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 or for # zombies. if not data: self._raise_if_zombie() return [] lines = data.split(b'\n') ls = [] first_line = lines.pop(0) current_block = [first_line] for header, data in get_blocks(lines, current_block): hfields = header.split(None, 5) try: addr, perms, _offset, _dev, _inode, path = hfields except ValueError: addr, perms, _offset, _dev, _inode, path = hfields + [''] if not path: path = '[anon]' else: path = decode(path) path = path.strip() if path.endswith(' (deleted)') and not path_exists_strict( path ): path = path[:-10] 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), data.get(b'Shared_Dirty:', 0), data.get(b'Private_Clean:', 0), data.get(b'Private_Dirty:', 0), data.get(b'Referenced:', 0), data.get(b'Anonymous:', 0), data.get(b'Swap:', 0), ) ls.append(item) return ls @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 self._readlink( f"{self._procfs_path}/{self.pid}/cwd", fallback="" ) @wrap_exceptions 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: 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(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(f"{self._procfs_path}/{self.pid}/task") thread_ids.sort() retlist = [] hit_enoent = False for thread_id in thread_ids: fname = f"{self._procfs_path}/{self.pid}/task/{thread_id}/stat" try: with open_binary(fname) as f: st = f.read().strip() 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 :] values = st.split(b' ') utime = float(values[11]) / CLOCK_TICKS stime = float(values[12]) / CLOCK_TICKS ntuple = ntp.pthread(int(thread_id), utime, stime) retlist.append(ntuple) if hit_enoent: self._raise_if_not_alive() return retlist @wrap_exceptions def nice_get(self): # 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.proc_priority_get(self.pid) @wrap_exceptions def nice_set(self, value): return cext.proc_priority_set(self.pid, value) # starting from CentOS 6. if HAS_CPU_AFFINITY: @wrap_exceptions def cpu_affinity_get(self): return cext.proc_cpu_affinity_get(self.pid) def _get_eligible_cpus( self, _re=re.compile(br"Cpus_allowed_list:\t(\d+)-(\d+)") ): # See: https://github.com/giampaolo/psutil/issues/956 data = self._read_status_file() match = _re.findall(data) if match: return list(range(int(match[0][0]), int(match[0][1]) + 1)) else: return list(range(len(per_cpu_times()))) @wrap_exceptions def cpu_affinity_set(self, cpus): try: cext.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 HAS_PROC_IO_PRIORITY: @wrap_exceptions def ionice_get(self): ioclass, value = cext.proc_ioprio_get(self.pid) ioclass = ProcessIOPriority(ioclass) return ntp.pionice(ioclass, value) @wrap_exceptions def ionice_set(self, ioclass, value): if value is None: value = 0 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 cext.proc_ioprio_set(self.pid, ioclass, value) if hasattr(resource, "prlimit"): @wrap_exceptions 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: msg = "can't use prlimit() against PID 0 process" raise ValueError(msg) try: if limits is None: # get return resource.prlimit(self.pid, resource_) else: # set if len(limits) != 2: 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: # I saw this happening on Travis: # https://travis-ci.org/giampaolo/psutil/jobs/51368273 self._raise_if_zombie() raise @wrap_exceptions def status(self): 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(f"{self._procfs_path}/{self.pid}/fd") hit_enoent = False for fd in files: file = f"{self._procfs_path}/{self.pid}/fd/{fd}" try: path = readlink(file) except (FileNotFoundError, ProcessLookupError): # ENOENT == file which is gone in the meantime hit_enoent = True continue except OSError as err: if err.errno == errno.EINVAL: # not a link continue 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. # A regular file is always supposed to be have an # absolute path though. if path.startswith('/') and isfile_strict(path): # Get file position and flags. 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: self._raise_if_not_alive() return retlist @wrap_exceptions 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(f"{self._procfs_path}/{self.pid}/fd")) @wrap_exceptions def ppid(self): return int(self._parse_stat_file()['ppid']) @wrap_exceptions 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 ntp.puids(int(real), int(effective), int(saved)) @wrap_exceptions 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 ntp.pgids(int(real), int(effective), int(saved)) ================================================ FILE: psutil/_psosx.py ================================================ # 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 platform implementation.""" import errno import functools import os from . import _ntuples as ntp from . import _psposix from . import _psutil_osx as cext 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 usage_percent from ._enums import BatteryTime from ._enums import ConnectionStatus from ._enums import NicDuplex from ._enums import ProcessStatus __extra__all__ = [] # ===================================================================== # --- globals # ===================================================================== PAGESIZE = cext.getpagesize() AF_LINK = cext.AF_LINK TCP_STATUSES = { cext.TCPS_ESTABLISHED: ConnectionStatus.CONN_ESTABLISHED, cext.TCPS_SYN_SENT: ConnectionStatus.CONN_SYN_SENT, cext.TCPS_SYN_RECEIVED: ConnectionStatus.CONN_SYN_RECV, cext.TCPS_FIN_WAIT_1: ConnectionStatus.CONN_FIN_WAIT1, cext.TCPS_FIN_WAIT_2: ConnectionStatus.CONN_FIN_WAIT2, cext.TCPS_TIME_WAIT: ConnectionStatus.CONN_TIME_WAIT, cext.TCPS_CLOSED: ConnectionStatus.CONN_CLOSE, cext.TCPS_CLOSE_WAIT: ConnectionStatus.CONN_CLOSE_WAIT, cext.TCPS_LAST_ACK: ConnectionStatus.CONN_LAST_ACK, cext.TCPS_LISTEN: ConnectionStatus.CONN_LISTEN, cext.TCPS_CLOSING: ConnectionStatus.CONN_CLOSING, cext.PSUTIL_CONN_NONE: ConnectionStatus.CONN_NONE, } PROC_STATUSES = { cext.SIDL: ProcessStatus.STATUS_IDLE, cext.SRUN: ProcessStatus.STATUS_RUNNING, cext.SSLEEP: ProcessStatus.STATUS_SLEEPING, cext.SSTOP: ProcessStatus.STATUS_STOPPED, cext.SZOMB: ProcessStatus.STATUS_ZOMBIE, } # ===================================================================== # --- memory # ===================================================================== def virtual_memory(): """System virtual memory as a named tuple.""" d = cext.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.""" d = cext.swap_mem() d["percent"] = usage_percent(d["used"], d["total"], round_=1) return ntp.sswap(**d) # malloc / heap functions heap_info = cext.heap_info heap_trim = cext.heap_trim # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """Return system CPU times as a named tuple.""" user, nice, system, idle = cext.cpu_times() return ntp.scputimes(user, system, idle, nice) def per_cpu_times(): """Return system CPU times as a named tuple.""" ret = [] for cpu_t in cext.per_cpu_times(): user, nice, system, idle = cpu_t 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() def cpu_count_cores(): """Return the number of CPU cores in the system.""" return cext.cpu_count_cores() def cpu_stats(): ctx_switches, interrupts, soft_interrupts, syscalls, _traps = ( cext.cpu_stats() ) return ntp.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls) if cext.has_cpu_freq(): # not always available on ARM64 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. """ curr, min_, max_ = cext.cpu_freq() return [ntp.scpufreq(curr, min_, max_)] # ===================================================================== # --- disks # ===================================================================== disk_usage = _psposix.disk_usage disk_io_counters = cext.disk_io_counters def disk_partitions(all=False): """Return mounted disk partitions as a list of named tuples.""" retlist = [] partitions = cext.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 = ntp.sdiskpart(device, mountpoint, fstype, opts) retlist.append(ntuple) return retlist # ===================================================================== # --- sensors # ===================================================================== def sensors_battery(): """Return battery information.""" try: percent, minsleft, power_plugged = cext.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.net_if_addrs def net_connections(kind='inet'): """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).net_connections(kind) except NoSuchProcess: continue else: if cons: for c in cons: c = list(c) + [pid] ret.append(ntp.sconn(*c)) return ret def net_if_stats(): """Get NIC stats (isup, duplex, speed, mtu).""" names = net_io_counters().keys() ret = {} for name in names: try: mtu = cext.net_if_mtu(name) flags = cext.net_if_flags(name) duplex, speed = cext.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 # ===================================================================== # --- other system functions # ===================================================================== def boot_time(): """The system boot time expressed in seconds since the epoch.""" return cext.boot_time() try: INIT_BOOT_TIME = boot_time() except Exception as err: # noqa: BLE001 # Don't want to crash at import time. debug(f"ignoring exception 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() for item in rawlist: user, tty, hostname, tstamp, pid = item if tty == '~': continue # reboot or shutdown if not tstamp: continue nt = ntp.suser(user, tty or None, hostname or None, tstamp, pid) retlist.append(nt) return retlist # ===================================================================== # --- processes # ===================================================================== def pids(): ls = cext.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 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 cext.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 cext.ZombieProcessError as err: raise ZombieProcess(pid, name, ppid) from err return wrapper class Process: """Wrapper class around underlying C implementation.""" __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 cext.proc_oneshot_kinfo(self.pid) @wrap_exceptions @memoize_when_activated def _oneshot_pidtaskinfo(self): # Note: should work for PIDs owned by user only. return cext.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): name = self._oneshot_kinfo()["name"] return name if name is not None else cext.proc_name(self.pid) @wrap_exceptions def exe(self): return cext.proc_exe(self.pid) @wrap_exceptions def cmdline(self): return cext.proc_cmdline(self.pid) @wrap_exceptions def environ(self): return parse_environ_block(cext.proc_environ(self.pid)) @wrap_exceptions def ppid(self): self._ppid = self._oneshot_kinfo()["ppid"] return self._ppid @wrap_exceptions def cwd(self): return cext.proc_cwd(self.pid) @wrap_exceptions def uids(self): d = self._oneshot_kinfo() return ntp.puids(d["ruid"], d["euid"], d["suid"]) @wrap_exceptions def gids(self): d = self._oneshot_kinfo() return ntp.pgids(d["rgid"], d["egid"], d["sgid"]) @wrap_exceptions def terminal(self): tty_nr = self._oneshot_kinfo()["ttynr"] tmap = _psposix.get_terminal_map() try: return tmap[tty_nr] except KeyError: return None @wrap_exceptions def memory_info(self): d = self._oneshot_pidtaskinfo() return ntp.pmem(d["rss"], d["vms"]) @wrap_exceptions def memory_info_ex(self): return cext.proc_memory_info_ex(self.pid) @wrap_exceptions def memory_footprint(self): uss = cext.proc_memory_uss(self.pid) return ntp.pfootprint(uss) @wrap_exceptions def page_faults(self): d = self._oneshot_pidtaskinfo() return ntp.ppagefaults(d["minor_faults"], d["major_faults"]) @wrap_exceptions def cpu_times(self): 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, 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): # 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 self._oneshot_pidtaskinfo()["num_threads"] @wrap_exceptions def open_files(self): if self.pid == 0: return [] files = [] rawlist = cext.proc_open_files(self.pid) for path, fd in rawlist: if isfile_strict(path): ntuple = ntp.popenfile(path, fd) files.append(ntuple) return files @wrap_exceptions def net_connections(self, kind='inet'): families, types = conn_tmap[kind] rawlist = cext.proc_net_connections(self.pid, families, types) ret = [] for item in rawlist: fd, fam, type, laddr, raddr, status = item nt = conn_to_ntuple( fd, fam, type, laddr, raddr, status, TCP_STATUSES ) ret.append(nt) return ret @wrap_exceptions def num_fds(self): if self.pid == 0: return 0 return cext.proc_num_fds(self.pid) @wrap_exceptions def wait(self, timeout=None): return _psposix.wait_pid(self.pid, timeout) @wrap_exceptions def nice_get(self): return cext.proc_priority_get(self.pid) @wrap_exceptions def nice_set(self, value): return cext.proc_priority_set(self.pid, value) @wrap_exceptions def status(self): 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) retlist = [] for thread_id, utime, stime in rawlist: ntuple = ntp.pthread(thread_id, utime, stime) retlist.append(ntuple) return retlist ================================================ FILE: psutil/_psposix.py ================================================ # 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 posix systems.""" import enum import errno import functools import glob import os import select import signal import time from . import _ntuples as ntp from ._common import MACOS from ._common import TimeoutExpired from ._common import debug from ._common import usage_percent if MACOS: from . import _psutil_osx __all__ = ['pid_exists', 'wait_pid', 'disk_usage', 'get_terminal_map'] def pid_exists(pid): """Check whether pid exists in the current process table.""" if pid == 0: # According to "man 2 kill" PID 0 has a special meaning: # it refers to <> so we don't want to go any further. # If we get here it means this UNIX platform *does* have # a process with id 0. return True try: os.kill(pid, 0) 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 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 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 # Should never happen. msg = f"unknown process exit status {status!r}" raise ValueError(msg) 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). """ interval = 0.0001 max_interval = 0.04 flags = 0 stop_at = None if timeout is not None: flags |= os.WNOHANG if timeout != 0: stop_at = _timer() + timeout 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 = 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 flag was used and PID is still running. interval = sleep_or_timeout(interval) else: 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): """Return disk usage associated with path. Note: UNIX usually reserves 5% disk space which is not accessible by user. In this function "total" and "used" values reflect the total and used disk space whereas "free" and "percent" represent the "free" and "used percent" user disk space. """ st = os.statvfs(path) # Total space which is only available to root (unless changed # at system level). total = st.f_blocks * st.f_frsize # Remaining free space usable by root. avail_to_root = st.f_bfree * st.f_frsize # Remaining free space usable by user. avail_to_user = st.f_bavail * st.f_frsize # Total space being used in general. used = total - avail_to_root if MACOS: # see: https://github.com/giampaolo/psutil/pull/2152 used = _psutil_osx.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) # 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 ntp.sdiskusage( total=total, used=used, free=avail_to_user, percent=usage_percent_user ) @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 FileNotFoundError: pass return ret ================================================ FILE: psutil/_pssunos.py ================================================ # 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 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 _ntuples as ntp from . import _psposix from . import _psutil_sunos as cext 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 ._enums import ConnectionStatus from ._enums import NicDuplex from ._enums import ProcessStatus __extra__all__ = ["PROCFS_PATH"] # ===================================================================== # --- globals # ===================================================================== PAGE_SIZE = cext.getpagesize() AF_LINK = cext.AF_LINK IS_64_BIT = sys.maxsize > 2**32 PROC_STATUSES = { cext.SSLEEP: ProcessStatus.STATUS_SLEEPING, cext.SRUN: ProcessStatus.STATUS_RUNNING, cext.SZOMB: ProcessStatus.STATUS_ZOMBIE, cext.SSTOP: ProcessStatus.STATUS_STOPPED, cext.SIDL: ProcessStatus.STATUS_IDLE, cext.SONPROC: ProcessStatus.STATUS_RUNNING, # same as run cext.SWAIT: ProcessStatus.STATUS_WAITING, } TCP_STATUSES = { cext.TCPS_ESTABLISHED: ConnectionStatus.CONN_ESTABLISHED, cext.TCPS_SYN_SENT: ConnectionStatus.CONN_SYN_SENT, cext.TCPS_SYN_RCVD: ConnectionStatus.CONN_SYN_RECV, cext.TCPS_FIN_WAIT_1: ConnectionStatus.CONN_FIN_WAIT1, cext.TCPS_FIN_WAIT_2: ConnectionStatus.CONN_FIN_WAIT2, cext.TCPS_TIME_WAIT: ConnectionStatus.CONN_TIME_WAIT, cext.TCPS_CLOSED: ConnectionStatus.CONN_CLOSE, cext.TCPS_CLOSE_WAIT: ConnectionStatus.CONN_CLOSE_WAIT, cext.TCPS_LAST_ACK: ConnectionStatus.CONN_LAST_ACK, cext.TCPS_LISTEN: ConnectionStatus.CONN_LISTEN, cext.TCPS_CLOSING: ConnectionStatus.CONN_CLOSING, cext.PSUTIL_CONN_NONE: ConnectionStatus.CONN_NONE, cext.TCPS_IDLE: ConnectionStatus.CONN_IDLE, # sunos specific cext.TCPS_BOUND: ConnectionStatus.CONN_BOUND, # sunos specific } 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, ) # ===================================================================== # --- memory # ===================================================================== def virtual_memory(): """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 ntp.svmem(total, avail, percent, used, free) def swap_memory(): """Report swap memory metrics.""" sin, sout = cext.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 # ...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', 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: msg = f"'swap -l' failed (retcode={p.returncode})" raise RuntimeError(msg) lines = stdout.strip().split('\n')[1:] if not lines: msg = 'no swap device(s) configured' raise RuntimeError(msg) total = free = 0 for line in lines: line = line.split() 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 ntp.sswap( total, used, free, percent, sin * PAGE_SIZE, sout * PAGE_SIZE ) # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """Return system-wide CPU times as a named tuple.""" ret = cext.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 [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(): """Return the number of CPU cores in the system.""" return cext.cpu_count_cores() def cpu_stats(): """Return various CPU stats as a named tuple.""" ctx_switches, interrupts, syscalls, _traps = cext.cpu_stats() soft_interrupts = 0 return ntp.scpustats(ctx_switches, interrupts, soft_interrupts, syscalls) # ===================================================================== # --- disks # ===================================================================== disk_io_counters = cext.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 = cext.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. 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 = ntp.sdiskpart(device, mountpoint, fstype, opts) retlist.append(ntuple) return retlist # ===================================================================== # --- network # ===================================================================== net_io_counters = cext.net_io_counters net_if_addrs = cext.net_if_addrs 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). Only INET sockets are returned (UNIX are not). """ families, types = conn_tmap[kind] rawlist = cext.net_connections(_pid) ret = set() for item in rawlist: fd, fam, type_, laddr, raddr, status, pid = item if fam not in families: 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 = ntp.sconn(fd, fam, type_, laddr, raddr, status, pid) else: 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() for name, items in ret.items(): isup, duplex, speed, mtu = items duplex = NicDuplex(duplex) ret[name] = ntp.snicstats(isup, duplex, speed, mtu, '') return ret # ===================================================================== # --- other system functions # ===================================================================== def boot_time(): """The system boot time expressed in seconds since the epoch.""" return cext.boot_time() def users(): """Return currently connected users as a list of named tuples.""" retlist = [] rawlist = cext.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.""" 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) 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 except OSError as err: if pid == 0: if 0 in pids(): raise AccessDenied(pid, name) from err raise raise 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 _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 cext.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 = cext.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 cext.proc_cred(self.pid, self._procfs_path) @wrap_exceptions def name(self): # note: max len == 15 return self._proc_name_and_args()[0] @wrap_exceptions def exe(self): try: return os.readlink(f"{self._procfs_path}/{self.pid}/path/a.out") except OSError: 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. self.cmdline() return "" @wrap_exceptions def cmdline(self): return self._proc_name_and_args()[1] @wrap_exceptions def environ(self): return cext.proc_environ(self.pid, self._procfs_path) @wrap_exceptions def create_time(self): return self._oneshot()[proc_info_map['create_time']] @wrap_exceptions def num_threads(self): return self._oneshot()[proc_info_map['num_threads']] @wrap_exceptions def nice_get(self): # 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}: # 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.proc_priority_set(self.pid, value) @wrap_exceptions def ppid(self): self._ppid = self._oneshot()[proc_info_map['ppid']] return self._ppid @wrap_exceptions def uids(self): 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): 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.puids(real, effective, saved) @wrap_exceptions def cpu_times(self): try: times = cext.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 # with a 32bit python. # Error originates from read() and also tools like "cat" # fail in the same way (!). # Since there simply is no way to determine CPU times we # return 0.0 as a fallback. See: # https://github.com/giampaolo/psutil/issues/857 times = (0.0, 0.0, 0.0, 0.0) else: raise return ntp.pcputimes(*times) @wrap_exceptions def cpu_num(self): return cext.proc_cpu_num(self.pid, self._procfs_path) @wrap_exceptions def terminal(self): procfs_path = self._procfs_path hit_enoent = False tty = wrap_exceptions(self._oneshot()[proc_info_map['ttynr']]) if tty != cext.PRNODEV: for x in (0, 1, 2, 255): try: return os.readlink(f"{procfs_path}/{self.pid}/path/{x}") except FileNotFoundError: hit_enoent = True continue if hit_enoent: 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: https://groups.google.com/g/comp.unix.solaris/c/tcqvhTNFCAs procfs_path = self._procfs_path try: 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 = 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 = self._oneshot()[proc_info_map['status']] # XXX is '?' legit? (we're not supposed to return it anyway) return PROC_STATUSES.get(code, '?') @wrap_exceptions def threads(self): procfs_path = self._procfs_path ret = [] 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 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. # Error originates from read() and also tools like "cat" # fail in the same way (!). # Since there simply is no way to determine CPU times we # return 0.0 as a fallback. See: # https://github.com/giampaolo/psutil/issues/857 continue # ENOENT == thread gone in meantime if err.errno == errno.ENOENT: hit_enoent = True continue raise else: nt = ntp.pthread(tid, utime, stime) ret.append(nt) if hit_enoent: self._assert_alive() return ret @wrap_exceptions def open_files(self): retlist = [] hit_enoent = False procfs_path = self._procfs_path 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 FileNotFoundError: hit_enoent = True continue else: if isfile_strict(file): retlist.append(ntp.popenfile(file, int(fd))) if hit_enoent: 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", str(pid)] 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: 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) msg = f"{cmd!r} command error\n{stderr}" raise RuntimeError(msg) 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': type = socket.SOCK_STREAM elif type == 'SOCK_DGRAM': type = socket.SOCK_DGRAM else: type = -1 yield ( -1, socket.AF_UNIX, type, path, "", ConnectionStatus.CONN_NONE, ) @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}") # UNIX sockets 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') nt_mmap_ext = namedtuple('mmap', 'addr perms path rss anon locked') @wrap_exceptions def memory_maps(self): def toaddr(start, end): 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) 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. # Error originates from read() and also tools like "cat" # fail in the same way (!). # Since there simply is no way to determine CPU times we # return 0.0 as a fallback. See: # https://github.com/giampaolo/psutil/issues/857 return [] else: raise hit_enoent = False for item in rawlist: addr, addrsize, perm, name, rss, anon, locked = item addr = toaddr(addr, addrsize) if not name.startswith('['): try: 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 inconsistency with /proc similar # to: http://goo.gl/55XgO name = f"{procfs_path}/{self.pid}/path/{name}" hit_enoent = True else: raise retlist.append((addr, perm, name, rss, anon, locked)) if hit_enoent: self._assert_alive() return retlist @wrap_exceptions def num_fds(self): return len(os.listdir(f"{self._procfs_path}/{self.pid}/fd")) @wrap_exceptions def num_ctx_switches(self): return ntp.pctxsw( *cext.proc_num_ctx_switches(self.pid, self._procfs_path) ) @wrap_exceptions def page_faults(self): ret = cext.proc_page_faults(self.pid, self._procfs_path) return ntp.ppagefaults(*ret) @wrap_exceptions def wait(self, timeout=None): return _psposix.wait_pid(self.pid, timeout) ================================================ FILE: psutil/_psutil_aix.c ================================================ /* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "arch/all/init.h" #include "arch/aix/ifaddrs.h" #include "arch/aix/net_connections.h" #include "arch/aix/common.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; } /* * Return process ppid, rss, vms, ctime, nice, nthreads, status and tty * as a Python tuple. */ static 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//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 ); } /* * Return process name as a Python string. */ static 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 */ static 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; } /* * Return process environment variables as a Python dict */ static 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 /* * Retrieves all threads used by process returning a list of tuples * including thread id, user time and system time. */ static 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 #ifdef CURR_VERSION_PROCESS static 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 /* * 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[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. */ static 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 ); } /* * Return process voluntary and involuntary context switches as a Python tuple. */ static 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 context switches */ (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)"); } /* * 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 *mt = NULL; PyObject *py_dev = NULL; PyObject *py_mountp = NULL; PyObject *py_retlist = PyList_New(0); if (py_retlist == NULL) return NULL; file = setmntent(MNTTAB, "rb"); if (file == NULL) { psutil_oserror(); goto error; } mt = getmntent(file); while (mt != 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); mt = getmntent(file); } 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; } #if defined(CURR_VERSION_NETINTERFACE) && CURR_VERSION_NETINTERFACE >= 3 /* * Return a list of tuples for network I/O statistics. */ static 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_iqdrop s, // 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 static 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? 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; 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; } static 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); } /* * Return a Python list of tuple representing per-cpu times */ static 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; } /* * Return disk IO statistics. */ static 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; } /* * Return virtual memory usage statistics. */ static 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 ); } /* * Return stats about swap memory. */ static 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 ); } /* * Return CPU statistics. */ static 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; } /* * define the psutil C module methods and initialize the module. */ static PyMethodDef PsutilMethods[] = { // --- 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} }; struct module_state { PyObject *error; }; #define GETSTATE(m) ((struct module_state *)PyModule_GetState(m)) #ifdef __cplusplus extern "C" { #endif static int psutil_aix_traverse(PyObject *m, visitproc visit, void *arg) { Py_VISIT(GETSTATE(m)->error); return 0; } static int psutil_aix_clear(PyObject *m) { Py_CLEAR(GETSTATE(m)->error); return 0; } static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "psutil_aix", NULL, sizeof(struct module_state), PsutilMethods, NULL, psutil_aix_traverse, psutil_aix_clear, NULL }; PyMODINIT_FUNC PyInit__psutil_aix(void) { PyObject *mod = PyModule_Create(&moduledef); if (mod == NULL) return NULL; #ifdef Py_GIL_DISABLED if (PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED)) return NULL; #endif if (psutil_setup() != 0) return NULL; if (psutil_posix_add_constants(mod) != 0) return NULL; if (psutil_posix_add_methods(mod) != 0) return NULL; if (PyModule_AddIntConstant(mod, "version", PSUTIL_VERSION)) return NULL; if (PyModule_AddIntConstant(mod, "SIDL", SIDL)) return NULL; if (PyModule_AddIntConstant(mod, "SZOMB", SZOMB)) return NULL; if (PyModule_AddIntConstant(mod, "SACTIVE", SACTIVE)) return NULL; if (PyModule_AddIntConstant(mod, "SSWAP", SSWAP)) return NULL; if (PyModule_AddIntConstant(mod, "SSTOP", SSTOP)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_CLOSED", TCPS_CLOSED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_CLOSING", TCPS_CLOSING)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_LISTEN", TCPS_LISTEN)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_ESTABLISHED", TCPS_ESTABLISHED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_SYN_SENT", TCPS_SYN_SENT)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_SYN_RCVD", TCPS_SYN_RECEIVED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_LAST_ACK", TCPS_LAST_ACK)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_TIME_WAIT", TCPS_TIME_WAIT)) return NULL; if (PyModule_AddIntConstant(mod, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE)) return NULL; return mod; } #ifdef __cplusplus } #endif ================================================ FILE: psutil/_psutil_bsd.c ================================================ /* * 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: https://github.com/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() */ #include #include #include // BSD version #include // for TCP connection states #include "arch/all/init.h" #include "arch/bsd/init.h" #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 /* * define the psutil C module methods and initialize the module. */ static PyMethodDef mod_methods[] = { // --- per-process functions {"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_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_exe", psutil_proc_exe, 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_topology", psutil_cpu_topology, 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}, {NULL, NULL, 0, NULL} }; static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "_psutil_bsd", NULL, -1, mod_methods, NULL, NULL, NULL, NULL }; PyObject * PyInit__psutil_bsd(void) { PyObject *v; PyObject *mod = PyModule_Create(&moduledef); if (mod == NULL) return NULL; #ifdef Py_GIL_DISABLED if (PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED)) return NULL; #endif if (psutil_setup() != 0) return NULL; if (psutil_posix_add_constants(mod) != 0) return NULL; if (psutil_posix_add_methods(mod) != 0) return NULL; if (PyModule_AddIntConstant(mod, "version", PSUTIL_VERSION)) return NULL; // process status constants #ifdef PSUTIL_FREEBSD if (PyModule_AddIntConstant(mod, "SIDL", SIDL)) return NULL; if (PyModule_AddIntConstant(mod, "SRUN", SRUN)) return NULL; if (PyModule_AddIntConstant(mod, "SSLEEP", SSLEEP)) return NULL; if (PyModule_AddIntConstant(mod, "SSTOP", SSTOP)) return NULL; if (PyModule_AddIntConstant(mod, "SZOMB", SZOMB)) return NULL; if (PyModule_AddIntConstant(mod, "SWAIT", SWAIT)) return NULL; if (PyModule_AddIntConstant(mod, "SLOCK", SLOCK)) return NULL; #elif PSUTIL_OPENBSD if (PyModule_AddIntConstant(mod, "SIDL", SIDL)) return NULL; if (PyModule_AddIntConstant(mod, "SRUN", SRUN)) return NULL; if (PyModule_AddIntConstant(mod, "SSLEEP", SSLEEP)) return NULL; if (PyModule_AddIntConstant(mod, "SSTOP", SSTOP)) return NULL; if (PyModule_AddIntConstant(mod, "SZOMB", SZOMB)) return NULL; // unused if (PyModule_AddIntConstant(mod, "SDEAD", SDEAD)) return NULL; if (PyModule_AddIntConstant(mod, "SONPROC", SONPROC)) return NULL; #elif defined(PSUTIL_NETBSD) if (PyModule_AddIntConstant(mod, "SIDL", LSIDL)) return NULL; if (PyModule_AddIntConstant(mod, "SRUN", LSRUN)) return NULL; if (PyModule_AddIntConstant(mod, "SSLEEP", LSSLEEP)) return NULL; if (PyModule_AddIntConstant(mod, "SSTOP", LSSTOP)) return NULL; if (PyModule_AddIntConstant(mod, "SZOMB", LSZOMB)) return NULL; #if __NetBSD_Version__ < 500000000 if (PyModule_AddIntConstant(mod, "SDEAD", LSDEAD)) return NULL; #endif if (PyModule_AddIntConstant(mod, "SONPROC", LSONPROC)) return NULL; // unique to NetBSD if (PyModule_AddIntConstant(mod, "SSUSPENDED", LSSUSPENDED)) return NULL; #endif // connection status constants if (PyModule_AddIntConstant(mod, "TCPS_CLOSED", TCPS_CLOSED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_CLOSING", TCPS_CLOSING)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_LISTEN", TCPS_LISTEN)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_ESTABLISHED", TCPS_ESTABLISHED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_SYN_SENT", TCPS_SYN_SENT)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_SYN_RECEIVED", TCPS_SYN_RECEIVED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_LAST_ACK", TCPS_LAST_ACK)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_TIME_WAIT", TCPS_TIME_WAIT)) return NULL; if (PyModule_AddIntConstant(mod, "PSUTIL_CONN_NONE", 128)) return NULL; return mod; } ================================================ FILE: psutil/_psutil_linux.c ================================================ /* * 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. #ifndef _GNU_SOURCE #define _GNU_SOURCE 1 #endif #include #include // 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 #endif static PyMethodDef mod_methods[] = { // --- per-process functions {"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 // --- system related functions {"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} }; static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "_psutil_linux", NULL, -1, mod_methods, NULL, NULL, NULL, NULL }; PyObject * PyInit__psutil_linux(void) { PyObject *mod = PyModule_Create(&moduledef); if (mod == NULL) return NULL; #ifdef Py_GIL_DISABLED if (PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED)) return NULL; #endif if (psutil_setup() != 0) return NULL; if (psutil_posix_add_constants(mod) != 0) return NULL; if (psutil_posix_add_methods(mod) != 0) return NULL; if (PyModule_AddIntConstant(mod, "version", PSUTIL_VERSION)) return NULL; if (PyModule_AddIntConstant(mod, "DUPLEX_HALF", DUPLEX_HALF)) return NULL; if (PyModule_AddIntConstant(mod, "DUPLEX_FULL", DUPLEX_FULL)) return NULL; if (PyModule_AddIntConstant(mod, "DUPLEX_UNKNOWN", DUPLEX_UNKNOWN)) return NULL; return mod; } ================================================ FILE: psutil/_psutil_osx.c ================================================ /* * 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. */ // macOS platform-specific module methods. #include #include // needed for old macOS versions #include #include #include "arch/all/init.h" #include "arch/osx/init.h" static PyMethodDef mod_methods[] = { // --- per-process functions // 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_info_ex", psutil_proc_memory_info_ex, 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 {"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}, {"has_cpu_freq", psutil_has_cpu_freq, 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} }; static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "_psutil_osx", NULL, -1, mod_methods, NULL, NULL, NULL, NULL }; PyObject * PyInit__psutil_osx(void) { PyObject *mod = PyModule_Create(&moduledef); if (mod == NULL) return NULL; #ifdef Py_GIL_DISABLED if (PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED)) return NULL; #endif if (psutil_setup() != 0) return NULL; if (psutil_setup_osx() != 0) return NULL; if (psutil_posix_add_constants(mod) != 0) return NULL; if (psutil_posix_add_methods(mod) != 0) return NULL; if (PyModule_AddIntConstant(mod, "version", PSUTIL_VERSION)) return NULL; // process status constants, defined in: // http://fxr.watson.org/fxr/source/bsd/sys/proc.h?v=xnu-792.6.70#L149 if (PyModule_AddIntConstant(mod, "SIDL", SIDL)) return NULL; if (PyModule_AddIntConstant(mod, "SRUN", SRUN)) return NULL; if (PyModule_AddIntConstant(mod, "SSLEEP", SSLEEP)) return NULL; if (PyModule_AddIntConstant(mod, "SSTOP", SSTOP)) return NULL; if (PyModule_AddIntConstant(mod, "SZOMB", SZOMB)) return NULL; // connection status constants if (PyModule_AddIntConstant(mod, "TCPS_CLOSED", TCPS_CLOSED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_CLOSING", TCPS_CLOSING)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_LISTEN", TCPS_LISTEN)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_ESTABLISHED", TCPS_ESTABLISHED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_SYN_SENT", TCPS_SYN_SENT)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_SYN_RECEIVED", TCPS_SYN_RECEIVED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_LAST_ACK", TCPS_LAST_ACK)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_TIME_WAIT", TCPS_TIME_WAIT)) return NULL; if (PyModule_AddIntConstant(mod, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE)) return NULL; return mod; } ================================================ FILE: psutil/_psutil_sunos.c ================================================ /* * 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. * * Fix compilation issue on SunOS 5.10, see: * https://github.com/giampaolo/psutil/issues/421 * https://github.com/giampaolo/psutil/issues/1077 */ #define _STRUCTURED_PROC 1 #define NEW_MIB_COMPLIANT 1 #include #if !defined(_LP64) && _FILE_OFFSET_BITS == 64 #undef _FILE_OFFSET_BITS #undef _LARGEFILE64_SOURCE #endif #include #include #include "arch/all/init.h" static PyMethodDef mod_methods[] = { // --- process-related functions {"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 {"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; }; static struct PyModuleDef moduledef = { PyModuleDef_HEAD_INIT, "psutil_sunos", NULL, -1, mod_methods, NULL, NULL, NULL, NULL }; PyObject * PyInit__psutil_sunos(void) { PyObject *mod = PyModule_Create(&moduledef); if (mod == NULL) return NULL; #ifdef Py_GIL_DISABLED if (PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED)) return NULL; #endif if (psutil_setup() != 0) return NULL; if (psutil_posix_add_constants(mod) != 0) return NULL; if (psutil_posix_add_methods(mod) != 0) return NULL; if (PyModule_AddIntConstant(mod, "version", PSUTIL_VERSION)) return NULL; if (PyModule_AddIntConstant(mod, "SSLEEP", SSLEEP)) return NULL; if (PyModule_AddIntConstant(mod, "SRUN", SRUN)) return NULL; if (PyModule_AddIntConstant(mod, "SZOMB", SZOMB)) return NULL; if (PyModule_AddIntConstant(mod, "SSTOP", SSTOP)) return NULL; if (PyModule_AddIntConstant(mod, "SIDL", SIDL)) return NULL; if (PyModule_AddIntConstant(mod, "SONPROC", SONPROC)) return NULL; #ifdef SWAIT if (PyModule_AddIntConstant(mod, "SWAIT", SWAIT)) return NULL; #else /* sys/proc.h started defining SWAIT somewhere * after Update 3 and prior to Update 5 included. */ if (PyModule_AddIntConstant(mod, "SWAIT", 0)) return NULL; #endif // for process tty if (PyModule_AddIntConstant(mod, "PRNODEV", PRNODEV)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_CLOSED", TCPS_CLOSED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_CLOSING", TCPS_CLOSING)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_CLOSE_WAIT", TCPS_CLOSE_WAIT)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_LISTEN", TCPS_LISTEN)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_ESTABLISHED", TCPS_ESTABLISHED)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_SYN_SENT", TCPS_SYN_SENT)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_SYN_RCVD", TCPS_SYN_RCVD)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_FIN_WAIT_1", TCPS_FIN_WAIT_1)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_FIN_WAIT_2", TCPS_FIN_WAIT_2)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_LAST_ACK", TCPS_LAST_ACK)) return NULL; if (PyModule_AddIntConstant(mod, "TCPS_TIME_WAIT", TCPS_TIME_WAIT)) return NULL; // sunos specific if (PyModule_AddIntConstant(mod, "TCPS_IDLE", TCPS_IDLE)) return NULL; // sunos specific if (PyModule_AddIntConstant(mod, "TCPS_BOUND", TCPS_BOUND)) return NULL; if (PyModule_AddIntConstant(mod, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE)) return NULL; return mod; } ================================================ FILE: psutil/_psutil_windows.c ================================================ /* * 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. * * List of undocumented Windows NT APIs which are used in here and in * other modules: * - NtQuerySystemInformation * - NtQueryInformationProcess * - NtQueryObject * - NtSuspendProcess * - NtResumeProcess */ #include #include #include "arch/all/init.h" #include "arch/windows/init.h" #define GETSTATE(m) ((struct module_state *)PyModule_GetState(m)) // ------------------------ Python init --------------------------- static PyMethodDef PsutilMethods[] = { // --- per-process functions {"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_is_suspended", psutil_proc_is_suspended, 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_page_faults", psutil_proc_page_faults, 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_oneshot", psutil_proc_oneshot, METH_VARARGS}, // --- system-related functions {"uptime", psutil_uptime, 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_VARARGS}, {"init_loadavg_counter", (PyCFunction)psutil_init_loadavg_counter, METH_VARARGS}, {"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}, {"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}, // --- direct Windows APIs {"GetPerformanceInfo", psutil_GetPerformanceInfo, METH_VARARGS}, {"QueryDosDevice", psutil_QueryDosDevice, 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; }; 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 }; PyMODINIT_FUNC PyInit__psutil_windows(void) { PyObject *mod = PyModule_Create(&moduledef); if (mod == NULL) return NULL; #ifdef Py_GIL_DISABLED if (PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED)) return NULL; #endif if (psutil_setup() != 0) return NULL; if (psutil_setup_windows() != 0) return NULL; if (psutil_set_se_debug() != 0) return NULL; // Exceptions TimeoutExpired = PyErr_NewException( "_psutil_windows.TimeoutExpired", NULL, NULL ); if (TimeoutExpired == NULL) return NULL; if (PyModule_AddObject(mod, "TimeoutExpired", TimeoutExpired)) return NULL; TimeoutAbandoned = PyErr_NewException( "_psutil_windows.TimeoutAbandoned", NULL, NULL ); if (TimeoutAbandoned == NULL) return NULL; if (PyModule_AddObject(mod, "TimeoutAbandoned", TimeoutAbandoned)) return NULL; // version constant if (PyModule_AddIntConstant(mod, "version", PSUTIL_VERSION)) return NULL; // process status constants // http://msdn.microsoft.com/en-us/library/ms683211(v=vs.85).aspx if (PyModule_AddIntConstant( mod, "ABOVE_NORMAL_PRIORITY_CLASS", ABOVE_NORMAL_PRIORITY_CLASS )) return NULL; if (PyModule_AddIntConstant( mod, "BELOW_NORMAL_PRIORITY_CLASS", BELOW_NORMAL_PRIORITY_CLASS )) return NULL; if (PyModule_AddIntConstant( mod, "HIGH_PRIORITY_CLASS", HIGH_PRIORITY_CLASS )) return NULL; if (PyModule_AddIntConstant( mod, "IDLE_PRIORITY_CLASS", IDLE_PRIORITY_CLASS )) return NULL; if (PyModule_AddIntConstant( mod, "NORMAL_PRIORITY_CLASS", NORMAL_PRIORITY_CLASS )) return NULL; if (PyModule_AddIntConstant( mod, "REALTIME_PRIORITY_CLASS", REALTIME_PRIORITY_CLASS )) return NULL; // connection status constants // http://msdn.microsoft.com/en-us/library/cc669305.aspx if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_CLOSED", MIB_TCP_STATE_CLOSED )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_CLOSING", MIB_TCP_STATE_CLOSING )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_CLOSE_WAIT", MIB_TCP_STATE_CLOSE_WAIT )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_LISTEN", MIB_TCP_STATE_LISTEN )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_ESTAB", MIB_TCP_STATE_ESTAB )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_SYN_SENT", MIB_TCP_STATE_SYN_SENT )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_SYN_RCVD", MIB_TCP_STATE_SYN_RCVD )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_FIN_WAIT1", MIB_TCP_STATE_FIN_WAIT1 )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_FIN_WAIT2", MIB_TCP_STATE_FIN_WAIT2 )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_LAST_ACK", MIB_TCP_STATE_LAST_ACK )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_TIME_WAIT", MIB_TCP_STATE_TIME_WAIT )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_TIME_WAIT", MIB_TCP_STATE_TIME_WAIT )) return NULL; if (PyModule_AddIntConstant( mod, "MIB_TCP_STATE_DELETE_TCB", MIB_TCP_STATE_DELETE_TCB )) return NULL; if (PyModule_AddIntConstant(mod, "PSUTIL_CONN_NONE", PSUTIL_CONN_NONE)) return NULL; // ...for internal use in _psutil_windows.py if (PyModule_AddIntConstant(mod, "INFINITE", INFINITE)) return NULL; if (PyModule_AddIntConstant( mod, "ERROR_ACCESS_DENIED", ERROR_ACCESS_DENIED )) return NULL; if (PyModule_AddIntConstant(mod, "ERROR_INVALID_NAME", ERROR_INVALID_NAME)) return NULL; if (PyModule_AddIntConstant( mod, "ERROR_SERVICE_DOES_NOT_EXIST", ERROR_SERVICE_DOES_NOT_EXIST )) return NULL; if (PyModule_AddIntConstant( mod, "ERROR_PRIVILEGE_NOT_HELD", ERROR_PRIVILEGE_NOT_HELD )) return NULL; if (PyModule_AddIntConstant(mod, "WINVER", PSUTIL_WINVER)) return NULL; if (PyModule_AddIntConstant(mod, "WINDOWS_VISTA", PSUTIL_WINDOWS_VISTA)) return NULL; if (PyModule_AddIntConstant(mod, "WINDOWS_7", PSUTIL_WINDOWS_7)) return NULL; if (PyModule_AddIntConstant(mod, "WINDOWS_8", PSUTIL_WINDOWS_8)) return NULL; if (PyModule_AddIntConstant(mod, "WINDOWS_8_1", PSUTIL_WINDOWS_8_1)) return NULL; if (PyModule_AddIntConstant(mod, "WINDOWS_10", PSUTIL_WINDOWS_10)) return NULL; return mod; } ================================================ FILE: psutil/_pswindows.py ================================================ # 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 platform implementation.""" from __future__ import annotations import contextlib import enum import functools import os import signal import sys 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 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 usage_percent 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_windows as cext 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", "AF_LINK"] # ===================================================================== # --- globals # ===================================================================== ERROR_PARTIAL_COPY = 299 PYPY = '__pypy__' in sys.builtin_module_names AddressFamily = enum.IntEnum('AddressFamily', {'AF_LINK': -1}) AF_LINK = AddressFamily.AF_LINK TCP_STATUSES = { cext.MIB_TCP_STATE_ESTAB: ConnectionStatus.CONN_ESTABLISHED, cext.MIB_TCP_STATE_SYN_SENT: ConnectionStatus.CONN_SYN_SENT, cext.MIB_TCP_STATE_SYN_RCVD: ConnectionStatus.CONN_SYN_RECV, cext.MIB_TCP_STATE_FIN_WAIT1: ConnectionStatus.CONN_FIN_WAIT1, cext.MIB_TCP_STATE_FIN_WAIT2: ConnectionStatus.CONN_FIN_WAIT2, cext.MIB_TCP_STATE_TIME_WAIT: ConnectionStatus.CONN_TIME_WAIT, cext.MIB_TCP_STATE_CLOSED: ConnectionStatus.CONN_CLOSE, cext.MIB_TCP_STATE_CLOSE_WAIT: ConnectionStatus.CONN_CLOSE_WAIT, cext.MIB_TCP_STATE_LAST_ACK: ConnectionStatus.CONN_LAST_ACK, cext.MIB_TCP_STATE_LISTEN: ConnectionStatus.CONN_LISTEN, cext.MIB_TCP_STATE_CLOSING: ConnectionStatus.CONN_CLOSING, cext.MIB_TCP_STATE_DELETE_TCB: ConnectionStatus.CONN_DELETE_TCB, cext.PSUTIL_CONN_NONE: ConnectionStatus.CONN_NONE, } # ===================================================================== # --- utils # ===================================================================== @functools.lru_cache(maxsize=512) def convert_dos_path(s): 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]) 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 = cext.QueryDosDevice(rawdrive) remainder = s[len(rawdrive) :] return os.path.join(driveletter, remainder) @functools.lru_cache def getpagesize(): return cext.getpagesize() # ===================================================================== # --- memory # ===================================================================== def virtual_memory(): """System virtual memory as a named tuple.""" info = cext.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 ntp.svmem(total, avail, percent, used, free, cached, wired) def swap_memory(): """Swap system memory as a (total, used, free, sin, sout) tuple.""" info = cext.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 substract 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 = cext.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 = cext.heap_info heap_trim = cext.heap_trim # ===================================================================== # --- disk # ===================================================================== disk_io_counters = cext.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") total, used, free = cext.disk_usage(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 [ntp.sdiskpart(*x) for x in rawlist] # ===================================================================== # --- CPU # ===================================================================== def cpu_times(): """Return system CPU times as a named tuple.""" user, system, idle = cext.cpu_times() # Internally, GetSystemTimes() is used, and it doesn't return # interrupt and dpc times. cext.per_cpu_times() does, so we # rely on it to get those only. percpu_summed = ntp.scputimes( *[sum(n) for n in zip(*cext.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, irq, dpc in cext.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() def cpu_count_cores(): """Return the number of CPU cores in the system.""" return cext.cpu_count_cores() def cpu_stats(): """Return CPU statistics.""" ctx_switches, interrupts, _dpcs, syscalls = cext.cpu_stats() soft_interrupts = 0 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_ = cext.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 = cext.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: cext.init_loadavg_counter() _loadavg_initialized = True return _getloadavg_impl() # ===================================================================== # --- network # ===================================================================== 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 = cext.net_connections(_pid, families, types) ret = set() for item in rawlist: fd, fam, type, laddr, raddr, status, pid = item 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(): """Get NIC stats (isup, duplex, speed, mtu).""" ret = {} rawdict = cext.net_if_stats() for name, items in rawdict.items(): isup, duplex, speed, mtu = items duplex = NicDuplex(duplex) ret[name] = ntp.snicstats(isup, duplex, speed, mtu, '') return ret def net_io_counters(): """Return network I/O statistics for every network interface installed on the system as a dict of raw tuples. """ return cext.net_io_counters() def net_if_addrs(): """Return the addresses associated to each NIC.""" return cext.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 = cext.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) # ===================================================================== # --- other system functions # ===================================================================== _last_btime = 0 def boot_time(): """The system boot time expressed in seconds since the epoch. This also includes the time spent during hybernate / suspend. """ # This dirty hack is to adjust the precision of the returned # value which may have a 1 second fluctuation, see: # https://github.com/giampaolo/psutil/issues/1007 global _last_btime ret = time.time() - cext.uptime() if abs(ret - _last_btime) <= 1: return _last_btime else: _last_btime = ret return ret def users(): """Return currently connected users as a list of named tuples.""" retlist = [] rawlist = cext.users() for item in rawlist: user, hostname, tstamp = item nt = ntp.suser(user, None, hostname, tstamp, None) retlist.append(nt) return retlist # ===================================================================== # --- Windows services # ===================================================================== def win_service_iter(): """Yields a list of WindowsService instances.""" for name, display_name in cext.winservice_enumerate(): yield WindowsService(name, display_name) def win_service_get(name): """Open a Windows service and return it as a WindowsService instance.""" service = WindowsService(name, None) service._display_name = service._query_config()['display_name'] return service class WindowsService: # noqa: PLW1641 """Represents an installed Windows service.""" def __init__(self, name: str, display_name: str): self._name = name self._display_name = display_name def __str__(self): details = f"(name={self._name!r}, display_name={self._display_name!r})" return f"{self.__class__.__name__}{details}" def __repr__(self): return f"<{self.__str__()} at {id(self)}>" 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: 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) ) # XXX - update _self.display_name? return dict( display_name=display_name, binpath=binpath, username=username, start_type=start_type, ) def _query_status(self): with self._wrap_exceptions(): status, pid = cext.winservice_query_status(self._name) if pid == 0: pid = None return dict(status=status, pid=pid) @contextlib.contextmanager def _wrap_exceptions(self): """Ctx manager which translates bare OSError and WindowsError exceptions into NoSuchProcess and AccessDenied. """ try: yield 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 { cext.ERROR_INVALID_NAME, cext.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) -> 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) -> str: """The service display name. The value is cached when this class is instantiated. """ return self._display_name 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) -> str: """The name of the user that owns this service.""" return self._query_config()['username'] def start_type(self) -> str: """A string which can either be "automatic", "manual" or "disabled". """ return self._query_config()['start_type'] # status query 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) -> str: """Service status as a string.""" return self._query_status()['status'] def description(self) -> str: """Service long description.""" return cext.winservice_query_descr(self.name()) # utils def as_dict(self) -> dict[str, str | int | None]: """Utility method retrieving all the information above as a dictionary. """ d = self._query_config() d.update(self._query_status()) d['name'] = self.name() d['display_name'] = self.display_name() d['description'] = self.description() return d # actions # 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, # which sucks) # - would require adding ServiceAlreadyStarted and # ServiceAlreadyStopped exceptions, adding two new APIs. # - we might also want to have modify(), which would basically mean # rewriting win32serviceutil.ChangeServiceConfig, which involves a # lot of stuff (and API constants which would pollute the API), see: # http://pyxr.sourceforge.net/PyXR/c/python24/lib/site-packages/ # win32/lib/win32serviceutil.py.html#0175 # - psutil is typically about "read only" monitoring stuff; # win_service_* APIs should only be used to retrieve a service and # check whether it's running # def start(self, timeout=None): # with self._wrap_exceptions(): # cext.winservice_start(self.name()) # if timeout: # giveup_at = time.time() + timeout # while True: # if self.status() == "running": # return # else: # if time.time() > giveup_at: # raise TimeoutExpired(timeout) # else: # time.sleep(.1) # def stop(self): # # Note: timeout is not implemented because it's just not # # possible, see: # # http://stackoverflow.com/questions/11973228/ # with self._wrap_exceptions(): # return cext.winservice_stop(self.name()) # ===================================================================== # --- processes # ===================================================================== pids = cext.pids pid_exists = cext.pid_exists ppid_map = cext.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 { cext.ERROR_ACCESS_DENIED, cext.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 converts OSError into NoSuchProcess or AccessDenied.""" @functools.wraps(fun) def wrapper(self, *args, **kwargs): try: return fun(self, *args, **kwargs) except OSError as err: 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: """Wrapper class around underlying C implementation.""" __slots__ = ["_cache", "_name", "_ppid", "pid"] def __init__(self, pid): self.pid = pid self._name = None self._ppid = None # --- 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 cext.proc_oneshot(self.pid) def name(self): """Return process name, which on Windows is always the final part of the executable. """ # This is how PIDs 0 and 4 are always represented in taskmgr # and process-hacker. if self.pid == 0: return "System Idle Process" if self.pid == 4: return "System" return os.path.basename(self.exe()) @wrap_exceptions @memoize_when_activated def exe(self): if PYPY: try: exe = cext.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 = cext.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): if cext.WINVER >= cext.WINDOWS_8_1: # PEB method detects cmdline changes but requires more # privileges: https://github.com/giampaolo/psutil/pull/1398 try: return cext.proc_cmdline(self.pid, use_peb=True) except OSError as err: if is_permission_err(err): return cext.proc_cmdline(self.pid, use_peb=False) else: raise else: return cext.proc_cmdline(self.pid, use_peb=True) @wrap_exceptions @retry_error_partial_copy def environ(self): s = cext.proc_environ(self.pid) return parse_environ_block(s) def ppid(self): try: return ppid_map()[self.pid] except KeyError: raise NoSuchProcess(self.pid, self._name) from None def _get_raw_meminfo(self): try: return cext.proc_memory_info(self.pid) except OSError as err: if is_permission_err(err): # TODO: the C ext can probably be refactored in order # to get this from cext.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): # Underlying C function returns fields of PROCESS_MEMORY_COUNTERS # struct. 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_info_ex() "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_info_ex(self): d = self._oneshot() raw = self._get_raw_meminfo() return { "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 = cext.proc_memory_uss(self.pid) uss *= getpagesize() return ntp.pfootprint(uss) @wrap_exceptions def page_faults(self): t = cext.proc_page_faults(self.pid) return ntp.ppagefaults(*t) def memory_maps(self): try: raw = cext.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. raise convert_oserror(err, self.pid, self._name) from err else: for addr, perm, path, rss in raw: path = convert_dos_path(path) addr = hex(addr) yield (addr, perm, path, rss) @wrap_exceptions def kill(self): return cext.proc_kill(self.pid) @wrap_exceptions def send_signal(self, sig): if sig == signal.SIGTERM: cext.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 else: # WaitForSingleObject() expects time in milliseconds. cext_timeout = int(timeout * 1000) 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 = cext.proc_wait(self.pid, cext_timeout) except cext.TimeoutExpired as err: # WaitForSingleObject() returned WAIT_TIMEOUT. Just raise. raise TimeoutExpired(timeout, self.pid, self._name) from err except cext.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}: return 'NT AUTHORITY\\SYSTEM' domain, user = cext.proc_username(self.pid) return f"{domain}\\{user}" @wrap_exceptions 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: _user, _system, created = cext.proc_times(self.pid) return created except OSError as err: 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 self._oneshot()["num_threads"] @wrap_exceptions def threads(self): rawlist = cext.proc_threads(self.pid) retlist = [] for thread_id, utime, stime in rawlist: ntuple = ntp.pthread(thread_id, utime, stime) retlist.append(ntuple) return retlist @wrap_exceptions def cpu_times(self): try: user, system, _created = cext.proc_times(self.pid) except OSError as err: 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 ntp.pcputimes(user, system, 0.0, 0.0) @wrap_exceptions def suspend(self): cext.proc_suspend_or_resume(self.pid, True) @wrap_exceptions def resume(self): cext.proc_suspend_or_resume(self.pid, False) @wrap_exceptions @retry_error_partial_copy def cwd(self): 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 os.path.normpath(path) @wrap_exceptions def open_files(self): 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): ntuple = ntp.popenfile(file, -1) ret.add(ntuple) return list(ret) @wrap_exceptions 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) value = ProcessPriority(value) return value @wrap_exceptions def nice_set(self, value): return cext.proc_priority_set(self.pid, value) @wrap_exceptions def ionice_get(self): ret = cext.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 ProcessIOPriority: msg = f"{ioclass} is not a valid priority" raise ValueError(msg) cext.proc_io_priority_set(self.pid, ioclass) @wrap_exceptions def io_counters(self): try: ret = cext.proc_io_counters(self.pid) except OSError as err: if not is_permission_err(err): raise 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 ProcessStatus.STATUS_STOPPED else: return ProcessStatus.STATUS_RUNNING @wrap_exceptions def cpu_affinity_get(self): def from_bitmask(x): return [i for i in range(64) if (1 << i) & x] bitmask = cext.proc_cpu_affinity_get(self.pid) return from_bitmask(bitmask) @wrap_exceptions def cpu_affinity_set(self, value): def to_bitmask(ls): if not ls: msg = f"invalid argument {ls!r}" raise ValueError(msg) out = 0 for b in ls: out |= 2**b return out # SetProcessAffinityMask() states that ERROR_INVALID_PARAMETER # is returned for an invalid CPU but this seems not to be true, # therefore we check CPUs validy beforehand. allcpus = list(range(len(per_cpu_times()))) for cpu in value: if cpu not in allcpus: 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) @wrap_exceptions def num_handles(self): try: return cext.proc_num_handles(self.pid) except OSError as err: 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 = self._oneshot()["ctx_switches"] # only voluntary ctx switches are supported return ntp.pctxsw(ctx_switches, 0) ================================================ FILE: psutil/arch/aix/common.c ================================================ /* * 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 #include #include #include "../../arch/all/init.h" #include "common.h" /* psutil_kread() - read from kernel memory */ 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; if (lseek64(Kd, (off64_t)addr, L_SET) == (off64_t)-1) { psutil_oserror(); return 1; } br = read(Kd, buf, len); if (br == -1) { psutil_oserror(); return 1; } if (br != len) { psutil_runtime_error("size mismatch when reading kernel memory fd"); return 1; } return 0; } 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; while ((i = getprocs64( p, PROCSIZE, (struct fdsinfo64 *)NULL, 0, &pid, PROCINFO_INCR )) == PROCINFO_INCR) { 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; } ================================================ FILE: psutil/arch/aix/common.h ================================================ /* * 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. */ #ifndef __PSUTIL_AIX_COMMON_H__ #define __PSUTIL_AIX_COMMON_H__ #include #define PROCINFO_INCR (256) #define PROCSIZE (sizeof(struct procentry64)) #define FDSINFOSIZE (sizeof(struct fdsinfo64)) #define KMEM "/dev/kmem" typedef u_longlong_t KA_T; // psutil_kread() - read from kernel memory 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 ); struct procentry64 *psutil_read_process_table( int *num // out - number of processes read ); #endif // __PSUTIL_AIX_COMMON_H__ ================================================ FILE: psutil/arch/aix/ifaddrs.c ================================================ /* * 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 #include #include #include #include #include #include #include #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); } ================================================ FILE: psutil/arch/aix/ifaddrs.h ================================================ /* * 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 #include #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 ================================================ FILE: psutil/arch/aix/net_connections.c ================================================ /* * 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. */ /* Baded 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 #include #include #define _KERNEL #include #undef _KERNEL #include #include #include #include #include #include #include "../../arch/all/init.h" #include "net_kernel_structs.h" #include "net_connections.h" #include "common.h" #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; } ================================================ FILE: psutil/arch/aix/net_connections.h ================================================ /* * 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. */ #ifndef __NET_CONNECTIONS_H__ #define __NET_CONNECTIONS_H__ #include PyObject *psutil_net_connections(PyObject *self, PyObject *args); #endif // __NET_CONNECTIONS_H__ ================================================ FILE: psutil/arch/aix/net_kernel_structs.h ================================================ /* * 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 #include #include #include #include #include #include #include #include #include #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__ ================================================ FILE: psutil/arch/all/errors.c ================================================ /* * 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 #include #include #if defined(PSUTIL_WINDOWS) #include #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; str_format( msg, sizeof(msg), "%s (originated from %s)", strerror(errno), syscall ); exc = PyObject_CallFunction(PyExc_OSError, "(is)", errno, msg); PyErr_SetObject(PyExc_OSError, exc); Py_XDECREF(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); PyErr_SetObject(PyExc_OSError, exc); Py_XDECREF(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); PyErr_SetObject(PyExc_OSError, exc); Py_XDECREF(exc); return NULL; } // 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; } ================================================ FILE: psutil/arch/all/init.c ================================================ /* * 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 #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) { PyObject *value; int x; if (!PyArg_ParseTuple(args, "O", &value)) return NULL; x = PyObject_IsTrue(value); if (x < 0) { return NULL; } else if (x == 0) { PSUTIL_DEBUG = 0; } else { PSUTIL_DEBUG = 1; } 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; } ================================================ FILE: psutil/arch/all/init.h ================================================ /* * 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 // 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 // ==================================================================== // --- 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 neither sizeof(int), " "sizeof(long) or sizeof(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 neither sizeof(int), " "sizeof(long) or sizeof(long long)" #endif #endif // clang-format on // ==================================================================== // --- Internal utils // ==================================================================== // Print a debug message to stderr, including where it originated from // within the C code (file path + lineno). #define psutil_debug(...) \ do { \ if (!PSUTIL_DEBUG) \ break; \ fprintf(stderr, "psutil-debug [%s:%d]> ", __FILE__, __LINE__); \ fprintf(stderr, __VA_ARGS__); \ fprintf(stderr, "\n"); \ } while (0) 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, ...); 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); 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); ================================================ FILE: psutil/arch/all/pids.c ================================================ /* * 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 #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 DWORD 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 ================================================ FILE: psutil/arch/all/str.c ================================================ /* * 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 #include #include #include #include #include "init.h" static int _error(const char *msg) { if (PSUTIL_TESTING) { fprintf(stderr, "CRITICAL: %s\n", msg); fflush(stderr); exit(EXIT_FAILURE); // terminate execution } else { // Print debug msg because we never check str_*() return value. psutil_debug("%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 (size == 0) return _error("str_format: invalid arg 'size' = 0"); 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) { psutil_debug("str_format: error in format '%s'", fmt); buf[size - 1] = '\0'; return -1; } return ret; } // Safely copy `src` to `dst`, always null-terminating. Replaces unsafe // strcpy/strncpy. int str_copy(char *dst, size_t dst_size, const char *src) { if (dst_size == 0) return _error("str_copy: invalid arg 'dst_size' = 0"); #if defined(PSUTIL_WINDOWS) if (strcpy_s(dst, dst_size, src) != 0) return _error("str_copy: strcpy_s failed"); #else strncpy(dst, src, dst_size - 1); dst[dst_size - 1] = '\0'; #endif return 0; } // Safely append `src` to `dst`, always null-terminating. Returns 0 on // success, -1 on truncation. int str_append(char *dst, size_t dst_size, const char *src) { size_t dst_len; if (!dst || !src || dst_size == 0) return _error("str_append: invalid arg"); #if defined(PSUTIL_WINDOWS) dst_len = strnlen_s(dst, dst_size); if (dst_len >= dst_size - 1) return _error("str_append: destination full or truncated"); if (strcat_s(dst, dst_size, src) != 0) return _error("str_append: strcat_s failed"); #elif defined(PSUTIL_MACOS) || defined(PSUTIL_BSD) dst_len = strlcat(dst, src, dst_size); if (dst_len >= dst_size) return _error("str_append: truncated"); #else dst_len = strnlen(dst, dst_size); if (dst_len >= dst_size - 1) return _error("str_append: destination full or truncated"); strncat(dst, src, dst_size - dst_len - 1); dst[dst_size - 1] = '\0'; #endif return 0; } ================================================ FILE: psutil/arch/all/utils.c ================================================ #include #include #include // 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; } 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; } ================================================ FILE: psutil/arch/bsd/cpu.c ================================================ /* * 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 #include #include #include #include // 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); } PyObject * psutil_cpu_times(PyObject *self, PyObject *args) { #ifdef PSUTIL_NETBSD u_int64_t cpu_time[CPUSTATES]; #else long cpu_time[CPUSTATES]; #endif size_t size = sizeof(cpu_time); int ret; #if defined(PSUTIL_FREEBSD) || defined(PSUTIL_NETBSD) ret = psutil_sysctlbyname("kern.cp_time", &cpu_time, size); #elif PSUTIL_OPENBSD int mib[] = {CTL_KERN, KERN_CPTIME}; ret = psutil_sysctl(mib, 2, &cpu_time, size); #endif if (ret != 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 ); } ================================================ FILE: psutil/arch/bsd/disk.c ================================================ /* * 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 #if PSUTIL_NETBSD // getvfsstat() #include #include #else // getfsstat() #include #include #include #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; } ================================================ FILE: psutil/arch/bsd/heap.c ================================================ /* * 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 #include #if defined(PSUTIL_FREEBSD) #include #else #include #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 ================================================ FILE: psutil/arch/bsd/init.c ================================================ /* * 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 #include #include #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); } ================================================ FILE: psutil/arch/bsd/init.h ================================================ /* * 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 #include #define PSUTIL_KPT2DOUBLE(t) (t##_sec + t##_usec / 1000000.0) #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 ================================================ FILE: psutil/arch/bsd/mem.c ================================================ /* * 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 #include #include #include #include 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; } } #if defined(PSUTIL_NETBSD) // Get swap in/out struct uvmexp_sysctl uv; int mib[] = {CTL_VM, VM_UVMEXP2}; if (psutil_sysctl(mib, 2, &uv, sizeof(uv)) != 0) goto error; sin = (uint64_t)uv.pgswapin * pagesize; sout = (uint64_t)uv.pgswapout * pagesize; #endif 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 ================================================ FILE: psutil/arch/bsd/net.c ================================================ /* * 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 #include #include #include #include #include #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]; 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) != 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; } ================================================ FILE: psutil/arch/bsd/proc.c ================================================ /* * 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 #include #include #include #include #include #include #ifdef PSUTIL_FREEBSD #include #include #endif #include "../../arch/all/init.h" /* * 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; int oncpu; #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 // 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 // clang-format off #ifdef PSUTIL_FREEBSD if (!pydict_add(dict, "ppid", _Py_PARSE_PID, kp.ki_ppid)) goto error; if (!pydict_add(dict, "status", "i", (int)kp.ki_stat)) goto error; if (!pydict_add(dict, "real_uid", "l", (long)kp.ki_ruid)) goto error; if (!pydict_add(dict, "effective_uid", "l", (long)kp.ki_uid)) goto error; if (!pydict_add(dict, "saved_uid", "l", (long)kp.ki_svuid)) goto error; if (!pydict_add(dict, "real_gid", "l", (long)kp.ki_rgid)) goto error; if (!pydict_add(dict, "effective_gid", "l", (long)kp.ki_groups[0])) goto error; if (!pydict_add(dict, "saved_gid", "l", (long)kp.ki_svuid)) goto error; if (!pydict_add(dict, "ttynr", "L", (unsigned long long)kp.ki_tdev)) goto error; if (!pydict_add(dict, "create_time", "d", PSUTIL_TV2DOUBLE(kp.ki_start))) goto error; if (!pydict_add(dict, "ctx_switches_vol", "l", kp.ki_rusage.ru_nvcsw)) goto error; if (!pydict_add(dict, "ctx_switches_unvol", "l", kp.ki_rusage.ru_nivcsw)) goto error; if (!pydict_add(dict, "read_io_count", "l", kp.ki_rusage.ru_inblock)) goto error; if (!pydict_add(dict, "write_io_count", "l", kp.ki_rusage.ru_oublock)) goto error; if (!pydict_add(dict, "user_time", "d", PSUTIL_TV2DOUBLE(kp.ki_rusage.ru_utime))) goto error; if (!pydict_add(dict, "sys_time", "d", PSUTIL_TV2DOUBLE(kp.ki_rusage.ru_stime))) goto error; if (!pydict_add(dict, "ch_user_time", "d", PSUTIL_TV2DOUBLE(kp.ki_rusage_ch.ru_utime))) goto error; if (!pydict_add(dict, "ch_sys_time", "d", PSUTIL_TV2DOUBLE(kp.ki_rusage_ch.ru_stime))) goto error; if (!pydict_add(dict, "min_faults", "l", (long)kp.ki_rusage.ru_minflt)) goto error; if (!pydict_add(dict, "maj_faults", "l", (long)kp.ki_rusage.ru_majflt)) goto error; #else // OpenBSD / NetBSD if (!pydict_add(dict, "ppid", _Py_PARSE_PID, kp.p_ppid)) goto error; if (!pydict_add(dict, "status", "i", (int)kp.p_stat)) goto error; if (!pydict_add(dict, "real_uid", "l", (long)kp.p_ruid)) goto error; if (!pydict_add(dict, "effective_uid", "l", (long)kp.p_uid)) goto error; if (!pydict_add(dict, "saved_uid", "l", (long)kp.p_svuid)) goto error; if (!pydict_add(dict, "real_gid", "l", (long)kp.p_rgid)) goto error; if (!pydict_add(dict, "effective_gid", "l", (long)kp.p_groups[0])) goto error; if (!pydict_add(dict, "saved_gid", "l", (long)kp.p_svuid)) goto error; if (!pydict_add(dict, "ttynr", "i", (int)kp.p_tdev)) goto error; if (!pydict_add(dict, "create_time", "d", PSUTIL_KPT2DOUBLE(kp.p_ustart))) goto error; if (!pydict_add(dict, "ctx_switches_vol", "l", kp.p_uru_nvcsw)) goto error; if (!pydict_add(dict, "ctx_switches_unvol", "l", kp.p_uru_nivcsw)) goto error; if (!pydict_add(dict, "read_io_count", "l", kp.p_uru_inblock)) goto error; if (!pydict_add(dict, "write_io_count", "l", kp.p_uru_oublock)) goto error; if (!pydict_add(dict, "user_time", "d", PSUTIL_KPT2DOUBLE(kp.p_uutime))) goto error; if (!pydict_add(dict, "sys_time", "d", PSUTIL_KPT2DOUBLE(kp.p_ustime))) goto error; // OpenBSD and NetBSD provide children user + system times summed // together (no distinction). if (!pydict_add(dict, "ch_user_time", "d", kp.p_uctime_sec + kp.p_uctime_usec / 1000000.0)) goto error; if (!pydict_add(dict, "ch_sys_time", "d", kp.p_uctime_sec + kp.p_uctime_usec / 1000000.0)) goto error; if (!pydict_add(dict, "min_faults", "l", (long)kp.p_uru_minflt)) goto error; if (!pydict_add(dict, "maj_faults", "l", (long)kp.p_uru_majflt)) goto error; #endif // all BSDs 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; #else struct kinfo_proc *p; #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; } // 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. // On NetBSD, we cannot call kvm_getenvv2() for a zombie process. // To make unittest suite happy, return an empty environment. #if defined(PSUTIL_FREEBSD) if (!((p)->ki_flag & P_INMEM) || ((p)->ki_flag & P_SYSTEM)) { #elif defined(PSUTIL_NETBSD) if ((p)->p_stat == SZOMB) { #elif defined(PSUTIL_OPENBSD) if ((p)->p_flag & P_SYSTEM) { #endif kvm_close(kd); return py_retdict; } #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_FREEBSD) case ENOMEM: // Unfortunately, under FreeBSD kvm_getenvv() returns // failure for certain processes ( e.g. try // "sudo procstat -e ".) // 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; // XXX - it appears path is not exposed in the kinfo_file struct. path = ""; #elif PSUTIL_NETBSD regular = (kif->ki_ftype == DTYPE_VNODE) && (kif->ki_vtype == VREG); fd = kif->ki_fd; // XXX - it appears path is not exposed in the kinfo_file struct. 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; } ================================================ FILE: psutil/arch/bsd/proc_utils.c ================================================ /* * 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 #include #include #include #include #include #include #include #include #include #ifdef PSUTIL_FREEBSD #include #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; mib[1] = KERN_FILE; mib[2] = KERN_FILE_BYPID; mib[3] = pid; mib[4] = sizeof(struct kinfo_file); mib[5] = 0; 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; } #if defined(PSUTIL_FREEBSD) return kp.ki_stat == SZOMB; #elif defined(PSUTIL_OPENBSD) // According to /usr/include/sys/proc.h SZOMB is unused. // test_zombie_process() shows that SDEAD is the right // equivalent. return ((kp.p_stat == SZOMB) || (kp.p_stat == SDEAD)); #else return kp.p_stat == SZOMB; #endif } ================================================ FILE: psutil/arch/bsd/sys.c ================================================ /* * 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 #include #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); } ================================================ FILE: psutil/arch/freebsd/cpu.c ================================================ /* * 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 #include #include #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_topology(PyObject *self, PyObject *args) { char *topology = NULL; size_t size = 0; PyObject *py_str; if (psutil_sysctlbyname_malloc( "kern.sched.topology_spec", &topology, &size ) != 0) { psutil_debug("ignore sysctlbyname('kern.sched.topology_spec') error"); Py_RETURN_NONE; } py_str = PyUnicode_FromString(topology); free(topology); return py_str; } 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]; size_t size; 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, ¤t, 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)"); return Py_BuildValue("is", current, available_freq_levels); error: if (errno == ENOENT) PyErr_SetString(PyExc_NotImplementedError, "unable to read frequency"); else psutil_oserror(); return NULL; } ================================================ FILE: psutil/arch/freebsd/disk.c ================================================ /* * 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 #include #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; struct statinfo stats; PyObject *py_retdict = PyDict_New(); PyObject *py_disk_info = NULL; if (py_retdict == NULL) return NULL; if (devstat_checkversion(NULL) < 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)); if (devstat_getdevs(NULL, &stats) == -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; } ================================================ FILE: psutil/arch/freebsd/init.h ================================================ /* * 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 #include 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_cpu_topology(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); ================================================ FILE: psutil/arch/freebsd/mem.c ================================================ /* * 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 #include #include #include #include #include #include #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; } ================================================ FILE: psutil/arch/freebsd/pids.c ================================================ /* * 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 #include #include #include #include #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; } ================================================ FILE: psutil/arch/freebsd/proc.c ================================================ /* * 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 #include #include #include #include #include "../../arch/all/init.h" // ============================================================================ // Utility functions // ============================================================================ // 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 // ============================================================================ /* * Borrowed from psi Python System Information project * Based on code from ps. */ 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; } 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 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; } 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 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; } ================================================ FILE: psutil/arch/freebsd/proc_socks.c ================================================ /* * 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 #include #include #include // for struct xsocket #include #include #include // for xinpcb struct #include #include // for struct xtcpcb #include // for inet_ntop() #include #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; 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; PyObject *py_family = NULL; PyObject *py_type = 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 (!PySequence_Check(py_af_filter) || !PySequence_Check(py_type_filter)) { PyErr_SetString(PyExc_TypeError, "arg 2 or 3 is not a sequence"); 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]; int inseq; 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, #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; } ================================================ FILE: psutil/arch/freebsd/sensors.c ================================================ /* * 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 #include #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, ¤t, 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; } ================================================ FILE: psutil/arch/freebsd/sys_socks.c ================================================ /* * 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 #include #include #include #include // for struct xsocket #include #include #include #include // for xinpcb struct #include #include #include // for struct xtcpcb #include // 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, int include_v4, int include_v6, 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) && (include_v4 == 0)) continue; if ((inp->inp_vflag & INP_IPV6) && (include_v6 == 0)) 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; } static int psutil_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; } PyObject * psutil_net_connections(PyObject *self, PyObject *args) { int include_v4, include_v6, include_unix, include_tcp, include_udp, psutil_nxfiles; 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 (!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 ((include_v4 = psutil_int_in_seq(AF_INET, py_af_filter)) == -1) goto error; if ((include_v6 = psutil_int_in_seq(AF_INET6, py_af_filter)) == -1) goto error; if ((include_unix = psutil_int_in_seq(AF_UNIX, py_af_filter)) == -1) goto error; if ((include_tcp = psutil_int_in_seq(SOCK_STREAM, py_type_filter)) == -1) goto error; if ((include_udp = psutil_int_in_seq(SOCK_DGRAM, py_type_filter)) == -1) 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 (include_tcp == 1) { if (psutil_gather_inet( IPPROTO_TCP, include_v4, include_v6, py_retlist, psutil_xfiles, psutil_nxfiles ) != 0) { goto error_free_psutil_xfiles; } } // UDP if (include_udp == 1) { if (psutil_gather_inet( IPPROTO_UDP, include_v4, include_v6, py_retlist, psutil_xfiles, psutil_nxfiles ) != 0) { goto error_free_psutil_xfiles; } } // UNIX if (include_unix == 1) { 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; } ================================================ FILE: psutil/arch/linux/disk.c ================================================ /* * 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 #include // 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 = PyList_New(0); if (py_retlist == NULL) return NULL; if (!PyArg_ParseTuple(args, "s", &mtab_path)) 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; } while ((entry = getmntent(file))) { if (entry == NULL) { psutil_runtime_error("getmntent() syscall failed"); goto error; } 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; } ================================================ FILE: psutil/arch/linux/heap.c ================================================ /* * 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 #include #include // A copy of glibc's mallinfo2 layout. Allows compilation even if // 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 ================================================ FILE: psutil/arch/linux/init.h ================================================ /* * 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 #include // __NR_* #include // 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 ================================================ FILE: psutil/arch/linux/mem.c ================================================ /* * 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 #include #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 ); } ================================================ FILE: psutil/arch/linux/net.c ================================================ /* * 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 #include #include #include #include #include #include #include "../../arch/all/init.h" // see: https://github.com/giampaolo/psutil/issues/659 #ifdef PSUTIL_ETHTOOL_MISSING_TYPES #include 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 // * 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(ðcmd, 0, sizeof ethcmd); ethcmd.cmd = ETHTOOL_GSET; ifr.ifr_data = (void *)ðcmd; ret = ioctl(sock, SIOCETHTOOL, &ifr); 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(ðcmd); 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; } ================================================ FILE: psutil/arch/linux/proc.c ================================================ /* * 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 #include #include #include // ==================================================================== // --- 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 ================================================ FILE: psutil/arch/netbsd/cpu.c ================================================ /* * 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 #include #include #include #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}; 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_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; } ================================================ FILE: psutil/arch/netbsd/disk.c ================================================ /* * 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 #include #include #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; } ================================================ FILE: psutil/arch/netbsd/init.h ================================================ /* * 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 #include 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); ================================================ FILE: psutil/arch/netbsd/mem.c ================================================ /* * 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 #include #include #include #include #include #include "../../arch/all/init.h" // Virtual memory stats, taken from: // https://github.com/zabbix/zabbix/blob/master/src/libs/zbxsysinfo/netbsd/memory.c 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(); FILE *f; char line[256]; 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; // get buffers from /proc/meminfo buffers = 0; f = fopen("/proc/meminfo", "r"); if (f != NULL) { while (fgets(line, sizeof(line), f) != NULL) { if (strncmp(line, "Buffers:", 8) == 0) { sscanf(line + 8, "%llu", &buffers); break; } } fclose(f); buffers *= 1024; } 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; // Also in /proc/meminfo as MemShared shared = (unsigned long long)(vmdata.t_vmshr + vmdata.t_rmshr) * pagesize; // Note: zabbix does not include anonpages, but that doesn't match // the "Cached" value in /proc/meminfo. // https://github.com/zabbix/zabbix/blob/af5e0f8/src/libs/ // zbxsysinfo/netbsd/memory.c#L182 cached = (unsigned long long)(uv.filepages + uv.execpages + uv.anonpages) << uv.pageshift; // 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; } ================================================ FILE: psutil/arch/netbsd/pids.c ================================================ /* * 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 #include #include #include #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; } ================================================ FILE: psutil/arch/netbsd/proc.c ================================================ /* * 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. */ #include #include #include #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; } // 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, _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, NULL, &size, NULL, 0); if (error == -1) { psutil_oserror(); return NULL; } error = sysctl(mib, 4, pathname, &size, NULL, 0); if (error == -1) { psutil_oserror(); return NULL; } if (size == 0 || strlen(pathname) == 0) { ret = psutil_pid_exists(pid); if (ret == -1) return NULL; else if (ret == 0) return psutil_oserror_nsp("psutil_pid_exists -> 0"); else str_copy(pathname, sizeof(pathname), ""); } return PyUnicode_DecodeFSDefault(pathname); #else return Py_BuildValue("s", ""); #endif } */ 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 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 ); 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); 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); } ================================================ FILE: psutil/arch/netbsd/socks.c ================================================ /* * 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 #include #include #include #include #include #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; 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) { 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; } if (sysctl(mib, 6, buf + offset, &len, NULL, 0) == -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; memset(mib, 0, sizeof(mib)); if (sysctlnametomib(name, mib, &namelen) == -1) { psutil_oserror(); goto error; } if (sysctl(mib, __arraycount(mib), NULL, &len, NULL, 0) == -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); if (sysctl(mib, __arraycount(mib), pcb, &len, NULL, 0) == -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; } ================================================ FILE: psutil/arch/openbsd/cpu.c ================================================ /* * 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 #include #include // for CPUSTATES & CP_* #include "../../arch/all/init.h" 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); } ================================================ FILE: psutil/arch/openbsd/disk.c ================================================ /* * 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 #include #include #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; } ================================================ FILE: psutil/arch/openbsd/init.h ================================================ /* * 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 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); ================================================ FILE: psutil/arch/openbsd/mem.c ================================================ /* * 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 #include #include #include #include #include "../../arch/all/init.h" 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; 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; // Note: many programs calculate total memory as "uvmexp.npages * // pagesize" but this is incorrect and does not match "sysctl | // grep hw.physmem". 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; total = (unsigned long long)_total; free = (unsigned long long)uvmexp.free * pagesize; active = (unsigned long long)uvmexp.active * pagesize; inactive = (unsigned long long)uvmexp.inactive * pagesize; wired = (unsigned long long)uvmexp.wired * pagesize; shared = (unsigned long long)vmdata.t_vmshr + vmdata.t_rmshr; // this is how "top" determines cached mem cached = (unsigned long long)bcstats.numbufpages * 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", 0ULL) | 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; } ================================================ FILE: psutil/arch/openbsd/pids.c ================================================ /* * 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 #include #include #include #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; } ================================================ FILE: psutil/arch/openbsd/proc.c ================================================ /* * 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 #include #include #include #include #include #include #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; kd = kvm_openfiles(0, 0, 0, O_RDONLY, errbuf); 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"); kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf); if (!kd) { convert_kvm_err("kvm_openfiles()", errbuf); 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) 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); } ================================================ FILE: psutil/arch/openbsd/socks.c ================================================ /* * 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 #include #include #include #define _KERNEL // silence compiler warning #include // DTYPE_SOCKET #include // 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]; int inseq; 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; PyObject *py_family = NULL; PyObject *_type = 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 (!PySequence_Check(py_af_filter) || !PySequence_Check(py_type_filter)) { PyErr_SetString(PyExc_TypeError, "arg 2 or 3 is not a sequence"); goto error; } kd = kvm_openfiles(NULL, NULL, NULL, KVM_NO_FILES, errbuf); if (!kd) { convert_kvm_err("kvm_openfiles", errbuf); goto error; } ikf = kvm_getfiles(kd, KERN_FILE_BYPID, -1, sizeof(*ikf), &cnt); 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; 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)) { // 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; } ================================================ FILE: psutil/arch/openbsd/users.c ================================================ /* * 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 #include #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; 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 (fread(&ut, sizeof(ut), 1, fp) == 1) { 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; } ================================================ FILE: psutil/arch/osx/cpu.c ================================================ /* * 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 #include #include #include #include #include #include #include #if defined(__arm64__) || defined(__aarch64__) #include #include #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; } // Python wrapper: return True/False. PyObject * psutil_has_cpu_freq(PyObject *self, PyObject *args) { io_registry_entry_t entry = IO_OBJECT_NULL; int ok = psutil_find_pmgr_entry(&entry); if (entry != IO_OBJECT_NULL) IOObjectRelease(entry); if (ok) Py_RETURN_TRUE; Py_RETURN_FALSE; } PyObject * psutil_cpu_freq(PyObject *self, PyObject *args) { io_registry_entry_t entry = IO_OBJECT_NULL; CFTypeRef pCoreRef = NULL; CFTypeRef eCoreRef = NULL; size_t pCoreLength = 0; uint32_t pMin = 0, eMin = 0, min = 0, max = 0, curr = 0; if (!psutil_find_pmgr_entry(&entry)) { psutil_runtime_error("'pmgr' entry not found in AppleARMIODevice"); return NULL; } pCoreRef = IORegistryEntryCreateCFProperty( entry, CFSTR("voltage-states5-sram"), kCFAllocatorDefault, 0 ); eCoreRef = IORegistryEntryCreateCFProperty( entry, CFSTR("voltage-states1-sram"), kCFAllocatorDefault, 0 ); if (!pCoreRef || !eCoreRef || CFGetTypeID(pCoreRef) != CFDataGetTypeID() || CFGetTypeID(eCoreRef) != CFDataGetTypeID() || CFDataGetLength(pCoreRef) < 8 || CFDataGetLength(eCoreRef) < 4) { psutil_runtime_error("invalid CPU frequency data"); goto cleanup; } pCoreLength = CFDataGetLength(pCoreRef); CFDataGetBytes(pCoreRef, CFRangeMake(0, 4), (UInt8 *)&pMin); CFDataGetBytes(eCoreRef, CFRangeMake(0, 4), (UInt8 *)&eMin); CFDataGetBytes(pCoreRef, CFRangeMake(pCoreLength - 8, 4), (UInt8 *)&max); min = (pMin < eMin) ? pMin : eMin; curr = max; cleanup: if (pCoreRef) CFRelease(pCoreRef); if (eCoreRef) CFRelease(eCoreRef); if (entry != IO_OBJECT_NULL) IOObjectRelease(entry); return Py_BuildValue( "KKK", (unsigned long long)(curr / 1000 / 1000), (unsigned long long)(min / 1000 / 1000), (unsigned long long)(max / 1000 / 1000) ); } #else // not ARM64 / ARCH64 PyObject * psutil_has_cpu_freq(PyObject *self, PyObject *args) { Py_RETURN_TRUE; } 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; } ================================================ FILE: psutil/arch/osx/disk.c ================================================ /* * 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 #include #include #include #include #include #include #include #include #include "../../arch/all/init.h" /* * Return a list of tuples including device, mount point and fs type * for all partitions mounted on the system. */ 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; } /* * Return a Python dict of tuples for disk I/O information */ 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; PyObject *py_disk_info = NULL; PyObject *py_retdict = PyDict_New(); if (py_retdict == NULL) return NULL; if (IOServiceGetMatchingServices( kIOMasterPortDefault, IOServiceMatching(kIOMediaClass), &disk_list ) != kIOReturnSuccess) { psutil_runtime_error("unable to get the list of disks"); goto error; } while ((disk = IOIteratorNext(disk_list)) != 0) { py_disk_info = NULL; parent_dict = NULL; props_dict = NULL; stats_dict = NULL; parent = IO_OBJECT_NULL; if (IORegistryEntryGetParentEntry(disk, kIOServicePlane, &parent) != kIOReturnSuccess) { psutil_runtime_error("unable to get the disk's parent"); goto error; } if (!IOObjectConformsTo(parent, "IOBlockStorageDriver")) { IOObjectRelease(parent); IOObjectRelease(disk); continue; } if (IORegistryEntryCreateCFProperties( disk, (CFMutableDictionaryRef *)&parent_dict, kCFAllocatorDefault, kNilOptions ) != kIOReturnSuccess) { psutil_runtime_error("unable to get the parent's properties"); goto error; } if (IORegistryEntryCreateCFProperties( parent, (CFMutableDictionaryRef *)&props_dict, kCFAllocatorDefault, kNilOptions ) != 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; } const int kMaxDiskNameSize = 64; char disk_name[kMaxDiskNameSize]; if (!CFStringGetCString( disk_name_ref, disk_name, kMaxDiskNameSize, 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; } ================================================ FILE: psutil/arch/osx/heap.c ================================================ /* * 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 #include #include #include #include #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; } ================================================ FILE: psutil/arch/osx/init.c ================================================ /* * 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 #include #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; } ================================================ FILE: psutil/arch/osx/init.h ================================================ /* * 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 #include #include #include #include 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 ); int psutil_task_for_pid(pid_t pid, mach_port_t *task); 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_has_cpu_freq(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_info_ex(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); ================================================ FILE: psutil/arch/osx/mem.c ================================================ /* * 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 #include #include #include #include "../../arch/all/init.h" static int psutil_sys_vminfo(vm_statistics64_t vmstat) { kern_return_t ret; mach_msg_type_number_t count = HOST_VM_INFO64_COUNT; mach_port_t mport; 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)vmstat, &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; } 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; } /* * Return stats about swap memory. */ 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; } ================================================ FILE: psutil/arch/osx/net.c ================================================ /* * 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 #include #include #include #include #include #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) < sizeof(struct if_msghdr)) { psutil_debug("struct if_msghdr size mismatch (skip entry)"); break; } ifm = (struct if_msghdr *)next; if (ifm->ifm_msglen == 0 || next + ifm->ifm_msglen > lim) { psutil_debug("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_debug("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_debug("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; } ================================================ FILE: psutil/arch/osx/pids.c ================================================ /* * 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 #include #include #include #include #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; } ================================================ FILE: psutil/arch/osx/proc.c ================================================ /* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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; } /* * Return process name from kinfo_proc as a Python string. */ 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); } /* * Return process current working directory. * Raises NSP in case of zombie process. */ 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); } /* * Return path of the process executable. */ 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); } /* * Indicates 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); } /* * Return extended memory info via task_info(TASK_VM_INFO). */ PyObject * psutil_proc_memory_info_ex(PyObject *self, PyObject *args) { pid_t pid; mach_port_t task = MACH_PORT_NULL; kern_return_t kr; task_vm_info_data_t info; mach_msg_type_number_t info_count = TASK_VM_INFO_COUNT; PyObject *dict = PyDict_New(); if (!dict) return NULL; if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid)) goto error; if (psutil_task_for_pid(pid, &task) != 0) goto error; // Fetch multiple metrics. Fails with access denied for any PID not // owned by us. kr = task_info(task, TASK_VM_INFO, (task_info_t)&info, &info_count); mach_port_deallocate(mach_task_self(), task); task = MACH_PORT_NULL; if (kr != KERN_SUCCESS) { psutil_runtime_error("task_info(TASK_VM_INFO) syscall failed"); goto error; } // Fetch wired memory. uint64_t wired_size = 0; struct rusage_info_v0 ri; if (proc_pid_rusage(pid, RUSAGE_INFO_V0, (rusage_info_t *)&ri) == 0) wired_size = ri.ri_wired_size; else psutil_debug("proc_pid_rusage() failed (pid=%i)", pid); // clang-format off if (!pydict_add(dict, "peak_rss", "K", (unsigned long long)info.resident_size_peak)) goto error; if (!pydict_add(dict, "rss_anon", "K", (unsigned long long)info.internal)) goto error; if (!pydict_add(dict, "rss_file", "K", (unsigned long long)info.external)) goto error; if (!pydict_add(dict, "wired", "K", (unsigned long long)wired_size)) goto error; if (!pydict_add(dict, "compressed", "K", (unsigned long long)info.compressed)) goto error; if (!pydict_add(dict, "phys_footprint", "K", (unsigned long long)info.phys_footprint)) goto error; // clang-format on return dict; error: Py_DECREF(dict); return NULL; } /* * Returns the USS (unique set size) of the process. 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; mach_vm_size_t size = 0; mach_msg_type_number_t info_count; kern_return_t kr; long pagesize = psutil_getpagesize(); mach_vm_address_t addr; mach_port_t task = MACH_PORT_NULL; vm_region_top_info_data_t info; mach_port_t object_name; mach_vm_address_t prev_addr; if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid)) return NULL; if (psutil_task_for_pid(pid, &task) != 0) return NULL; if (psutil_sysctlbyname("sysctl.proc_cputype", &cpu_type, sizeof(cpu_type)) != 0) { mach_port_deallocate(mach_task_self(), task); 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 = MACH_VM_MIN_ADDRESS;; addr += size) { prev_addr = addr; info_count = VM_REGION_TOP_INFO_COUNT; // reset before each call object_name = MACH_PORT_NULL; kr = mach_vm_region( task, &addr, &size, VM_REGION_TOP_INFO, (vm_region_info_t)&info, &info_count, &object_name ); if (object_name != MACH_PORT_NULL) { mach_port_deallocate(mach_task_self(), object_name); object_name = MACH_PORT_NULL; } if (kr == KERN_INVALID_ADDRESS) { // Done iterating VM regions. break; } else if (kr != KERN_SUCCESS) { psutil_runtime_error( "mach_vm_region(VM_REGION_TOP_INFO) syscall failed" ); mach_port_deallocate(mach_task_self(), task); return NULL; } if (size == 0 || addr < prev_addr) { psutil_debug("prevent infinite loop"); break; } 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); return Py_BuildValue("K", private_pages * pagesize); } /* * Return process threads */ PyObject * psutil_proc_threads(PyObject *self, PyObject *args) { pid_t pid; kern_return_t kr; 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, j; PyObject *py_retlist = PyList_New(0); if (py_retlist == NULL) return NULL; if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid)) goto error; if (psutil_task_for_pid(pid, &task) != 0) goto error; // Get basic task info (optional, ignored if access denied) mach_msg_type_number_t info_count = TASK_BASIC_INFO_COUNT; kr = task_info( task, TASK_BASIC_INFO, (task_info_t)&tasks_info, &info_count ); if (kr != KERN_SUCCESS) { if (kr == KERN_INVALID_ARGUMENT) { psutil_oserror_ad("task_info(TASK_BASIC_INFO)"); } else { // otherwise throw a runtime error with appropriate error code psutil_runtime_error("task_info(TASK_BASIC_INFO) syscall failed"); } goto error; } kr = task_threads(task, &thread_list, &thread_count); if (kr != KERN_SUCCESS) { psutil_runtime_error("task_threads() syscall failed"); goto error; } for (j = 0; j < thread_count; j++) { 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) { psutil_runtime_error( "thread_info(THREAD_BASIC_INFO) syscall failed" ); goto error; } basic_info_th = (thread_basic_info_t)thinfo_basic; if (!pylist_append_fmt( py_retlist, "Iff", j + 1, basic_info_th->user_time.seconds + (float)basic_info_th->user_time.microseconds / 1000000.0, basic_info_th->system_time.seconds + (float)basic_info_th->system_time.microseconds / 1000000.0 )) { goto error; } } // deallocate thread_list if it was allocated if (thread_list != NULL) { vm_deallocate( mach_task_self(), (vm_address_t)thread_list, thread_count * sizeof(thread_act_t) ); thread_list = NULL; } // deallocate the task port if (task != MACH_PORT_NULL) { mach_port_deallocate(mach_task_self(), task); task = MACH_PORT_NULL; } return py_retlist; error: Py_XDECREF(py_retlist); if (thread_list != NULL) { vm_deallocate( mach_task_self(), (vm_address_t)thread_list, thread_count * sizeof(thread_act_t) ); thread_list = NULL; } if (task != MACH_PORT_NULL) { mach_port_deallocate(mach_task_self(), task); task = MACH_PORT_NULL; } 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. * Raises NSP in case of zombie process. * 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; 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 (!PySequence_Check(py_af_filter) || !PySequence_Check(py_type_filter)) { PyErr_SetString(PyExc_TypeError, "arg 2 or 3 is not a sequence"); 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]; 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 == -1) goto error; if (inseq == 0) continue; py_type = PyLong_FromLong((long)type); inseq = PySequence_Contains(py_type_filter, py_type); Py_DECREF(py_type); if (inseq == -1) goto error; if (inseq == 0) 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); } // return process args as a python list 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; } ================================================ FILE: psutil/arch/osx/proc_utils.c ================================================ /* * 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 #include #include #include #include #include #include #include #include #include #include #include #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 0; } 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 task_for_pid() which sucks big time: * - it's not documented * - errno is set only sometimes * - sometimes errno is ENOENT (?!?) * - for PIDs != getpid() or PIDs which are not members of the procmod * it requires root * As such we can only guess what the heck went wrong and fail either * with NoSuchProcess or give up with AccessDenied. * References: * https://github.com/giampaolo/psutil/issues/1181 * https://github.com/giampaolo/psutil/issues/1209 * https://github.com/giampaolo/psutil/issues/1291#issuecomment-396062519 */ int psutil_task_for_pid(pid_t pid, mach_port_t *task) { kern_return_t err; if (pid < 0 || !task) return psutil_badargs("psutil_task_for_pid"); err = task_for_pid(mach_task_self(), pid, task); if (err != KERN_SUCCESS) { if (psutil_pid_exists(pid) == 0) { psutil_oserror_nsp("task_for_pid"); } else if (is_zombie(pid) == 1) { PyErr_SetString( ZombieProcessError, "task_for_pid -> psutil_is_zombie -> 1" ); } else { psutil_debug( "task_for_pid() failed (pid=%ld, err=%i, errno=%i, msg='%s'); " "setting EACCES", (long)pid, err, errno, mach_error_string(err) ); psutil_oserror_ad("task_for_pid"); } 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; } ================================================ FILE: psutil/arch/osx/sensors.c ================================================ /* * 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 #include #include #include #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; power_info = IOPSCopyPowerSourcesInfo(); if (!power_info) { psutil_runtime_error("IOPSCopyPowerSourcesInfo() syscall failed"); goto error; } power_sources_list = IOPSCopyPowerSourcesList(power_info); 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; } ================================================ FILE: psutil/arch/osx/sys.c ================================================ /* * 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 #include #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); } ================================================ FILE: psutil/arch/posix/init.c ================================================ /* * 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 #include #include #include "init.h" PyObject *ZombieProcessError = NULL; /* * From "man getpagesize" on Linux, https://linux.die.net/man/2/getpagesize: * * > 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; } } // custom exception ZombieProcessError = PyErr_NewException( "_psutil_posix.ZombieProcessError", NULL, NULL ); if (ZombieProcessError == NULL) return -1; if (PyModule_AddObject(mod, "ZombieProcessError", ZombieProcessError)) 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) if (PyModule_AddIntConstant(mod, "AF_LINK", AF_LINK)) return -1; #endif #if defined(PSUTIL_LINUX) || defined(PSUTIL_FREEBSD) PyObject *v; #ifdef RLIMIT_AS if (PyModule_AddIntConstant(mod, "RLIMIT_AS", RLIMIT_AS)) return -1; #endif #ifdef RLIMIT_CORE if (PyModule_AddIntConstant(mod, "RLIMIT_CORE", RLIMIT_CORE)) return -1; #endif #ifdef RLIMIT_CPU if (PyModule_AddIntConstant(mod, "RLIMIT_CPU", RLIMIT_CPU)) return -1; #endif #ifdef RLIMIT_DATA if (PyModule_AddIntConstant(mod, "RLIMIT_DATA", RLIMIT_DATA)) return -1; #endif #ifdef RLIMIT_FSIZE if (PyModule_AddIntConstant(mod, "RLIMIT_FSIZE", RLIMIT_FSIZE)) return -1; #endif #ifdef RLIMIT_MEMLOCK if (PyModule_AddIntConstant(mod, "RLIMIT_MEMLOCK", RLIMIT_MEMLOCK)) return -1; #endif #ifdef RLIMIT_NOFILE if (PyModule_AddIntConstant(mod, "RLIMIT_NOFILE", RLIMIT_NOFILE)) return -1; #endif #ifdef RLIMIT_NPROC if (PyModule_AddIntConstant(mod, "RLIMIT_NPROC", RLIMIT_NPROC)) return -1; #endif #ifdef RLIMIT_RSS if (PyModule_AddIntConstant(mod, "RLIMIT_RSS", RLIMIT_RSS)) return -1; #endif #ifdef RLIMIT_STACK if (PyModule_AddIntConstant(mod, "RLIMIT_STACK", RLIMIT_STACK)) return -1; #endif // Linux specific #ifdef RLIMIT_LOCKS if (PyModule_AddIntConstant(mod, "RLIMIT_LOCKS", RLIMIT_LOCKS)) return -1; #endif #ifdef RLIMIT_MSGQUEUE if (PyModule_AddIntConstant(mod, "RLIMIT_MSGQUEUE", RLIMIT_MSGQUEUE)) return -1; #endif #ifdef RLIMIT_NICE if (PyModule_AddIntConstant(mod, "RLIMIT_NICE", RLIMIT_NICE)) return -1; #endif #ifdef RLIMIT_RTPRIO if (PyModule_AddIntConstant(mod, "RLIMIT_RTPRIO", RLIMIT_RTPRIO)) return -1; #endif #ifdef RLIMIT_RTTIME if (PyModule_AddIntConstant(mod, "RLIMIT_RTTIME", RLIMIT_RTTIME)) return -1; #endif #ifdef RLIMIT_SIGPENDING if (PyModule_AddIntConstant(mod, "RLIMIT_SIGPENDING", RLIMIT_SIGPENDING)) return -1; #endif // Free specific #ifdef RLIMIT_SWAP if (PyModule_AddIntConstant(mod, "RLIMIT_SWAP", RLIMIT_SWAP)) return -1; #endif #ifdef RLIMIT_SBSIZE if (PyModule_AddIntConstant(mod, "RLIMIT_SBSIZE", RLIMIT_SBSIZE)) return -1; #endif #ifdef RLIMIT_NPTS if (PyModule_AddIntConstant(mod, "RLIMIT_NPTS", RLIMIT_NPTS)) return -1; #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; } ================================================ FILE: psutil/arch/posix/init.h ================================================ /* * 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 #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); int psutil_sysctlbyname_malloc(const char *name, char **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 ================================================ FILE: psutil/arch/posix/net.c ================================================ /* * 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 #include #include #include #include #include #include #include #ifdef PSUTIL_AIX #include "arch/aix/ifaddrs.h" #else #include #endif #if defined(PSUTIL_LINUX) #include #include #include #endif #if defined(PSUTIL_BSD) || defined(PSUTIL_OSX) #include #include #include #include #include #include #endif #if defined(PSUTIL_SUNOS) #include #include #endif #if defined(PSUTIL_AIX) #include #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; 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; if (getifaddrs(&ifaddr) == -1) { psutil_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; 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); } 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); ret = ioctl(sock, SIOCGIFMTU, &ifr); 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); ret = ioctl(sock, SIOCGIFFLAGS, &ifr); 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); ret = ioctl(sock, SIOCGIFFLAGS, &ifr); 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); 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); return Py_BuildValue("[ii]", duplex, speed); } #endif // PSUTIL_HAS_NET_IF_DUPLEX_SPEED ================================================ FILE: psutil/arch/posix/pids.c ================================================ /* * 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 #include #include #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; } ================================================ FILE: psutil/arch/posix/proc.c ================================================ /* * 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 #include #include #include #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; } ================================================ FILE: psutil/arch/posix/sysctl.c ================================================ /* * 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 #include #include 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"); // First query to determine required size ret = sysctl(mib, miblen, NULL, &needed, NULL, 0); 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; ret = sysctl(mib, miblen, buffer, &len, NULL, 0); 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 if (sysctl(mib, miblen, NULL, &needed, NULL, 0) == -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; } // Allocate buffer for sysctlbyname with retry on ENOMEM or size mismatch. // The caller is responsible for freeing the memory. int psutil_sysctlbyname_malloc(const char *name, char **buf, size_t *buflen) { int ret; int max_retries = MAX_RETRIES; size_t needed = 0; size_t len = 0; char *buffer = NULL; char errbuf[256]; if (!name || !buf || !buflen) return psutil_badargs("psutil_sysctlbyname_malloc"); // First query to determine required size. ret = sysctlbyname(name, NULL, &needed, NULL, 0); if (ret == -1) { str_format( errbuf, sizeof(errbuf), "sysctlbyname('%s') malloc 1/3", name ); psutil_oserror_wsyscall(errbuf); return -1; } if (needed == 0) { psutil_debug("psutil_sysctlbyname_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; } len = needed; ret = sysctlbyname(name, buffer, &len, NULL, 0); if (ret == 0) { // Success: return buffer and actual length. *buf = buffer; *buflen = len; return 0; } // Handle buffer too small. Re-query and retry. if (errno == ENOMEM) { free(buffer); buffer = NULL; if (sysctlbyname(name, NULL, &needed, NULL, 0) == -1) { str_format( errbuf, sizeof(errbuf), "sysctlbyname('%s') malloc 2/3", name ); psutil_oserror_wsyscall(errbuf); return -1; } psutil_debug("psutil_sysctlbyname_malloc() retry"); continue; } // Other errors: clean up and give up. free(buffer); str_format( errbuf, sizeof(errbuf), "sysctlbyname('%s') malloc 3/3", name ); psutil_oserror_wsyscall(errbuf); return -1; } str_format( errbuf, sizeof(errbuf), "sysctlbyname('%s') buffer allocation retry limit exceeded", name ); psutil_runtime_error(errbuf); return -1; } #endif // PSUTIL_HAS_SYSCTLBYNAME #endif // PSUTIL_HAS_SYSCTL ================================================ FILE: psutil/arch/posix/users.c ================================================ /* * 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 #include #include 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. char hostbuf[sizeof(ut->ut_host)]; 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 ================================================ FILE: psutil/arch/sunos/cpu.c ================================================ /* * 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 #include #include #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; kc = kstat_open(); 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; 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 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; kc = kstat_open(); 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; } ================================================ FILE: psutil/arch/sunos/disk.c ================================================ /* * 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 #include #include #include #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; kc = kstat_open(); 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) { kstat_close(kc); return psutil_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_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; file = fopen(MNTTAB, "rb"); if (file == NULL) { psutil_oserror(); goto error; } 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; } ================================================ FILE: psutil/arch/sunos/environ.c ================================================ /* * 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. * * Functions specific for Process.environ(). */ #define _STRUCTURED_PROC 1 #include #include #include #include #include #include #include "../../arch/all/init.h" #define STRING_SEARCH_BUF_SIZE 512 /* * Open address space of specified process and return file descriptor. * @param pid a pid of process. * @param procfs_path a path to mounted procfs filesystem. * @return file descriptor or -1 in case of error. */ 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); fd = open(proc_path, O_RDONLY); if (fd < 0) psutil_oserror(); return fd; } /* * Read chunk of data by offset to specified buffer of the same size. * @param fd a file descriptor. * @param offset an required offset in file. * @param buf a buffer where to store result. * @param buf_size a size of buffer where data will be stored. * @return amount of bytes stored to the buffer or -1 in case of * 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) { r = pread(fd, buf + stored, to_read, offset + stored); 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. * @param fd a file descriptor of opened address space. * @param offset an offset in specified file descriptor. * @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; size_t len; char buf[STRING_SEARCH_BUF_SIZE]; char *result = NULL; if (lseek(fd, offset, SEEK_SET) == (off_t)-1) { psutil_oserror(); goto error; } // Search end of string for (;;) { r = read(fd, buf, sizeof(buf)); 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. * @param fd a file descriptor of address space of interesting process. * @param offset an offset of address block in address space. * @param ptr_size a size of pointer. Only 4 or 8 are valid values. * @param count amount of pointers in block. * @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. * @param info a pointer to process info (psinfo_t) structure of the * interesting process. * @return 1 in case if caller process can extract proper values from * psinfo_t structure, or 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 * @param info a pointer to process info (psinfo_t) structure of the * interesting process. * @return 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. * @param fd a descriptor of /proc/PID/as special file. * @param offt an offset of block of pointers at the file. * @param ptr_size a pointer size (allowed values: {4, 8}). * @return amount of non-NULL pointers or -1 in case of 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. * @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. * @return allocated array of cstrings or NULL in case of 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 clean 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. * @param array an array of cstrings returned by psutil_read_raw_env, * psutil_read_raw_args or any other function. * @param count a count of strings in the passed array */ 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); } ================================================ FILE: psutil/arch/sunos/init.h ================================================ /* * 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 #include #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); ================================================ FILE: psutil/arch/sunos/mem.c ================================================ /* * 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 #include #include #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; kc = kstat_open(); 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); } ================================================ FILE: psutil/arch/sunos/net.c ================================================ /* * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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; kc = kstat_open(); 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); 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)) { 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; kc = kstat_open(); 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); 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_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 * ...and: * 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; sd = open("/dev/arp", O_RDWR); if (sd == -1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, "/dev/arp"); goto error; } ret = ioctl(sd, I_PUSH, "tcp"); if (ret == -1) { psutil_oserror(); goto error; } ret = ioctl(sd, I_PUSH, "udp"); 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 if (putmsg(sd, &ctlbuf, (struct strbuf *)0, flags) == -1) { psutil_oserror(); goto error; } ctlbuf.maxlen = sizeof(buf); for (;;) { flags = 0; getcode = getmsg(sd, &ctlbuf, (struct strbuf *)0, &flags); 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; getcode = getmsg(sd, (struct strbuf *)0, &databuf, &flags); 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; } ================================================ FILE: psutil/arch/sunos/proc.c ================================================ /* * 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 #include #include #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; 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); 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; } /* * 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[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, // 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; } /* * Return process environ block. */ 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 = PyDict_New(); if (!py_retdict) return PyErr_NoMemory(); 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))) 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_envname) 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; } /* * Return process user and system CPU times as a Python tuple. */ 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); fd = open(path, O_RDONLY); if (fd == -1) { PyErr_SetFromErrnoWithFilename(PyExc_OSError, path); return NULL; } // read header nbytes = pread(fd, &header, sizeof(header), 0); 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 nbytes = pread(fd, lwp, size, sizeof(header)); 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 ); } /* * Return process voluntary and involuntary context switches as a Python tuple. */ 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); } /* * Return process page faults as a (minor, major) tuple. */ 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) ); } /* * Return process memory mappings. */ 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; fd = open(path, O_RDONLY); if (fd == -1) { psutil_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 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; } ================================================ FILE: psutil/arch/sunos/sys.c ================================================ /* * 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 #include #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); } ================================================ FILE: psutil/arch/windows/cpu.c ================================================ /* * 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 #include #include #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 = 0; // Minimum requirement: Windows 7 if (GetActiveProcessorCount != NULL) { ncpus = GetActiveProcessorCount(ALL_PROCESSOR_GROUPS); if ((ncpus == 0) && (fail_on_err == 1)) { psutil_oserror(); } } else { psutil_debug( "GetActiveProcessorCount() not available; " "using GetSystemInfo()" ); ncpus = (unsigned int)PSUTIL_SYSTEM_INFO.dwNumberOfProcessors; if ((ncpus <= 0) && (fail_on_err == 1)) { psutil_runtime_error("GetSystemInfo failed to retrieve CPU count"); } } return ncpus; } /* * 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. */ 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 system 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; 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), NULL ); if (!NT_SUCCESS(status)) { psutil_SetFromNTStatusErr( status, "NtQuerySystemInformation(SystemProcessorPerformanceInformation)" ); goto error; } // computes system global times summing each // processor value 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; // GetLogicalProcessorInformationEx() is available from Windows 7 // onward. Differently from GetLogicalProcessorInformation() // it supports process groups, meaning this is able to report more // than 64 CPUs. See: // https://bugs.python.org/issue33166 if (GetLogicalProcessorInformationEx == NULL) { psutil_debug("Win < 7; cpu_count_cores() forced to None"); Py_RETURN_NONE; } 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; } /* * Return CPU statistics. */ 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; UINT i; ULONG64 dpcs = 0; ULONG interrupts = 0; // retrieves number of processors ncpus = psutil_get_num_cpus(1); if (ncpus == 0) goto error; // get syscalls / ctx switches spi = (_SYSTEM_PERFORMANCE_INFORMATION *)malloc( ncpus * sizeof(_SYSTEM_PERFORMANCE_INFORMATION) ); if (spi == NULL) { PyErr_NoMemory(); goto error; } status = NtQuerySystemInformation( SystemPerformanceInformation, spi, ncpus * 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), NULL ); if (!NT_SUCCESS(status)) { psutil_SetFromNTStatusErr( status, "NtQuerySystemInformation(SystemInterruptInformation)" ); goto error; } for (i = 0; i < ncpus; 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), NULL ); if (!NT_SUCCESS(status)) { psutil_SetFromNTStatusErr( status, "NtQuerySystemInformation(SystemProcessorPerformanceInformation)" ); goto error; } for (i = 0; i < ncpus; i++) { interrupts += sppi[i].InterruptCount; } // done free(spi); free(InterruptInformation); free(sppi); return Py_BuildValue( "kkkk", spi->ContextSwitches, interrupts, (unsigned long)dpcs, spi->SystemCalls ); error: if (spi) free(spi); if (InterruptInformation) free(InterruptInformation); if (sppi) free(sppi); return NULL; } /* * Return CPU frequency. */ 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 (ret != 0) { psutil_runtime_error("CallNtPowerInformation syscall failed"); 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; } ================================================ FILE: psutil/arch/windows/disk.c ================================================ /* * 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 #include #include #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 "?"; } } // Return path's disk total, used, and free space. 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); } /* * Return a Python dict of tuples for disk I/O information. This may * require running "diskperf -y" command first. */ PyObject * psutil_disk_io_counters(PyObject *self, PyObject *args) { DISK_PERFORMANCE diskPerformance; DWORD dwSize; HANDLE hDevice = NULL; char szDevice[MAX_PATH]; char szDeviceDisplay[MAX_PATH]; int devNum; int i; DWORD ioctrlSize; BOOL ret; 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; str_format(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; // DeviceIoControl() sucks! i = 0; ioctrlSize = sizeof(diskPerformance); while (1) { i += 1; ret = DeviceIoControl( hDevice, IOCTL_DISK_PERFORMANCE, NULL, 0, &diskPerformance, ioctrlSize, &dwSize, NULL ); if (ret != 0) break; // OK! if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) { // Retry with a bigger buffer (+ limit for retries). if (i <= 1024) { ioctrlSize *= 2; 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); } return py_retdict; error: Py_XDECREF(py_tuple); Py_DECREF(py_retdict); if (hDevice != NULL) CloseHandle(hDevice); return NULL; } /* * Return disk partitions as a list of tuples such as * (drive_letter, drive_letter, type, "") */ PyObject * psutil_disk_partitions(PyObject *self, PyObject *args) { DWORD num_bytes; char drive_strings[255]; char *drive_letter = drive_strings; char mp_buf[MAX_PATH]; char mp_path[MAX_PATH]; int all; int type; int ret; unsigned int old_mode = 0; char opts[50]; HANDLE mp_h; BOOL mp_flag = TRUE; LPTSTR fs_type[MAX_PATH + 1] = {0}; DWORD pflags = 0; DWORD lpMaximumComponentLength = 0; // max file name PyObject *py_all; 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, "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) { psutil_oserror(); goto error; } while (*drive_letter != 0) { 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, &lpMaximumComponentLength, &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'). str_append(opts, sizeof(opts), ""); 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"); // Check for mount points on this volume and add/get info // (checks first to know if we can even have mount points) if (pflags & FILE_SUPPORTS_REPARSE_POINTS) { mp_h = FindFirstVolumeMountPoint( drive_letter, mp_buf, MAX_PATH ); if (mp_h != INVALID_HANDLE_VALUE) { mp_flag = TRUE; while (mp_flag) { // Append full mount path with drive letter str_copy( mp_path, sizeof(mp_path), drive_letter ); // initialize str_append( mp_path, sizeof(mp_path), mp_buf ); // append mount point if (!pylist_append_fmt( py_retlist, "(ssss)", drive_letter, mp_path, fs_type, // typically "NTFS" opts )) { FindVolumeMountPointClose(mp_h); goto error; } // Continue looking for more mount points mp_flag = FindNextVolumeMountPoint( mp_h, mp_buf, MAX_PATH ); } FindVolumeMountPointClose(mp_h); } } } if (strlen(opts) > 0) str_append(opts, sizeof(opts), ","); str_append(opts, sizeof(opts), psutil_get_drive_type(type)); if (!pylist_append_fmt( py_retlist, "(ssss)", drive_letter, drive_letter, fs_type, // either FAT, FAT32, NTFS, HPFS, CDFS, UDF or NWFS opts )) { goto error; } goto next; next: drive_letter = strchr(drive_letter, 0) + 1; } SetErrorMode(old_mode); return py_retlist; error: 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) { 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 PyUnicode_FromString(szBuff); } } d++; } return PyUnicode_FromString(""); } ================================================ FILE: psutil/arch/windows/heap.c ================================================ /* * 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 #include #include #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 written; _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). heap_count = GetProcessHeaps(0, NULL); // 1st: get count if (heap_count == 0) return psutil_oserror_wsyscall("GetProcessHeaps (1/2)"); heaps = (HANDLE *)malloc(heap_count * sizeof(HANDLE)); if (!heaps) { PyErr_NoMemory(); return NULL; } written = GetProcessHeaps(heap_count, heaps); // 2nd: get heaps handles if (written == 0) { free(heaps); return psutil_oserror_wsyscall("GetProcessHeaps (2/2)"); } // 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 < heap_count; 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"); 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); } ================================================ FILE: psutil/arch/windows/init.c ================================================ /* * 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 #include #include "../../arch/all/init.h" #include "ntextapi.h" // Needed to make these globally visible. int PSUTIL_WINVER; SYSTEM_INFO PSUTIL_SYSTEM_INFO; CRITICAL_SECTION PSUTIL_CRITICAL_SECTION; // ==================================================================== // --- Backward compatibility with missing Python.h APIs // ==================================================================== // PyPy on Windows. Missing APIs added in PyPy 7.3.14. #if defined(PYPY_VERSION) #if !defined(PyErr_SetFromWindowsErrWithFilename) PyObject * PyErr_SetFromWindowsErrWithFilename(int winerr, const char *filename) { PyObject *py_exc = NULL; PyObject *py_winerr = NULL; if (winerr == 0) winerr = GetLastError(); if (filename == NULL) { py_exc = PyObject_CallFunction( PyExc_OSError, "(is)", winerr, strerror(winerr) ); } else { py_exc = PyObject_CallFunction( PyExc_OSError, "(iss)", winerr, strerror(winerr), filename ); } if (py_exc == NULL) return NULL; py_winerr = Py_BuildValue("i", winerr); if (py_winerr == NULL) goto error; if (PyObject_SetAttrString(py_exc, "winerror", py_winerr) != 0) goto error; PyErr_SetObject(PyExc_OSError, py_exc); Py_XDECREF(py_exc); return NULL; error: Py_XDECREF(py_exc); Py_XDECREF(py_winerr); return NULL; } #endif // !defined(PyErr_SetFromWindowsErrWithFilename) #if !defined(PyErr_SetExcFromWindowsErrWithFilenameObject) PyObject * PyErr_SetExcFromWindowsErrWithFilenameObject( PyObject *type, int ierr, PyObject *filename ) { // Original function is too complex. Just raise OSError without // filename. return PyErr_SetFromWindowsErrWithFilename(ierr, NULL); } #endif // !defined(PyErr_SetExcFromWindowsErrWithFilenameObject) #endif // defined(PYPY_VERSION) // ==================================================================== // --- 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); // if (GetLastError() != 0) // err = GetLastError(); 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 NtQuerySystemInformation = psutil_GetProcAddressFromLib( "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_GetProcAddressFromLib("ntdll.dll", "NtQueryObject"); if (!NtQueryObject) return -1; RtlIpv4AddressToStringA = psutil_GetProcAddressFromLib( "ntdll.dll", "RtlIpv4AddressToStringA" ); if (!RtlIpv4AddressToStringA) return -1; GetExtendedTcpTable = psutil_GetProcAddressFromLib( "iphlpapi.dll", "GetExtendedTcpTable" ); if (!GetExtendedTcpTable) return -1; GetExtendedUdpTable = psutil_GetProcAddressFromLib( "iphlpapi.dll", "GetExtendedUdpTable" ); if (!GetExtendedUdpTable) return -1; RtlGetVersion = psutil_GetProcAddressFromLib("ntdll.dll", "RtlGetVersion"); if (!RtlGetVersion) return -1; NtSuspendProcess = psutil_GetProcAddressFromLib( "ntdll", "NtSuspendProcess" ); if (!NtSuspendProcess) return -1; NtResumeProcess = psutil_GetProcAddressFromLib("ntdll", "NtResumeProcess"); if (!NtResumeProcess) return -1; NtQueryVirtualMemory = psutil_GetProcAddressFromLib( "ntdll", "NtQueryVirtualMemory" ); if (!NtQueryVirtualMemory) return -1; RtlNtStatusToDosErrorNoTeb = psutil_GetProcAddressFromLib( "ntdll", "RtlNtStatusToDosErrorNoTeb" ); if (!RtlNtStatusToDosErrorNoTeb) return -1; GetTickCount64 = psutil_GetProcAddress("kernel32", "GetTickCount64"); if (!GetTickCount64) return -1; RtlIpv6AddressToStringA = psutil_GetProcAddressFromLib( "ntdll.dll", "RtlIpv6AddressToStringA" ); if (!RtlIpv6AddressToStringA) return -1; // --- Optional // minimum requirement: Win 7 QueryInterruptTime = psutil_GetProcAddressFromLib( "kernelbase.dll", "QueryInterruptTime" ); // minimum requirement: Win 7 GetActiveProcessorCount = psutil_GetProcAddress( "kernel32", "GetActiveProcessorCount" ); // minimum requirement: Win 7 GetLogicalProcessorInformationEx = psutil_GetProcAddressFromLib( "kernel32", "GetLogicalProcessorInformationEx" ); // 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_set_winver() { RTL_OSVERSIONINFOEXW versionInfo; ULONG maj; ULONG min; versionInfo.dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW); memset(&versionInfo, 0, sizeof(RTL_OSVERSIONINFOEXW)); RtlGetVersion((PRTL_OSVERSIONINFOW)&versionInfo); maj = versionInfo.dwMajorVersion; min = versionInfo.dwMinorVersion; if (maj == 6 && min == 0) PSUTIL_WINVER = PSUTIL_WINDOWS_VISTA; // or Server 2008 else if (maj == 6 && min == 1) PSUTIL_WINVER = PSUTIL_WINDOWS_7; else if (maj == 6 && min == 2) PSUTIL_WINVER = PSUTIL_WINDOWS_8; else if (maj == 6 && min == 3) PSUTIL_WINVER = PSUTIL_WINDOWS_8_1; else if (maj == 10 && min == 0) PSUTIL_WINVER = PSUTIL_WINDOWS_10; else PSUTIL_WINVER = PSUTIL_WINDOWS_NEW; return 0; } // Called on module import. int psutil_setup_windows(void) { if (psutil_loadlibs() != 0) return -1; if (psutil_set_winver() != 0) return -1; GetSystemInfo(&PSUTIL_SYSTEM_INFO); InitializeCriticalSection(&PSUTIL_CRITICAL_SECTION); return 0; } ================================================ FILE: psutil/arch/windows/init.h ================================================ /* * 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 #include #include #include "ntextapi.h" extern int PSUTIL_WINVER; extern SYSTEM_INFO PSUTIL_SYSTEM_INFO; extern CRITICAL_SECTION PSUTIL_CRITICAL_SECTION; #define PSUTIL_WINDOWS_VISTA 60 #define PSUTIL_WINDOWS_7 61 #define PSUTIL_WINDOWS_8 62 #define PSUTIL_WINDOWS_8_1 63 #define PSUTIL_WINDOWS_10 100 #define PSUTIL_WINDOWS_NEW MAXLONG #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 #if defined(PSUTIL_WINDOWS) && defined(PYPY_VERSION) #if !defined(PyErr_SetFromWindowsErrWithFilename) PyObject *PyErr_SetFromWindowsErrWithFilename(int ierr, const char *filename); #endif #if !defined(PyErr_SetExcFromWindowsErrWithFilenameObject) PyObject *PyErr_SetExcFromWindowsErrWithFilenameObject( PyObject *type, int ierr, PyObject *filename ); #endif #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); PyObject *TimeoutExpired; PyObject *TimeoutAbandoned; int _psutil_pids(DWORD **pids_array, int *pids_count); HANDLE psutil_check_phandle(HANDLE hProcess, DWORD pid, int check_exit_code); HANDLE psutil_handle_from_pid(DWORD pid, DWORD dwDesiredAccess); int psutil_assert_pid_exists(DWORD pid, char *err); int psutil_assert_pid_not_exists(DWORD pid, char *err); int psutil_pid_is_running(DWORD pid); int psutil_set_se_debug(); SC_HANDLE psutil_get_service_handle( char service_name, DWORD scm_access, DWORD access ); int psutil_get_proc_info( 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(DWORD pid, 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_is_suspended(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_page_faults(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_uptime(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); ================================================ FILE: psutil/arch/windows/mem.c ================================================ /* * 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 #include #include #include #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; if ((PdhOpenQueryW(NULL, 0, &hQuery)) != ERROR_SUCCESS) { psutil_runtime_error("PdhOpenQueryW failed"); return NULL; } s = PdhAddEnglishCounterW(hQuery, szCounterPath, 0, &hCounter); if (s != ERROR_SUCCESS) { PdhCloseQuery(hQuery); psutil_runtime_error( "PdhAddEnglishCounterW failed. Performance counters may be " "disabled." ); return NULL; } s = PdhCollectQueryData(hQuery); if (s != ERROR_SUCCESS) { // If swap disabled this will fail. psutil_debug("PdhCollectQueryData failed; assume swap percent is 0"); percentUsage = 0; } else { s = PdhGetFormattedCounterValue( (PDH_HCOUNTER)hCounter, PDH_FMT_DOUBLE, 0, &counterValue ); if (s != ERROR_SUCCESS) { PdhCloseQuery(hQuery); psutil_runtime_error("PdhGetFormattedCounterValue failed"); return NULL; } percentUsage = counterValue.doubleValue; } PdhRemoveCounter(hCounter); PdhCloseQuery(hQuery); return Py_BuildValue("d", percentUsage); } ================================================ FILE: psutil/arch/windows/net.c ================================================ /* * 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 #include #include #include #include "../../arch/all/init.h" static PIP_ADAPTER_ADDRESSES psutil_get_nic_addresses(void) { ULONG bufferLength = 0; PIP_ADAPTER_ADDRESSES buffer; if (GetAdaptersAddresses(AF_UNSPEC, 0, NULL, NULL, &bufferLength) != ERROR_BUFFER_OVERFLOW) { psutil_runtime_error("GetAdaptersAddresses() syscall failed."); return NULL; } buffer = malloc(bufferLength); if (buffer == NULL) { PyErr_NoMemory(); return NULL; } memset(buffer, 0, bufferLength); if (GetAdaptersAddresses(AF_UNSPEC, 0, NULL, buffer, &bufferLength) != ERROR_SUCCESS) { free(buffer); psutil_runtime_error("GetAdaptersAddresses() syscall failed."); return NULL; } return buffer; } /* * Return a Python list of named tuples with overall network I/O information */ 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(); 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; dwRetVal = GetIfEntry2(&ifRow); if (dwRetVal != NO_ERROR) { psutil_runtime_error( "GetIfEntry2() syscall failed for interface %lu", (unsigned long)ifRow.InterfaceIndex ); goto error; } 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[1024]; char buff_macaddr[1024]; char buff_netmask[1024]; 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(); 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; netmaskIntRet = 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_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"); break; } 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++) { 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) 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) 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) 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) { int i; DWORD dwSize = 0; DWORD dwRetVal = 0; MIB_IFTABLE *pIfTable = NULL; 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) { psutil_runtime_error("GetIfTable() syscall 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; Py_CLEAR(py_nic_name); Py_CLEAR(py_ifc_info); pCurrAddresses = pAddresses; while (pCurrAddresses) { str_format(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; } Py_CLEAR(py_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_CLEAR(py_ifc_info); Py_CLEAR(py_nic_name); } free(pIfTable); 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 (pIfTable) free(pIfTable); if (pAddresses) free(pAddresses); return NULL; } ================================================ FILE: psutil/arch/windows/ntextapi.h ================================================ /* * 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. * Define Windows structs and constants which are considered private. */ // clang-format off #if !defined(__NTEXTAPI_H__) #define __NTEXTAPI_H__ #include #include typedef LONG NTSTATUS; // 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 // ================================================================ #undef SystemExtendedHandleInformation #define SystemExtendedHandleInformation 64 #undef MemoryWorkingSetInformation #define MemoryWorkingSetInformation 0x1 #undef ObjectNameInformation #define ObjectNameInformation 1 #undef ProcessIoPriority #define ProcessIoPriority 33 #undef ProcessWow64Information #define ProcessWow64Information 26 #undef SystemProcessIdInformation #define SystemProcessIdInformation 88 // 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 { LARGE_INTEGER IdleTime; LARGE_INTEGER KernelTime; LARGE_INTEGER UserTime; LARGE_INTEGER DpcTime; LARGE_INTEGER InterruptTime; ULONG InterruptCount; } _SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION; // cpu_stats() typedef struct { LARGE_INTEGER IdleProcessTime; LARGE_INTEGER IoReadTransferCount; LARGE_INTEGER IoWriteTransferCount; LARGE_INTEGER IoOtherTransferCount; ULONG IoReadOperationCount; ULONG IoWriteOperationCount; ULONG IoOtherOperationCount; ULONG AvailablePages; ULONG CommittedPages; ULONG CommitLimit; ULONG PeakCommitment; ULONG PageFaultCount; ULONG CopyOnWriteCount; ULONG TransitionCount; ULONG CacheTransitionCount; ULONG DemandZeroCount; ULONG PageReadCount; ULONG PageReadIoCount; ULONG CacheReadCount; ULONG CacheIoCount; ULONG DirtyPagesWriteCount; ULONG DirtyWriteIoCount; ULONG MappedPagesWriteCount; ULONG MappedWriteIoCount; ULONG PagedPoolPages; ULONG NonPagedPoolPages; ULONG PagedPoolAllocs; ULONG PagedPoolFrees; ULONG NonPagedPoolAllocs; ULONG NonPagedPoolFrees; ULONG FreeSystemPtes; ULONG ResidentSystemCodePage; ULONG TotalSystemDriverPages; ULONG TotalSystemCodePages; ULONG NonPagedPoolLookasideHits; ULONG PagedPoolLookasideHits; ULONG AvailablePagedPoolPages; ULONG ResidentSystemCachePage; ULONG ResidentPagedPoolPage; ULONG ResidentSystemDriverPage; ULONG CcFastReadNoWait; ULONG CcFastReadWait; ULONG CcFastReadResourceMiss; ULONG CcFastReadNotPossible; ULONG CcFastMdlReadNoWait; ULONG CcFastMdlReadWait; ULONG CcFastMdlReadResourceMiss; ULONG CcFastMdlReadNotPossible; ULONG CcMapDataNoWait; ULONG CcMapDataWait; ULONG CcMapDataNoWaitMiss; ULONG CcMapDataWaitMiss; ULONG CcPinMappedDataCount; ULONG CcPinReadNoWait; ULONG CcPinReadWait; ULONG CcPinReadNoWaitMiss; ULONG CcPinReadWaitMiss; ULONG CcCopyReadNoWait; ULONG CcCopyReadWait; ULONG CcCopyReadNoWaitMiss; ULONG CcCopyReadWaitMiss; ULONG CcMdlReadNoWait; ULONG CcMdlReadWait; ULONG CcMdlReadNoWaitMiss; ULONG CcMdlReadWaitMiss; ULONG CcReadAheadIos; ULONG CcLazyWriteIos; ULONG CcLazyWritePages; ULONG CcDataFlushes; ULONG CcDataPages; ULONG ContextSwitches; ULONG FirstLevelTbFills; ULONG SecondLevelTbFills; ULONG SystemCalls; } _SYSTEM_PERFORMANCE_INFORMATION; // cpu_stats() typedef struct { ULONG ContextSwitches; ULONG DpcCount; ULONG DpcRate; ULONG TimeIncrement; ULONG DpcBypassCount; ULONG ApcBypassCount; } _SYSTEM_INTERRUPT_INFORMATION; 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 struct _CLIENT_ID2 { HANDLE UniqueProcess; HANDLE UniqueThread; } CLIENT_ID2, *PCLIENT_ID2; #define CLIENT_ID CLIENT_ID2 #define PCLIENT_ID PCLIENT_ID2 typedef struct _SYSTEM_THREAD_INFORMATION2 { LARGE_INTEGER KernelTime; LARGE_INTEGER UserTime; LARGE_INTEGER CreateTime; ULONG WaitTime; PVOID StartAddress; CLIENT_ID ClientId; LONG Priority; LONG BasePriority; ULONG ContextSwitches; ULONG ThreadState; KWAIT_REASON WaitReason; } SYSTEM_THREAD_INFORMATION2, *PSYSTEM_THREAD_INFORMATION2; #define SYSTEM_THREAD_INFORMATION SYSTEM_THREAD_INFORMATION2 #define PSYSTEM_THREAD_INFORMATION PSYSTEM_THREAD_INFORMATION2 typedef struct _SYSTEM_PROCESS_INFORMATION2 { 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_INFORMATION2, *PSYSTEM_PROCESS_INFORMATION2; #define SYSTEM_PROCESS_INFORMATION SYSTEM_PROCESS_INFORMATION2 #define PSYSTEM_PROCESS_INFORMATION PSYSTEM_PROCESS_INFORMATION2 // 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; #ifndef __IPHLPAPI_H__ typedef struct in6_addr { union { UCHAR Byte[16]; USHORT Word[8]; } u; } IN6_ADDR, *PIN6_ADDR, FAR *LPIN6_ADDR; #endif // PEB / cmdline(), cwd(), environ() 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_; // users() typedef struct _WTS_SESSION_INFOW { DWORD SessionId; // session id LPWSTR pWinStationName; // name of WinStation this session is // connected to WTS_CONNECTSTATE_CLASS State; // connection state (see enum) } WTS_SESSION_INFOW, * PWTS_SESSION_INFOW; #define PWTS_SESSION_INFO 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; #define PWTSINFO PWTSINFOW // cpu_count_cores() #if (_WIN32_WINNT < 0x0601) // Windows < 7 (Vista and XP) typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX { LOGICAL_PROCESSOR_RELATIONSHIP Relationship; DWORD Size; _ANONYMOUS_UNION union { PROCESSOR_RELATIONSHIP Processor; NUMA_NODE_RELATIONSHIP NumaNode; CACHE_RELATIONSHIP Cache; GROUP_RELATIONSHIP Group; } DUMMYUNIONNAME; } SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, \ *PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX; #endif // 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; } SYSTEM_PROCESS_ID_INFORMATION, *PSYSTEM_PROCESS_ID_INFORMATION; // ==================================================================== // PEB structs for cmdline(), cwd(), environ() // ==================================================================== #ifdef _WIN64 typedef struct { 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 { 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 // ! _WIN64 typedef struct { BYTE Reserved1[2]; BYTE BeingDebugged; BYTE Reserved2[1]; PVOID Reserved3[2]; PVOID Ldr; PRTL_USER_PROCESS_PARAMETERS_ ProcessParameters; // more fields... } PEB_; // 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)( HANDLE ProcessHandle, PVOID64 BaseAddress, PVOID Buffer, ULONG64 Size, PULONG64 NumberOfBytesRead); 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 // _WIN64 // ================================================================ // Type defs for modules loaded at runtime. // ================================================================ BOOL (WINAPI *_GetLogicalProcessorInformationEx) ( LOGICAL_PROCESSOR_RELATIONSHIP relationship, PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Buffer, PDWORD ReturnLength); #define GetLogicalProcessorInformationEx _GetLogicalProcessorInformationEx BOOLEAN (WINAPI * _WinStationQueryInformationW) ( HANDLE ServerHandle, ULONG SessionId, WINSTATIONINFOCLASS WinStationInformationClass, PVOID pWinStationInformation, ULONG WinStationInformationLength, PULONG pReturnLength); #define WinStationQueryInformationW _WinStationQueryInformationW NTSTATUS (NTAPI *_NtQueryInformationProcess) ( HANDLE ProcessHandle, DWORD ProcessInformationClass, PVOID ProcessInformation, DWORD ProcessInformationLength, PDWORD ReturnLength); #define NtQueryInformationProcess _NtQueryInformationProcess NTSTATUS (NTAPI *_NtQuerySystemInformation) ( ULONG SystemInformationClass, PVOID SystemInformation, ULONG SystemInformationLength, PULONG ReturnLength); #define NtQuerySystemInformation _NtQuerySystemInformation NTSTATUS (NTAPI *_NtSetInformationProcess) ( HANDLE ProcessHandle, DWORD ProcessInformationClass, PVOID ProcessInformation, DWORD ProcessInformationLength); #define NtSetInformationProcess _NtSetInformationProcess PSTR (NTAPI * _RtlIpv4AddressToStringA) ( struct in_addr *Addr, PSTR S); #define RtlIpv4AddressToStringA _RtlIpv4AddressToStringA PSTR (NTAPI * _RtlIpv6AddressToStringA) ( struct in6_addr *Addr, PSTR P); #define RtlIpv6AddressToStringA _RtlIpv6AddressToStringA DWORD (WINAPI * _GetExtendedTcpTable) ( PVOID pTcpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, TCP_TABLE_CLASS TableClass, ULONG Reserved); #define GetExtendedTcpTable _GetExtendedTcpTable DWORD (WINAPI * _GetExtendedUdpTable) ( PVOID pUdpTable, PDWORD pdwSize, BOOL bOrder, ULONG ulAf, UDP_TABLE_CLASS TableClass, ULONG Reserved); #define GetExtendedUdpTable _GetExtendedUdpTable DWORD (CALLBACK *_GetActiveProcessorCount) ( WORD GroupNumber); #define GetActiveProcessorCount _GetActiveProcessorCount BOOL(CALLBACK *_WTSQuerySessionInformationW) ( HANDLE hServer, DWORD SessionId, WTS_INFO_CLASS WTSInfoClass, LPWSTR* ppBuffer, DWORD* pBytesReturned ); #define WTSQuerySessionInformationW _WTSQuerySessionInformationW BOOL(CALLBACK *_WTSEnumerateSessionsW)( HANDLE hServer, DWORD Reserved, DWORD Version, PWTS_SESSION_INFO* ppSessionInfo, DWORD* pCount ); #define WTSEnumerateSessionsW _WTSEnumerateSessionsW VOID(CALLBACK *_WTSFreeMemory)( IN PVOID pMemory ); #define WTSFreeMemory _WTSFreeMemory ULONGLONG (CALLBACK *_GetTickCount64) ( void); #define GetTickCount64 _GetTickCount64 VOID(CALLBACK *_QueryInterruptTime) ( PULONGLONG lpInterruptTime ); #define QueryInterruptTime _QueryInterruptTime NTSTATUS (NTAPI *_NtQueryObject) ( HANDLE Handle, OBJECT_INFORMATION_CLASS ObjectInformationClass, PVOID ObjectInformation, ULONG ObjectInformationLength, PULONG ReturnLength); #define NtQueryObject _NtQueryObject NTSTATUS (WINAPI *_RtlGetVersion) ( PRTL_OSVERSIONINFOW lpVersionInformation ); #define RtlGetVersion _RtlGetVersion NTSTATUS (WINAPI *_NtResumeProcess) ( HANDLE hProcess ); #define NtResumeProcess _NtResumeProcess NTSTATUS (WINAPI *_NtSuspendProcess) ( HANDLE hProcess ); #define NtSuspendProcess _NtSuspendProcess NTSTATUS (NTAPI *_NtQueryVirtualMemory) ( HANDLE ProcessHandle, PVOID BaseAddress, int MemoryInformationClass, PVOID MemoryInformation, SIZE_T MemoryInformationLength, PSIZE_T ReturnLength ); #define NtQueryVirtualMemory _NtQueryVirtualMemory ULONG (WINAPI *_RtlNtStatusToDosErrorNoTeb) ( NTSTATUS status ); #define RtlNtStatusToDosErrorNoTeb _RtlNtStatusToDosErrorNoTeb #endif // __NTEXTAPI_H__ // clang-format on ================================================ FILE: psutil/arch/windows/pids.c ================================================ /* * 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 #include #include #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; } ================================================ FILE: psutil/arch/windows/proc.c ================================================ /* * 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 #include #include // memory_info(), memory_maps() #include #include // threads(), PROCESSENTRY32 // Link with Iphlpapi.lib #pragma comment(lib, "IPHLPAPI.lib") #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); } /* * Kill a process given its PID. */ 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"); return NULL; } } CloseHandle(hProcess); Py_RETURN_NONE; } /* * Wait for process to terminate and return its exit code. */ PyObject * psutil_proc_wait(PyObject *self, PyObject *args) { HANDLE hProcess; DWORD ExitCode; DWORD retVal; DWORD pid; long timeout; 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; } else { 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 a Python tuple (user_time, kernel_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_pid_is_running(pid) == 0) return psutil_oserror_nsp("psutil_pid_is_running -> 0"); 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 bufferSize *= 2; 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); if (psutil_pid_is_running(pid) == 0) psutil_oserror_nsp("psutil_pid_is_running -> 0"); else psutil_SetFromNTStatusErr(status, "NtQuerySystemInformation"); return NULL; } 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; } /* * Return process memory information as a Python dict. */ 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 if (psutil_pid_is_running(pid) == 0) { psutil_oserror_nsp("psutil_pid_is_running -> 0"); } else { PyErr_Clear(); psutil_SetFromNTStatusErr( status, "NtQueryVirtualMemory(MemoryWorkingSetInformation)" ); } HeapFree(GetProcessHeap(), 0, 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++; } } HeapFree(GetProcessHeap(), 0, 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; PyObject *suspend; if (!PyArg_ParseTuple(args, _Py_PARSE_PID "O", &pid, &suspend)) return NULL; hProcess = psutil_handle_from_pid(pid, access); if (hProcess == NULL) return NULL; if (PyObject_IsTrue(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) { HANDLE hThread = NULL; THREADENTRY32 te32 = {0}; DWORD pid; int pid_return; int rc; FILETIME ftDummy, ftKernel, ftUser; HANDLE hThreadSnap = NULL; PyObject *py_retlist = PyList_New(0); if (py_retlist == NULL) return NULL; if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid)) goto error; if (pid == 0) { // raise AD instead of returning 0 as procexp is able to // retrieve useful information somehow psutil_oserror_ad("forced for PID 0"); goto error; } pid_return = psutil_pid_is_running(pid); if (pid_return == 0) { psutil_oserror_nsp("psutil_pid_is_running -> 0"); goto error; } if (pid_return == -1) goto error; hThreadSnap = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0); if (hThreadSnap == INVALID_HANDLE_VALUE) { psutil_oserror_wsyscall("CreateToolhelp32Snapshot"); goto error; } // Fill in the size of the structure before using it te32.dwSize = sizeof(THREADENTRY32); if (!Thread32First(hThreadSnap, &te32)) { psutil_oserror_wsyscall("Thread32First"); 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) { 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) { psutil_oserror_wsyscall("GetThreadTimes"); goto error; } /* * 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 */ if (!pylist_append_fmt( py_retlist, "kdd", te32.th32ThreadID, (double)(ftUser.dwHighDateTime * HI_T + ftUser.dwLowDateTime * LO_T), (double)(ftKernel.dwHighDateTime * HI_T + ftKernel.dwLowDateTime * LO_T) )) { goto error; } CloseHandle(hThread); } } while (Thread32Next(hThreadSnap, &te32)); CloseHandle(hThreadSnap); return py_retlist; error: Py_DECREF(py_retlist); if (hThread != NULL) CloseHandle(hThread); if (hThreadSnap != NULL) CloseHandle(hThreadSnap); 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(pid, processHandle); CloseHandle(processHandle); return py_retlist; } static PTOKEN_USER _psutil_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; PyObject *py_username = NULL; PyObject *py_domain = NULL; PyObject *py_tuple = NULL; if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid)) return NULL; userToken = _psutil_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; } if (!LookupAccountSidW( NULL, userToken->User.Sid, userName, &nameSize, domainName, &domainNameSize, &nameUse )) { if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) { free(userName); free(domainName); continue; } else if (GetLastError() == ERROR_NONE_MAPPED) { // From MS doc: // https://docs.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; } /* * Get process IO priority as a Python integer. */ 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); } /* * Set process IO priority. */ 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; } /* * Return a Python tuple referencing process I/O counters. */ 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); } /* * Set process CPU affinity */ 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; } // Return process page faults as a (minor, major) tuple. Uses // NtQuerySystemInformation(SystemProcessInformation) which returns // SYSTEM_PROCESS_INFORMATION. PageFaultCount is the total (soft + // hard), while HardFaultCount (available since Win7) tracks hard // (major) faults only. Minor faults are derived by subtracting the // two. PyObject * psutil_proc_page_faults(PyObject *self, PyObject *args) { DWORD pid; PSYSTEM_PROCESS_INFORMATION process; PVOID buffer; ULONG minor; ULONG major; PyObject *ret; if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid)) return NULL; if (psutil_get_proc_info(pid, &process, &buffer) != 0) return NULL; major = process->HardFaultCount; minor = process->PageFaultCount - major; ret = Py_BuildValue("(kk)", (unsigned long)minor, (unsigned long)major); free(buffer); return ret; } /* * Return True if all process threads are in waiting/suspended state. */ PyObject * psutil_proc_is_suspended(PyObject *self, PyObject *args) { DWORD pid; ULONG i; PSYSTEM_PROCESS_INFORMATION process; PVOID buffer; if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid)) return NULL; if (psutil_get_proc_info(pid, &process, &buffer) != 0) 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 the number of handles opened by process. */ 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 "?"; } } /* * Return a list of process's memory mappings. */ PyObject * psutil_proc_memory_maps(PyObject *self, PyObject *args) { MEMORY_BASIC_INFORMATION basicInfo; DWORD pid; HANDLE hProcess = NULL; PVOID baseAddress; WCHAR mappedFileName[MAX_PATH]; 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; maxAddr = PSUTIL_SYSTEM_INFO.lpMaximumApplicationAddress; baseAddress = NULL; while (VirtualQueryEx( hProcess, baseAddress, &basicInfo, sizeof(MEMORY_BASIC_INFORMATION) )) { if (baseAddress > maxAddr) break; if (GetMappedFileNameW( hProcess, baseAddress, mappedFileName, sizeof(mappedFileName) )) { 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; } CloseHandle(hProcess); return py_retlist; error: Py_XDECREF(py_str); Py_DECREF(py_retlist); if (hProcess != NULL) CloseHandle(hProcess); return NULL; } /* * 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(); 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) { psutil_oserror(); Py_DECREF(py_retdict); return NULL; } if (Process32First(handle, &pe)) { do { py_pid = PyLong_FromPid(pe.th32ProcessID); if (py_pid == NULL) goto error; py_ppid = PyLong_FromPid(pe.th32ParentProcessID); 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 (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; } ================================================ FILE: psutil/arch/windows/proc_handles.c ================================================ /* * 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 handles opened by a process. * We use NtQuerySystemInformation to enumerate them and NtQueryObject * to obtain the corresponding file name. * Since NtQueryObject hangs for certain handle types we call it in a * separate thread which gets killed if it doesn't complete within 100ms. * This is a limitation of the Windows API and ProcessHacker uses the * same trick: https://github.com/giampaolo/psutil/pull/597 * * CREDITS: original implementation was written by Jeff Tang. * It was then rewritten by Giampaolo Rodola many years later. * Utility functions for getting the file handles and names were re-adapted * from the excellent ProcessHacker. */ #include #include #include "../../arch/all/init.h" #define THREAD_TIMEOUT 100 // ms // Global object shared between the 2 threads. PUNICODE_STRING globalFileName = NULL; static int psutil_enum_handles(PSYSTEM_HANDLE_INFORMATION_EX *handles) { static ULONG initialBufferSize = 0x10000; NTSTATUS status; PVOID buffer; ULONG bufferSize; bufferSize = initialBufferSize; buffer = MALLOC_ZERO(bufferSize); if (buffer == NULL) { PyErr_NoMemory(); return -1; } while ((status = NtQuerySystemInformation( SystemExtendedHandleInformation, 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( "SystemExtendedHandleInformation buffer too big" ); return -1; } buffer = MALLOC_ZERO(bufferSize); if (buffer == NULL) { PyErr_NoMemory(); return -1; } } if (!NT_SUCCESS(status)) { psutil_SetFromNTStatusErr(status, "NtQuerySystemInformation"); FREE(buffer); return -1; } *handles = (PSYSTEM_HANDLE_INFORMATION_EX)buffer; return 0; } static int psutil_get_filename(LPVOID lpvParam) { HANDLE hFile = *((HANDLE *)lpvParam); NTSTATUS status; ULONG bufferSize; ULONG attempts = 8; bufferSize = 0x200; globalFileName = MALLOC_ZERO(bufferSize); if (globalFileName == NULL) { PyErr_NoMemory(); goto error; } // Note: also this is supposed to hang, hence why we do it in here. if (GetFileType(hFile) != FILE_TYPE_DISK) { SetLastError(0); globalFileName->Length = 0; return 0; } // A loop is needed because the I/O subsystem likes to give us the // wrong return lengths... do { status = NtQueryObject( hFile, ObjectNameInformation, globalFileName, bufferSize, &bufferSize ); if (status == STATUS_BUFFER_OVERFLOW || status == STATUS_INFO_LENGTH_MISMATCH || status == STATUS_BUFFER_TOO_SMALL) { FREE(globalFileName); globalFileName = MALLOC_ZERO(bufferSize); if (globalFileName == NULL) { PyErr_NoMemory(); goto error; } } else { break; } } while (--attempts); if (!NT_SUCCESS(status)) { psutil_SetFromNTStatusErr(status, "NtQuerySystemInformation"); FREE(globalFileName); globalFileName = NULL; return 1; } return 0; error: if (globalFileName != NULL) { FREE(globalFileName); globalFileName = NULL; } return 1; } static DWORD psutil_threaded_get_filename(HANDLE hFile) { DWORD dwWait; HANDLE hThread; DWORD threadRetValue; hThread = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)psutil_get_filename, &hFile, 0, NULL ); if (hThread == NULL) { psutil_oserror_wsyscall("CreateThread"); return -1; } // Wait for the worker thread to finish. dwWait = WaitForSingleObject(hThread, THREAD_TIMEOUT); // If the thread hangs, kill it and cleanup. if (dwWait == WAIT_TIMEOUT) { psutil_debug( "get handle name thread timed out after %i ms", THREAD_TIMEOUT ); if (TerminateThread(hThread, 0) == 0) { psutil_oserror_wsyscall("TerminateThread"); CloseHandle(hThread); return -1; } CloseHandle(hThread); return 0; } if (dwWait == WAIT_FAILED) { psutil_debug("WaitForSingleObject -> WAIT_FAILED"); if (TerminateThread(hThread, 0) == 0) { psutil_oserror_wsyscall( "WaitForSingleObject -> WAIT_FAILED -> TerminateThread" ); CloseHandle(hThread); return -1; } psutil_oserror_wsyscall("WaitForSingleObject"); CloseHandle(hThread); return -1; } if (GetExitCodeThread(hThread, &threadRetValue) == 0) { if (TerminateThread(hThread, 0) == 0) { psutil_oserror_wsyscall( "GetExitCodeThread (failed) -> TerminateThread" ); CloseHandle(hThread); return -1; } CloseHandle(hThread); psutil_oserror_wsyscall("GetExitCodeThread"); return -1; } CloseHandle(hThread); return threadRetValue; } PyObject * psutil_get_open_files(DWORD dwPid, HANDLE hProcess) { PSYSTEM_HANDLE_INFORMATION_EX handlesList = NULL; PSYSTEM_HANDLE_TABLE_ENTRY_INFO_EX hHandle = NULL; HANDLE hFile = NULL; ULONG i = 0; BOOLEAN errorOccurred = FALSE; PyObject *py_retlist = PyList_New(0); ; if (!py_retlist) return NULL; // Due to the use of global variables, ensure only 1 call // to psutil_get_open_files() is running. EnterCriticalSection(&PSUTIL_CRITICAL_SECTION); if (psutil_enum_handles(&handlesList) != 0) goto error; for (i = 0; i < handlesList->NumberOfHandles; i++) { hHandle = &handlesList->Handles[i]; if ((ULONG_PTR)hHandle->UniqueProcessId != dwPid) continue; if (!DuplicateHandle( hProcess, hHandle->HandleValue, GetCurrentProcess(), &hFile, 0, TRUE, DUPLICATE_SAME_ACCESS )) { // Will fail if not a regular file; just skip it. continue; } // This will set *globalFileName* global variable. if (psutil_threaded_get_filename(hFile) != 0) goto error; if ((globalFileName != NULL) && (globalFileName->Length > 0)) { if (!pylist_append_obj( py_retlist, PyUnicode_FromWideChar( globalFileName->Buffer, wcslen(globalFileName->Buffer) ) )) goto error; } // Loop cleanup section. if (globalFileName != NULL) { FREE(globalFileName); globalFileName = NULL; } CloseHandle(hFile); hFile = NULL; } goto exit; error: Py_XDECREF(py_retlist); errorOccurred = TRUE; goto exit; exit: if (hFile != NULL) CloseHandle(hFile); if (globalFileName != NULL) { FREE(globalFileName); globalFileName = NULL; } if (handlesList != NULL) FREE(handlesList); LeaveCriticalSection(&PSUTIL_CRITICAL_SECTION); if (errorOccurred == TRUE) return NULL; return py_retlist; } ================================================ FILE: psutil/arch/windows/proc_info.c ================================================ /* * 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 #include #include "../../arch/all/init.h" #ifndef _WIN64 typedef NTSTATUS(NTAPI *__NtQueryInformationProcess)( HANDLE ProcessHandle, DWORD ProcessInformationClass, PVOID ProcessInformation, DWORD ProcessInformationLength, PDWORD ReturnLength ); #endif #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) /* * 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))) { psutil_oserror_wsyscall("VirtualQueryEx"); return -1; } *psize = info.RegionSize - ((char *)src - (char *)info.BaseAddress); return 0; } enum psutil_process_data_kind { KIND_CMDLINE, KIND_CWD, KIND_ENVIRON, }; static void psutil_convert_winerr(ULONG err, char *syscall) { char fullmsg[8192]; if (err == ERROR_NOACCESS) { str_format(fullmsg, sizeof(fullmsg), "%s -> ERROR_NOACCESS", syscall); psutil_debug(fullmsg); psutil_oserror_ad(fullmsg); } else { psutil_oserror_wsyscall(syscall); } } static void psutil_convert_ntstatus_err(NTSTATUS status, char *syscall) { ULONG err; if (NT_NTWIN32(status)) err = WIN32_FROM_NTSTATUS(status); else err = RtlNtStatusToDosErrorNoTeb(status); psutil_convert_winerr(err, syscall); } static void psutil_giveup_with_ad(NTSTATUS status, char *syscall) { ULONG err; char fullmsg[2048]; if (NT_NTWIN32(status)) err = WIN32_FROM_NTSTATUS(status); else err = RtlNtStatusToDosErrorNoTeb(status); str_format( fullmsg, sizeof(fullmsg), "%s -> %lu (%s)", syscall, err, strerror(err) ); psutil_debug(fullmsg); psutil_oserror_ad(fullmsg); } /* * 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( DWORD 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 */ SIZE_T size = 0; HANDLE hProcess = NULL; LPCVOID src; WCHAR *buffer = NULL; #ifdef _WIN64 LPVOID ppeb32 = NULL; #else static __NtQueryInformationProcess NtWow64QueryInformationProcess64 = NULL; static _NtWow64ReadVirtualMemory64 NtWow64ReadVirtualMemory64 = NULL; PVOID64 src64; 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 (!ReadProcessMemory(hProcess, ppeb32, &peb32, sizeof(peb32), NULL)) { // May fail with ERROR_PARTIAL_COPY, see: // https://github.com/giampaolo/psutil/issues/875 psutil_convert_winerr(GetLastError(), "ReadProcessMemory"); goto error; } // read process parameters if (!ReadProcessMemory( hProcess, UlongToPtr(peb32.ProcessParameters), &procParameters32, sizeof(procParameters32), NULL )) { // May fail with ERROR_PARTIAL_COPY, see: // https://github.com/giampaolo/psutil/issues/875 psutil_convert_winerr(GetLastError(), "ReadProcessMemory"); 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 // #ifdef _WIN64 // 32 bit process. In here we may run into a lot of errors, e.g.: // * [Error 0] The operation completed successfully // (originated from NtWow64ReadVirtualMemory64) // * [Error 998] Invalid access to memory location: // (originated from NtWow64ReadVirtualMemory64) // Refs: // * https://github.com/giampaolo/psutil/issues/1839 // * https://github.com/giampaolo/psutil/pull/1866 // Since the following code is quite hackish and fails unpredictably, // in case of any error from NtWow64* APIs we raise AccessDenied. // 32 bit case. Check if the target is also 32 bit. if (!IsWow64Process(GetCurrentProcess(), &weAreWow64) || !IsWow64Process(hProcess, &theyAreWow64)) { psutil_oserror_wsyscall("IsWow64Process"); 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 = psutil_GetProcAddressFromLib( "ntdll.dll", "NtWow64QueryInformationProcess64" ); if (NtWow64QueryInformationProcess64 == NULL) { PyErr_Clear(); psutil_oserror_ad( "can't query 64-bit process in 32-bit-WoW mode" ); goto error; } } if (NtWow64ReadVirtualMemory64 == NULL) { NtWow64ReadVirtualMemory64 = psutil_GetProcAddressFromLib( "ntdll.dll", "NtWow64ReadVirtualMemory64" ); if (NtWow64ReadVirtualMemory64 == NULL) { PyErr_Clear(); psutil_oserror_ad( "can't query 64-bit process in 32-bit-WoW mode" ); goto error; } } status = NtWow64QueryInformationProcess64( hProcess, ProcessBasicInformation, &pbi64, sizeof(pbi64), NULL ); if (!NT_SUCCESS(status)) { /* psutil_convert_ntstatus_err( status, "NtWow64QueryInformationProcess64(ProcessBasicInformation)"); */ psutil_giveup_with_ad( status, "NtWow64QueryInformationProcess64(ProcessBasicInformation)" ); goto error; } // read peb status = NtWow64ReadVirtualMemory64( hProcess, pbi64.PebBaseAddress, &peb64, sizeof(peb64), NULL ); if (!NT_SUCCESS(status)) { /* psutil_convert_ntstatus_err( status, "NtWow64ReadVirtualMemory64(pbi64.PebBaseAddress)"); */ psutil_giveup_with_ad( status, "NtWow64ReadVirtualMemory64(pbi64.PebBaseAddress)" ); goto error; } // read process parameters status = NtWow64ReadVirtualMemory64( hProcess, peb64.ProcessParameters, &procParameters64, sizeof(procParameters64), NULL ); if (!NT_SUCCESS(status)) { /* psutil_convert_ntstatus_err( status, "NtWow64ReadVirtualMemory64(peb64.ProcessParameters)"); */ psutil_giveup_with_ad( status, "NtWow64ReadVirtualMemory64(peb64.ProcessParameters)" ); 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; status = NtQueryInformationProcess( hProcess, ProcessBasicInformation, &pbi, sizeof(pbi), NULL ); if (!NT_SUCCESS(status)) { psutil_SetFromNTStatusErr( status, "NtQueryInformationProcess(ProcessBasicInformation)" ); goto error; } // read peb if (!ReadProcessMemory( hProcess, pbi.PebBaseAddress, &peb, sizeof(peb), NULL )) { // May fail with ERROR_PARTIAL_COPY, see: // https://github.com/giampaolo/psutil/issues/875 psutil_convert_winerr(GetLastError(), "ReadProcessMemory"); goto error; } // read process parameters if (!ReadProcessMemory( hProcess, peb.ProcessParameters, &procParameters, sizeof(procParameters), NULL )) { // May fail with ERROR_PARTIAL_COPY, see: // https://github.com/giampaolo/psutil/issues/875 psutil_convert_winerr(GetLastError(), "ReadProcessMemory"); 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) { psutil_oserror_ad("can't query 64-bit process in 32-bit-WoW mode"); goto error; } 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) { status = NtWow64ReadVirtualMemory64( hProcess, src64, buffer, size, NULL ); if (!NT_SUCCESS(status)) { // psutil_convert_ntstatus_err(status, // "NtWow64ReadVirtualMemory64"); psutil_giveup_with_ad(status, "NtWow64ReadVirtualMemory64"); goto error; } } else #endif if (!ReadProcessMemory(hProcess, src, buffer, size, NULL)) { // May fail with ERROR_PARTIAL_COPY, see: // https://github.com/giampaolo/psutil/issues/875 psutil_convert_winerr(GetLastError(), "ReadProcessMemory"); 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. Requires Windows 8.1+. */ static int psutil_cmdline_query_proc(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; int ProcessCommandLineInformation = 60; if (PSUTIL_WINVER < PSUTIL_WINDOWS_8_1) { psutil_runtime_error("requires Windows 8.1+"); goto error; } 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(ProcessBasicInformation) -> " "STATUS_NOT_FOUND" ); goto error; } if (status != STATUS_BUFFER_OVERFLOW && status != STATUS_BUFFER_TOO_SMALL && status != STATUS_INFO_LENGTH_MISMATCH) { psutil_SetFromNTStatusErr( status, "NtQueryInformationProcess(ProcessBasicInformation)" ); 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; } /* * Return a Python list representing the arguments for the process * with given pid or NULL on error. */ 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 pid_return; int use_peb; // TODO: shouldn't this be decref-ed in case of error on // PyArg_ParseTuple? PyObject *py_usepeb = Py_True; PyObject *py_retlist = NULL; PyObject *py_unicode = NULL; static char *keywords[] = {"pid", "use_peb", NULL}; if (!PyArg_ParseTupleAndKeywords( args, kwdict, _Py_PARSE_PID "|O", keywords, &pid, &py_usepeb )) { return NULL; } if ((pid == 0) || (pid == 4)) return Py_BuildValue("[]"); pid_return = psutil_pid_is_running(pid); if (pid_return == 0) return psutil_oserror_nsp("psutil_pid_is_running -> 0"); if (pid_return == -1) return NULL; use_peb = (py_usepeb == Py_True) ? 1 : 0; /* 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 = psutil_get_process_data(pid, KIND_CMDLINE, &data, &size); else func_ret = psutil_cmdline_query_proc(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; int pid_return; if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid)) return NULL; pid_return = psutil_pid_is_running(pid); if (pid_return == 0) return psutil_oserror_nsp("psutil_pid_is_running -> 0"); if (pid_return == -1) return NULL; 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: if (data != NULL) 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_proc_environ(PyObject *self, PyObject *args) { DWORD pid; WCHAR *data = NULL; SIZE_T size; int pid_return; PyObject *ret = NULL; if (!PyArg_ParseTuple(args, _Py_PARSE_PID, &pid)) return NULL; if ((pid == 0) || (pid == 4)) return PyUnicode_FromString(""); pid_return = psutil_pid_is_running(pid); if (pid_return == 0) return psutil_oserror_nsp("psutil_pid_is_running -> 0"); if (pid_return == -1) return NULL; 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: if (data != NULL) free(data); return ret; } /* * Given a process PID and a PSYSTEM_PROCESS_INFORMATION structure * fills the structure with various process information in one shot * 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 * but it doesn't require any privilege (also work for PID 0). * On success return 0, else -1 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; 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 (!NT_SUCCESS(status)) { psutil_SetFromNTStatusErr( status, "NtQuerySystemInformation(SystemProcessInformation)" ); goto error; } if (bufferSize <= 0x20000) initialBufferSize = bufferSize; process = PSUTIL_FIRST_PROCESS(buffer); do { if ((ULONG_PTR)process->UniqueProcessId == pid) { *retProcess = process; *retBuffer = buffer; return 0; } } while ((process = PSUTIL_NEXT_PROCESS(process))); psutil_oserror_nsp("NtQuerySystemInformation (no PID found)"); goto error; error: if (buffer != NULL) free(buffer); return -1; } /* * 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 dict includes the following process info: * * - num_threads() * - ctx_switches() * - num_handles() (fallback) * - cpu_times() (fallback) * - create_time() (fallback) * - io_counters() (fallback) * - memory_info() (fallback) */ PyObject * psutil_proc_oneshot(PyObject *self, PyObject *args) { DWORD pid; PSYSTEM_PROCESS_INFORMATION proc; PVOID buffer = NULL; ULONG i; ULONG ctx_switches = 0; 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_get_proc_info(pid, &proc, &buffer) != 0) goto error; for (i = 0; i < proc->NumberOfThreads; i++) ctx_switches += proc->Threads[i].ContextSwitches; 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, "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, "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; } ================================================ FILE: psutil/arch/windows/proc_utils.c ================================================ /* * 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 #include #include // EnumProcesses #include "../../arch/all/init.h" // Return 1 if PID exists, 0 if not, -1 on error. int psutil_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; } // Given a process handle checks whether it's actually running. If it // does return the handle, else return NULL with Python exception set. // This is needed because OpenProcess API sucks. HANDLE psutil_check_phandle(HANDLE hProcess, DWORD pid, int check_exit_code) { DWORD exitCode; 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"); return NULL; } if (GetLastError() == ERROR_SUCCESS) { // Yeah, it's this bad. // https://github.com/giampaolo/psutil/issues/1877 if (psutil_pid_in_pids(pid) == 1) { psutil_debug("OpenProcess -> ERROR_SUCCESS turned into AD"); psutil_oserror_ad("OpenProcess -> ERROR_SUCCESS"); } else { psutil_debug("OpenProcess -> ERROR_SUCCESS turned into NSP"); psutil_oserror_nsp("OpenProcess -> ERROR_SUCCESS"); } return NULL; } psutil_oserror_wsyscall("OpenProcess"); return NULL; } if (check_exit_code == 0) return hProcess; if (GetExitCodeProcess(hProcess, &exitCode)) { // XXX - maybe STILL_ACTIVE is not fully reliable as per: // http://stackoverflow.com/questions/1591342/#comment47830782_1591379 if (exitCode == STILL_ACTIVE) { return hProcess; } if (psutil_pid_in_pids(pid) == 1) { return hProcess; } CloseHandle(hProcess); psutil_oserror_nsp("GetExitCodeProcess != STILL_ACTIVE"); return NULL; } if (GetLastError() == ERROR_ACCESS_DENIED) { psutil_debug("GetExitCodeProcess -> ERROR_ACCESS_DENIED (ignored)"); SetLastError(0); return hProcess; } psutil_oserror_wsyscall("GetExitCodeProcess"); CloseHandle(hProcess); return NULL; } // 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; 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) && (GetLastError() == ERROR_ACCESS_DENIED)) { psutil_oserror_wsyscall("OpenProcess"); return NULL; } hProcess = psutil_check_phandle(hProcess, pid, 1); return hProcess; } // Check for PID existence. Return 1 if pid exists, 0 if not, -1 on error. int psutil_pid_is_running(DWORD pid) { HANDLE hProcess; // Special case for PID 0 System Idle Process if (pid == 0) return 1; if (pid < 0) return 0; hProcess = OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, FALSE, pid); if (hProcess != NULL) { hProcess = psutil_check_phandle(hProcess, pid, 1); if (hProcess != NULL) { CloseHandle(hProcess); return 1; } CloseHandle(hProcess); } PyErr_Clear(); return psutil_pid_in_pids(pid); } ================================================ FILE: psutil/arch/windows/security.c ================================================ /* * 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 * SE DEBUG). */ #include #include #include "../../arch/all/init.h" static BOOL psutil_set_privilege(HANDLE hToken, LPCTSTR Privilege, BOOL bEnablePrivilege) { TOKEN_PRIVILEGES tp; LUID luid; TOKEN_PRIVILEGES tpPrevious; DWORD cbPrevious = sizeof(TOKEN_PRIVILEGES); if (!LookupPrivilegeValue(NULL, Privilege, &luid)) { psutil_oserror_wsyscall("LookupPrivilegeValue"); return -1; } // first pass. get current privilege setting tp.PrivilegeCount = 1; tp.Privileges[0].Luid = luid; tp.Privileges[0].Attributes = 0; if (!AdjustTokenPrivileges( hToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), &tpPrevious, &cbPrevious )) { psutil_oserror_wsyscall("AdjustTokenPrivileges"); return -1; } // Second pass. Set privilege based on previous setting. tpPrevious.PrivilegeCount = 1; tpPrevious.Privileges[0].Luid = luid; if (bEnablePrivilege) tpPrevious.Privileges[0].Attributes |= (SE_PRIVILEGE_ENABLED); else tpPrevious.Privileges[0].Attributes ^= (SE_PRIVILEGE_ENABLED & tpPrevious.Privileges[0].Attributes); if (!AdjustTokenPrivileges( hToken, FALSE, &tpPrevious, cbPrevious, NULL, NULL )) { psutil_oserror_wsyscall("AdjustTokenPrivileges"); return -1; } return 0; } static HANDLE psutil_get_thisproc_token() { HANDLE hToken = NULL; HANDLE me = GetCurrentProcess(); if (!OpenProcessToken(me, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) { if (GetLastError() == ERROR_NO_TOKEN) { if (!ImpersonateSelf(SecurityImpersonation)) { psutil_oserror_wsyscall("ImpersonateSelf"); return NULL; } if (!OpenProcessToken( me, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken )) { psutil_oserror_wsyscall("OpenProcessToken"); return NULL; } } else { psutil_oserror_wsyscall("OpenProcessToken"); return NULL; } } return hToken; } static void psutil_print_err() { char *msg = "psutil module couldn't set SE DEBUG mode for this process; " "please file an issue against psutil bug tracker"; psutil_debug(msg); if (GetLastError() != ERROR_ACCESS_DENIED) PyErr_WarnEx(PyExc_RuntimeWarning, msg, 1); PyErr_Clear(); } /* * 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_set_se_debug() { HANDLE hToken; if ((hToken = psutil_get_thisproc_token()) == NULL) { // "return -1;" to get an exception psutil_print_err(); return 0; } if (psutil_set_privilege(hToken, SE_DEBUG_NAME, TRUE) != 0) { // "return -1;" to get an exception psutil_print_err(); } RevertToSelf(); CloseHandle(hToken); return 0; } ================================================ FILE: psutil/arch/windows/sensors.c ================================================ /* * 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 #include #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 sps.BatteryLifeTime // remaining secs ); } ================================================ FILE: psutil/arch/windows/services.c ================================================ /* * 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 #include #include #include "../../arch/all/init.h" // ================================================================== // utils // ================================================================== SC_HANDLE psutil_get_service_handler( const wchar_t *service_name, DWORD scm_access, DWORD access ) { SC_HANDLE sc = NULL; SC_HANDLE hService = NULL; sc = OpenSCManagerW(NULL, NULL, scm_access); if (sc == NULL) { psutil_oserror_wsyscall("OpenSCManagerW"); return NULL; } hService = OpenServiceW(sc, service_name, access); if (hService == NULL) { psutil_oserror_wsyscall("OpenServiceW"); CloseServiceHandle(sc); 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) { switch (startup) { case SERVICE_AUTO_START: return "automatic"; case SERVICE_DEMAND_START: 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"; default: return "unknown"; } } // XXX - expose these as constants? static const char * get_state_string(DWORD state) { switch (state) { case SERVICE_RUNNING: return "running"; case SERVICE_PAUSED: return "paused"; case SERVICE_START_PENDING: return "start_pending"; case SERVICE_PAUSE_PENDING: return "pause_pending"; case SERVICE_CONTINUE_PENDING: return "continue_pending"; case SERVICE_STOP_PENDING: return "stop_pending"; case SERVICE_STOPPED: return "stopped"; default: return "unknown"; } } // ================================================================== // APIs // ================================================================== /* * Enumerate all services. */ PyObject * psutil_winservice_enumerate(PyObject *self, PyObject *args) { ENUM_SERVICE_STATUS_PROCESSW *lpService = NULL; BOOL ok; SC_HANDLE sc = NULL; DWORD bytesNeeded = 0; DWORD srvCount; DWORD resumeHandle = 0; DWORD dwBytes = 0; DWORD i; PyObject *py_retlist = PyList_New(0); PyObject *py_name = NULL; PyObject *py_display_name = NULL; if (py_retlist == NULL) return NULL; sc = OpenSCManager(NULL, NULL, SC_MANAGER_ENUMERATE_SERVICE); if (sc == NULL) { psutil_oserror_wsyscall("OpenSCManager"); return NULL; } for (;;) { ok = EnumServicesStatusExW( sc, SC_ENUM_PROCESS_INFO, SERVICE_WIN32, // XXX - extend this to include drivers etc.? SERVICE_STATE_ALL, (LPBYTE)lpService, dwBytes, &bytesNeeded, &srvCount, &resumeHandle, NULL ); if (ok || (GetLastError() != ERROR_MORE_DATA)) break; if (lpService) free(lpService); dwBytes = bytesNeeded; lpService = (ENUM_SERVICE_STATUS_PROCESSW *)malloc(dwBytes); } for (i = 0; i < srvCount; i++) { // 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; py_display_name = NULL; py_display_name = PyUnicode_FromWideChar( lpService[i].lpDisplayName, wcslen(lpService[i].lpDisplayName) ); if (py_display_name == NULL) goto error; // Construct the result. if (!pylist_append_fmt(py_retlist, "(OO)", py_name, py_display_name)) goto error; Py_DECREF(py_display_name); Py_DECREF(py_name); } // Free resources. CloseServiceHandle(sc); free(lpService); return py_retlist; error: Py_DECREF(py_name); Py_XDECREF(py_display_name); Py_DECREF(py_retlist); if (sc != NULL) CloseServiceHandle(sc); if (lpService != NULL) free(lpService); return NULL; } /* * Get service config information. Returns: * - display_name * - binpath * - username * - startup_type */ PyObject * psutil_winservice_query_config(PyObject *self, PyObject *args) { wchar_t *service_name = NULL; SC_HANDLE hService = NULL; BOOL ok; DWORD bytesNeeded = 0; 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; hService = psutil_get_service_from_args( args, SC_MANAGER_ENUMERATE_SERVICE, SERVICE_QUERY_CONFIG, &service_name ); if (hService == NULL) return NULL; // First call to QueryServiceConfigW() is necessary to get the // right size. bytesNeeded = 0; QueryServiceConfigW(hService, NULL, 0, &bytesNeeded); if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) { psutil_oserror_wsyscall("QueryServiceConfigW"); goto error; } qsc = (QUERY_SERVICE_CONFIGW *)malloc(bytesNeeded); if (qsc == NULL) { PyErr_NoMemory(); goto error; } ok = QueryServiceConfigW(hService, qsc, bytesNeeded, &bytesNeeded); if (!ok) { psutil_oserror_wsyscall("QueryServiceConfigW"); goto error; } // Get unicode display name. 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_FromWideChar( qsc->lpBinaryPathName, wcslen(qsc->lpBinaryPathName) ); if (py_unicode_binpath == NULL) goto error; // Get unicode username. py_unicode_username = PyUnicode_FromWideChar( qsc->lpServiceStartName, wcslen(qsc->lpServiceStartName) ); if (py_unicode_username == NULL) goto error; // Construct result tuple. py_tuple = Py_BuildValue( "(OOOs)", py_unicode_display_name, py_unicode_binpath, py_unicode_username, get_startup_string(qsc->dwStartType) // startup ); if (py_tuple == NULL) goto error; // Free resources. Py_DECREF(py_unicode_display_name); Py_DECREF(py_unicode_binpath); Py_DECREF(py_unicode_username); free(qsc); CloseServiceHandle(hService); PyMem_Free(service_name); return py_tuple; error: Py_XDECREF(py_unicode_display_name); Py_XDECREF(py_unicode_binpath); Py_XDECREF(py_unicode_username); Py_XDECREF(py_tuple); if (hService) CloseServiceHandle(hService); if (qsc) free(qsc); if (service_name) PyMem_Free(service_name); return NULL; } /* * Get service status information. Returns: * - status * - pid */ PyObject * psutil_winservice_query_status(PyObject *self, PyObject *args) { wchar_t *service_name = NULL; SC_HANDLE hService = NULL; BOOL ok; DWORD bytesNeeded = 0; SERVICE_STATUS_PROCESS *ssp = NULL; PyObject *py_tuple = NULL; hService = psutil_get_service_from_args( args, SC_MANAGER_ENUMERATE_SERVICE, SERVICE_QUERY_STATUS, &service_name ); if (hService == NULL) return NULL; // First call to QueryServiceStatusEx() is necessary to get the // right size. QueryServiceStatusEx( hService, SC_STATUS_PROCESS_INFO, NULL, 0, &bytesNeeded ); if (GetLastError() == ERROR_MUI_FILE_NOT_FOUND) { // Also services.msc fails in the same manner, so we return an // empty string. CloseServiceHandle(hService); PyMem_Free(service_name); return PyUnicode_FromString(""); } if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) { psutil_oserror_wsyscall("QueryServiceStatusEx"); goto error; } ssp = (SERVICE_STATUS_PROCESS *)HeapAlloc( GetProcessHeap(), 0, bytesNeeded ); if (ssp == NULL) { PyErr_NoMemory(); goto error; } // Actual call. ok = QueryServiceStatusEx( hService, SC_STATUS_PROCESS_INFO, (LPBYTE)ssp, bytesNeeded, &bytesNeeded ); if (!ok) { psutil_oserror_wsyscall("QueryServiceStatusEx"); goto error; } py_tuple = Py_BuildValue( "(sk)", get_state_string(ssp->dwCurrentState), ssp->dwProcessId ); if (py_tuple == NULL) goto error; CloseServiceHandle(hService); HeapFree(GetProcessHeap(), 0, ssp); PyMem_Free(service_name); return py_tuple; error: Py_XDECREF(py_tuple); if (hService) CloseServiceHandle(hService); if (ssp) HeapFree(GetProcessHeap(), 0, ssp); if (service_name) PyMem_Free(service_name); return NULL; } PyObject * psutil_winservice_query_descr(PyObject *self, PyObject *args) { BOOL ok; DWORD bytesNeeded = 0; SC_HANDLE hService = NULL; SERVICE_DESCRIPTIONW *scd = NULL; wchar_t *service_name = NULL; PyObject *py_retstr = NULL; hService = psutil_get_service_from_args( args, SC_MANAGER_ENUMERATE_SERVICE, SERVICE_QUERY_CONFIG, &service_name ); if (hService == NULL) return NULL; QueryServiceConfig2W( hService, SERVICE_CONFIG_DESCRIPTION, NULL, 0, &bytesNeeded ); if ((GetLastError() == ERROR_NOT_FOUND) || (GetLastError() == ERROR_MUI_FILE_NOT_FOUND)) { // E.g. services.msc fails in this manner, so we return an // empty string. psutil_debug("set empty string for NOT_FOUND service description"); CloseServiceHandle(hService); PyMem_Free(service_name); return PyUnicode_FromString(""); } if (GetLastError() != ERROR_INSUFFICIENT_BUFFER) { psutil_oserror_wsyscall("QueryServiceConfig2W"); goto error; } scd = (SERVICE_DESCRIPTIONW *)malloc(bytesNeeded); if (scd == NULL) { PyErr_NoMemory(); goto error; } ok = QueryServiceConfig2W( hService, SERVICE_CONFIG_DESCRIPTION, (LPBYTE)scd, bytesNeeded, &bytesNeeded ); if (!ok) { psutil_oserror_wsyscall("QueryServiceConfig2W"); goto error; } if (scd->lpDescription == NULL) { py_retstr = PyUnicode_FromString(""); } else { 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) CloseServiceHandle(hService); if (scd) free(scd); if (service_name) PyMem_Free(service_name); return NULL; } /* * Start service. * XXX - note: this is exposed but not used. */ PyObject * psutil_winservice_start(PyObject *self, PyObject *args) { BOOL ok; SC_HANDLE hService = NULL; wchar_t *service_name = NULL; hService = psutil_get_service_from_args( args, SC_MANAGER_ALL_ACCESS, SERVICE_START, &service_name ); if (hService == NULL) return NULL; ok = StartService(hService, 0, NULL); if (!ok) { psutil_oserror_wsyscall("StartService"); goto error; } CloseServiceHandle(hService); PyMem_Free(service_name); Py_RETURN_NONE; error: if (hService) CloseServiceHandle(hService); if (service_name) PyMem_Free(service_name); return NULL; } /* * Stop service. * XXX - note: this is exposed but not used. */ PyObject * psutil_winservice_stop(PyObject *self, PyObject *args) { wchar_t *service_name = NULL; BOOL ok; SC_HANDLE hService = NULL; SERVICE_STATUS ssp; hService = psutil_get_service_from_args( args, SC_MANAGER_ALL_ACCESS, SERVICE_STOP, &service_name ); if (hService == NULL) 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) { psutil_oserror_wsyscall("ControlService"); goto error; } CloseServiceHandle(hService); PyMem_Free(service_name); Py_RETURN_NONE; error: if (hService) CloseServiceHandle(hService); if (service_name) PyMem_Free(service_name); return NULL; } ================================================ FILE: psutil/arch/windows/socks.c ================================================ /* * 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 #include #include #include "../../arch/all/init.h" #define BYTESWAP_USHORT(x) ((((USHORT)(x) << 8) | ((USHORT)(x) >> 8)) & 0xffff) #define STATUS_UNSUCCESSFUL 0xC0000001 // 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 = 0; TCP_TABLE_CLASS class = TCP_TABLE_OWNER_PID_ALL; GetExtendedTcpTable(NULL, &size, FALSE, family, class, 0); // reserve 25% more space to be sure size = size + (size / 2 / 2); table = malloc(size); if (table == NULL) { PyErr_NoMemory(); return NULL; } err = GetExtendedTcpTable(table, &size, FALSE, family, class, 0); if (err == NO_ERROR) return table; free(table); if (err == ERROR_INSUFFICIENT_BUFFER || err == STATUS_UNSUCCESSFUL) { psutil_debug("GetExtendedTcpTable: retry with different bufsize"); return __GetExtendedTcpTable(family); } psutil_runtime_error("GetExtendedTcpTable failed"); return NULL; } static PVOID __GetExtendedUdpTable(ULONG family) { DWORD err; PVOID table; ULONG size = 0; UDP_TABLE_CLASS class = UDP_TABLE_OWNER_PID; GetExtendedUdpTable(NULL, &size, FALSE, family, class, 0); // reserve 25% more space size = size + (size / 2 / 2); table = malloc(size); if (table == NULL) { PyErr_NoMemory(); return NULL; } err = GetExtendedUdpTable(table, &size, FALSE, family, class, 0); if (err == NO_ERROR) return table; free(table); if (err == ERROR_INSUFFICIENT_BUFFER || err == STATUS_UNSUCCESSFUL) { psutil_debug("GetExtendedUdpTable: retry with different bufsize"); return __GetExtendedUdpTable(family); } psutil_runtime_error("GetExtendedUdpTable failed"); return NULL; } #define psutil_conn_decref_objs() \ Py_DECREF(_AF_INET); \ Py_DECREF(_AF_INET6); \ Py_DECREF(_SOCK_STREAM); \ Py_DECREF(_SOCK_DGRAM); /* * 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; int pid_return; 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; 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; 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, _Py_PARSE_PID "OO", &pid, &py_af_filter, &py_type_filter )) { goto error; } 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) { pid_return = psutil_pid_is_running(pid); if (pid_return == 0) { psutil_conn_decref_objs(); return psutil_oserror_nsp("psutil_pid_is_running"); } else if (pid_return == -1) { 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_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; if (!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 )) { goto error; } py_addr_tuple_local = NULL; py_addr_tuple_remote = NULL; } free(table); table = NULL; } // TCP IPv6 if ((PySequence_Contains(py_af_filter, _AF_INET6) == 1) && (PySequence_Contains(py_type_filter, _SOCK_STREAM) == 1) && (RtlIpv6AddressToStringA != NULL)) { 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; if (!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 )) { goto error; } py_addr_tuple_local = NULL; py_addr_tuple_remote = NULL; } free(table); table = NULL; } // UDP IPv4 if ((PySequence_Contains(py_af_filter, _AF_INET) == 1) && (PySequence_Contains(py_type_filter, _SOCK_DGRAM) == 1)) { 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; if (!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 )) { goto error; } py_addr_tuple_local = NULL; } free(table); table = NULL; } // UDP IPv6 if ((PySequence_Contains(py_af_filter, _AF_INET6) == 1) && (PySequence_Contains(py_type_filter, _SOCK_DGRAM) == 1) && (RtlIpv6AddressToStringA != NULL)) { 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; if (!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 )) { goto error; } py_addr_tuple_local = NULL; } free(table); table = NULL; } psutil_conn_decref_objs(); return py_retlist; error: psutil_conn_decref_objs(); Py_XDECREF(py_addr_tuple_local); Py_XDECREF(py_addr_tuple_remote); Py_DECREF(py_retlist); if (table != NULL) free(table); return NULL; } ================================================ FILE: psutil/arch/windows/sys.c ================================================ /* * 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 #include #include "ntextapi.h" #include "../../arch/all/init.h" // The number of seconds passed since boot. This is a monotonic timer, // not affected by system clock updates. On Windows 7+ it also includes // the time spent during suspend / hybernate. PyObject * psutil_uptime(PyObject *self, PyObject *args) { double uptimeSeconds; ULONGLONG interruptTime100ns = 0; if (QueryInterruptTime) { // Windows 7+ QueryInterruptTime(&interruptTime100ns); // Convert from 100-nanosecond to seconds. uptimeSeconds = interruptTime100ns / 10000000.0; } else { // Convert from milliseconds to seconds. uptimeSeconds = (double)GetTickCount64() / 1000.0; } return Py_BuildValue("d", uptimeSeconds); } 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; 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 return py_retlist; } if (WTSEnumerateSessionsW(hServer, 0, 1, &sessions, &count) == 0) { if (ERROR_CALL_NOT_IMPLEMENTED == GetLastError()) { // On Windows Nano server, the Wtsapi32 API can be present, but // return WinError 120. 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; if (WTSQuerySessionInformationW( hServer, sessionId, WTSUserName, &buffer_user, &bytes ) == 0) { psutil_oserror_wsyscall("WTSQuerySessionInformationW"); goto error; } if (bytes <= 2) continue; // address bytes = 0; if (WTSQuerySessionInformationW( hServer, sessionId, WTSClientAddress, &buffer_addr, &bytes ) == 0) { psutil_oserror_wsyscall("WTSQuerySessionInformationW"); goto error; } address = (PWTS_CLIENT_ADDRESS)buffer_addr; if (address->AddressFamily == 2) { // AF_INET == 2 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; if (WTSQuerySessionInformationW( hServer, sessionId, WTSSessionInfo, &buffer_info, &bytes ) == 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); WTSFreeMemory(buffer_user); WTSFreeMemory(buffer_addr); 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; } ================================================ FILE: psutil/arch/windows/wmi.c ================================================ /* * 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 #include #include #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; } /* * Gets the emulated 1 minute, 5 minute and 15 minute load averages * (processor queue length) for the system. * `init_loadavg_counter` must be called before this function 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 ); } ================================================ FILE: pyproject.toml ================================================ [tool.black] target-version = ["py37"] line-length = 79 skip-string-normalization = true # https://black.readthedocs.io/en/stable/the_black_code_style/future_style.html preview = true enable-unstable-feature = ["hug_parens_with_braces_and_square_brackets", "string_processing", "wrap_long_dict_values_in_parens"] [tool.ruff] # https://beta.ruff.rs/docs/settings/ target-version = "py37" line-length = 79 [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 "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 "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"] "tests/*" = ["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 [tool.cibuildwheel] skip = [ "cp3{8,9,10,11,12}-*linux_{ppc64le,s390x} cp3*t-musllinux*", ] test-extras = ["test"] # same as doing `pip install .[test]` test-command = "make -C {project} PYTHON=python PSUTIL_ROOT_DIR=\"{project}\" ci-test-cibuildwheel" # Run tests on Python 3.13. On all other Python versions do a lightweight # import test. [[tool.cibuildwheel.overrides]] select = "cp3{8,9,10,11,12,13t,14,14t}-* cp313-macosx* *-musllinux*" test-extras = [] test-command = "python -c \"import psutil; print(psutil.__version__)\"" [[tool.cibuildwheel.overrides]] select = "cp38-macosx*" # In macOS use Python 3.8: higher Python version hang for some reason. test-extras = ["test"] test-command = "make -C {project} PYTHON=python PSUTIL_ROOT_DIR=\"{project}\" ci-test-cibuildwheel" [tool.pytest] addopts = [ "--capture=no", "--instafail", "--no-header", "--strict-config", "--strict-markers", "--tb=short", "--verbose", "-p instafail", "-p no:doctest", "-p no:junitxml", "-p no:nose", "-p no:pastebin", "-p xdist", ] verbosity_subtests = "0" testpaths = ["tests/"] python_files = ["test_*.py"] [build-system] build-backend = "setuptools.build_meta" requires = ["setuptools>=43"] ================================================ FILE: scripts/battery.py ================================================ #!/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() ================================================ FILE: scripts/cpu_distribution.py ================================================ #!/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.info['cpu_num']].append(p.info['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() ================================================ FILE: scripts/disk_usage.py ================================================ #!/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. $ 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 os import sys import psutil from psutil._common import bytes2human def main(): 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 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) line = templ.format( part.device, bytes2human(usage.total), bytes2human(usage.used), bytes2human(usage.free), int(usage.percent), part.fstype, part.mountpoint, ) print(line) if __name__ == '__main__': sys.exit(main()) ================================================ FILE: scripts/fans.py ================================================ #!/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() ================================================ FILE: scripts/free.py ================================================ #!/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. $ python3 scripts/free.py total used free shared buffers cache Mem: 10125520 8625996 1499524 0 349500 3307836 Swap: 0 0 0 """ import psutil def main(): virt = psutil.virtual_memory() swap = psutil.swap_memory() 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(sect) sect = templ.format( 'Swap:', int(swap.total / 1024), int(swap.used / 1024), int(swap.free / 1024), '', '', '', ) print(sect) if __name__ == '__main__': main() ================================================ FILE: scripts/ifconfig.py ================================================ #!/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. $ 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 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 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 """ import socket import psutil from psutil._common import bytes2human af_map = { socket.AF_INET: 'IPv4', socket.AF_INET6: 'IPv6', psutil.AF_LINK: 'MAC', } duplex_map = { psutil.NIC_DUPLEX_FULL: "full", psutil.NIC_DUPLEX_HALF: "half", psutil.NIC_DUPLEX_UNKNOWN: "?", } 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: 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: fam = " {:<4}".format(af_map.get(addr.family, addr.family)) print(fam, end="") print(f" address : {addr.address}") if addr.broadcast: print(f" broadcast : {addr.broadcast}") if addr.netmask: print(f" netmask : {addr.netmask}") if addr.ptp: print(f" p2p : {addr.ptp}") print() if __name__ == '__main__': main() ================================================ FILE: scripts/internal/README ================================================ This directory contains scripts which are meant to be used internally (benchmarks, CI automation, etc.). ================================================ FILE: scripts/internal/bench_oneshot.py ================================================ #!/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 sys import textwrap import timeit import psutil ITERATIONS = 1000 # 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', 'name', 'num_ctx_switches', 'num_threads', 'ppid', 'status', 'terminal', 'uids', ] elif psutil.BSD: names = [ 'cpu_times', 'gids', 'io_counters', 'memory_footprint', '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', ] names = sorted(set(names)) setup = 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 main(): print( f"{len(names)} methods involved on platform" f" {sys.platform!r} ({ITERATIONS} iterations, psutil" f" {psutil.__version__}):" ) for name in sorted(names): print(" " + name) # "normal" run elapsed1 = timeit.timeit( "call_normal(funs)", setup=setup, number=ITERATIONS ) print(f"normal: {elapsed1:.3f} secs") # "one shot" run elapsed2 = timeit.timeit( "call_oneshot(funs)", setup=setup, number=ITERATIONS ) print(f"onshot: {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() ================================================ FILE: scripts/internal/bench_oneshot_2.py ================================================ #!/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() ================================================ FILE: scripts/internal/convert_readme.py ================================================ #!/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 `_ - `Documentation `_ - `Who uses psutil `_ - `Download `_ - `Blog `_ - `What's new `_ """ 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(".. "): excluding = True continue if line.startswith(".. "): excluding = False continue if not excluding: lines.append(line) text = "".join(lines) # Rewrite summary text = re.sub( r".. raw:: html\n+\s+
    ", quick_links, text ) print(text) if __name__ == '__main__': main() ================================================ FILE: scripts/internal/download_wheels.py ================================================ #!/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" 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() download_zip(data['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() ================================================ FILE: scripts/internal/find_adopters.py ================================================ #!/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/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} `__" 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() ================================================ FILE: scripts/internal/find_broken_links.py ================================================ #!/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 (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 memoize(fun): """A memoize decorator.""" @functools.wraps(fun) def wrapper(*args, **kwargs): key = (args, frozenset(sorted(kwargs.items()))) try: return cache[key] except KeyError: ret = cache[key] = fun(*args, **kwargs) return ret cache = {} return wrapper 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) ================================================ FILE: scripts/internal/generate_manifest.py ================================================ #!/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', '.svg') SKIP_FILES = () SKIP_PREFIXES = ('.ci/', '.github/') 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) print("recursive-exclude docs/_static *") if __name__ == '__main__': main() ================================================ FILE: scripts/internal/git_pre_commit.py ================================================ #!/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() ================================================ FILE: scripts/internal/install-sysdeps.sh ================================================ #!/bin/sh # Depending on the UNIX platform, install the necessary system dependencies to: # * compile psutil # * run those unit tests that rely on CLI tools (netstat, ps, etc.) # NOTE: this script MUST be kept compatible with the `sh` shell. set -e UNAME_S=$(uname -s) case "$UNAME_S" in Linux) if command -v apt > /dev/null 2>&1; then HAS_APT=true # debian / ubuntu elif command -v yum > /dev/null 2>&1; then HAS_YUM=true # 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 # Function to install system dependencies main() { if [ $HAS_APT ]; then $SUDO apt-get install -y python3-dev gcc $SUDO apt-get install -y net-tools coreutils util-linux sudo # for tests elif [ $HAS_YUM ]; then $SUDO yum install -y python3-devel gcc $SUDO yum install -y net-tools coreutils-single util-linux sudo procps-ng # for tests elif [ $HAS_PACMAN ]; then $SUDO pacman -S --noconfirm python gcc $SUDO pacman -S --noconfirm net-tools coreutils util-linux sudo # for tests elif [ $HAS_APK ]; then $SUDO apk add --no-interactive python3-dev gcc musl-dev linux-headers $SUDO apk add --no-interactive coreutils util-linux procps # for tests elif [ $FREEBSD ]; then $SUDO pkg install -y python3 gcc elif [ $NETBSD ]; then $SUDO /usr/sbin/pkg_add -v pkgin $SUDO pkgin update $SUDO pkgin -y install python311-* gcc12-* if [ ! -e /usr/pkg/bin/python3 ]; then $SUDO ln -s /usr/pkg/bin/python3.11 /usr/pkg/bin/python3 fi elif [ $OPENBSD ]; then $SUDO pkg_add gcc python3 elif [ $SUNOS ]; then $SUDO pkg install developer/gcc else echo "Unsupported platform '$UNAME_S'. Ignoring." fi } main ================================================ FILE: scripts/internal/install_pip.py ================================================ #!/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 sys try: import pip # noqa: F401 except ImportError: pass else: print("pip already installed") sys.exit(0) import os import ssl import tempfile from urllib.request import urlopen URL = "https://bootstrap.pypa.io/get-pip.py" def main(): ssl_context = ( ssl._create_unverified_context() if hasattr(ssl, "_create_unverified_context") else None ) 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 = os.system( f"{sys.executable} {f.name} --user --upgrade" " --break-system-packages" ) sys.exit(code) if __name__ == "__main__": main() ================================================ FILE: scripts/internal/print_access_denied.py ================================================ #!/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() ================================================ FILE: scripts/internal/print_announce.py ================================================ #!/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 = 'http://psutil.readthedocs.io' PRJ_URL_DOWNLOAD = 'https://pypi.org/project/psutil/#files' PRJ_URL_WHATSNEW = 'https://psutil.readthedocs.io/en/latest/changelog.html' 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() ================================================ FILE: scripts/internal/print_api_speed.py ================================================ #!/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 ------------------------------------------------- disk_usage 300 0.00157 cpu_count 300 0.00255 pid_exists 300 0.00792 cpu_times 300 0.01044 boot_time 300 0.01136 cpu_percent 300 0.01290 cpu_times_percent 300 0.01515 virtual_memory 300 0.01594 users 300 0.01964 net_io_counters 300 0.02027 cpu_stats 300 0.02034 net_if_addrs 300 0.02962 swap_memory 300 0.03209 sensors_battery 300 0.05186 pids 300 0.07954 net_if_stats 300 0.09321 disk_io_counters 300 0.09406 cpu_count (cores) 300 0.10293 disk_partitions 300 0.10345 cpu_freq 300 0.20817 sensors_fans 300 0.63476 sensors_temperatures 231 2.00039 process_iter (all) 171 2.01300 net_connections 97 2.00206 PROCESS APIS NUM CALLS SECONDS ------------------------------------------------- create_time 300 0.00009 exe 300 0.00015 nice 300 0.00057 ionice 300 0.00091 cpu_affinity 300 0.00091 cwd 300 0.00151 num_fds 300 0.00391 memory_info 300 0.00597 memory_percent 300 0.00648 memory_info_ex 300 0.00701 io_counters 300 0.00707 name 300 0.00894 status 300 0.00900 ppid 300 0.00906 num_threads 300 0.00932 cpu_num 300 0.00933 num_ctx_switches 300 0.00943 uids 300 0.00979 gids 300 0.01002 cpu_times 300 0.01008 cmdline 300 0.01009 terminal 300 0.01059 is_running 300 0.01063 threads 300 0.01209 connections 300 0.01276 cpu_percent 300 0.01463 open_files 300 0.01630 username 300 0.01655 environ 300 0.02250 memory_foorprint 300 0.07066 memory_maps 300 0.74281 """ 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 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): fun(*args, **kw) elapsed = timer() - t if elapsed > 2: break print("\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 main(): global TIMES parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.RawTextHelpFormatter ) parser.add_argument('-t', '--times', type=int, default=TIMES) args = parser.parse_args() TIMES = args.times assert TIMES > 1, TIMES try: set_highest_priority() except psutil.AccessDenied: prio_set = False else: prio_set = True # --- system public_apis = [] ignore = [ '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 = (os.getpid(),) 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") ignore = [ 'send_signal', 'suspend', 'resume', 'terminate', 'kill', 'wait', 'as_dict', 'parent', 'parents', 'oneshot', 'pid', 'rlimit', 'children', ] if psutil.MACOS: ignore.append('memory_maps') # XXX p = psutil.Process() for name in sorted(dir(p)): if not name.startswith('_') and name not in ignore: fun = getattr(p, name) 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() ================================================ FILE: scripts/internal/print_dist.py ================================================ #!/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 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 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' 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 main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( 'dir', nargs="?", default="dist", help='directory containing tar.gz or wheel files', ) 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 __name__ == '__main__': main() ================================================ FILE: scripts/internal/print_downloads.py ================================================ #!/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 statistics in MarkDown format. Useful sites: * https://pepy.tech/project/psutil * https://pypistats.org/packages/psutil * https://hugovk.github.io/top-pypi-packages/. """ import functools import json import os import shlex import subprocess import sys import pypinfo # noqa: F401 AUTH_FILE = os.path.expanduser("~/.pypinfo.json") PKGNAME = 'psutil' DAYS = 30 LIMIT = 100 GITHUB_SCRIPT_URL = ( "https://github.com/giampaolo/psutil/blob/master/" "scripts/internal/pypistats.py" ) LAST_UPDATE = None bytes_billed = 0 # --- get @functools.lru_cache 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 def query(cmd): global bytes_billed ret = json.loads(sh(cmd)) bytes_billed += ret['query']['bytes_billed'] return ret def top_packages(): global LAST_UPDATE ret = query( f"pypinfo --all --json --days {DAYS} --limit {LIMIT} '' project" ) LAST_UPDATE = ret['last_update'] return [(x['project'], x['download_count']) for x in ret['rows']] def ranking(): data = top_packages() for i, (name, downloads) in enumerate(data, start=1): if name == PKGNAME: return i raise ValueError(f"can't find {PKGNAME}") def downloads(): data = top_packages() for name, downloads in data: if name == PKGNAME: return downloads raise ValueError(f"can't find {PKGNAME}") def downloads_pyver(): return query(f"pypinfo --json --days {DAYS} {PKGNAME} pyversion") def downloads_by_country(): return query(f"pypinfo --json --days {DAYS} {PKGNAME} country") def downloads_by_system(): return query(f"pypinfo --json --days {DAYS} {PKGNAME} system") def downloads_by_distro(): return query(f"pypinfo --json --days {DAYS} {PKGNAME} distro") # --- print templ = "| {:<30} | {:>15} |" def print_row(left, right): if isinstance(right, int): right = f"{right:,}" print(templ.format(left, right)) def print_header(left, right="Downloads"): print_row(left, right) s = templ.format("-" * 30, "-" * 15) print("|:" + s[2:-2] + ":|") def print_markdown_table(title, left, rows): pleft = left.replace('_', ' ').capitalize() print("### " + title) print() print_header(pleft) for row in rows: lval = row[left] print_row(lval, row['download_count']) print() def main(): downs = downloads() print("# Download stats") print() s = f"psutil download statistics of the last {DAYS} days (last update " s += f"*{LAST_UPDATE}*).\n" s += f"Generated via [pypistats.py]({GITHUB_SCRIPT_URL}) script.\n" print(s) data = [ {'what': 'Per month', 'download_count': downs}, {'what': 'Per day', 'download_count': int(downs / 30)}, {'what': 'PYPI ranking', 'download_count': ranking()}, ] print_markdown_table('Overview', 'what', data) print_markdown_table( 'Operating systems', 'system_name', downloads_by_system()['rows'] ) print_markdown_table( 'Distros', 'distro_name', downloads_by_distro()['rows'] ) print_markdown_table( 'Python versions', 'python_version', downloads_pyver()['rows'] ) print_markdown_table( 'Countries', 'country', downloads_by_country()['rows'] ) if __name__ == '__main__': try: main() finally: print(f"bytes billed: {bytes_billed}", file=sys.stderr) ================================================ FILE: scripts/internal/print_hashes.py ================================================ #!/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() ================================================ FILE: scripts/internal/print_sysinfo.py ================================================ #!/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._common 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, file=sys.stderr) for k, v in info.items(): print("{:<17} {}".format(k + ":", v), file=sys.stderr) print("=" * 70, file=sys.stderr) sys.stdout.flush() if __name__ == "__main__": main() ================================================ FILE: scripts/internal/purge_installation.py ================================================ #!/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() ================================================ FILE: scripts/internal/rst_check_dead_refs.py ================================================ #!/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 two classes of reference errors: 1. Hyperlink targets with a URL that are defined but never referenced. 2. Backtick references (`name`_) that point to an undefined target. Targets and references are resolved across all files passed as arguments, so cross-file references work correctly. Usage:: python3 scripts/internal/rst_check_dead_refs.py docs/*.rst """ import argparse import os import re import sys # .. _`Foo Bar`: https://... or .. _foo: https://... (URL targets only) RE_URL_TARGET = re.compile( r'^\.\. _`?([^`\n:]+)`?\s*:\s*(https?://\S+)', re.MULTILINE, ) # .. _`Foo Bar`: or .. _foo: (any target, with or without URL) RE_ANY_TARGET = re.compile( r'^\.\. _`?([^`\n:]+)`?\s*:', re.MULTILINE, ) # `Foo Bar`_ but NOT `text `_ and NOT `text`__ RE_REF = re.compile(r'`([^`<\n]+)`_(?!_)') # .. include:: somefile.rst RE_INCLUDE = re.compile(r'^\.\. include::\s*(\S+)', re.MULTILINE) def line_number(text, pos): return text.count('\n', 0, pos) + 1 def read_with_includes(path, _seen=None): """Return file text plus the text of any ``.. include::`` files.""" if _seen is None: _seen = set() path = os.path.normpath(path) if path in _seen: return "" _seen.add(path) try: with open(path) as f: text = f.read() except OSError: return "" base = os.path.dirname(path) for m in RE_INCLUDE.finditer(text): inc = os.path.join(base, m.group(1)) text += read_with_includes(inc, _seen) return text def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("files", nargs="+", metavar="FILE") args = parser.parse_args() # Pass 1: collect all defined targets across all files. # Targets from ".. include::" files are also collected so that # cross-file references resolve correctly. all_targets = set() # URL-only targets defined directly in a file (not via include), used # to detect targets that are defined but never referenced. url_targets = {} for path in args.files: # Use expanded text (with includes) so cross-file references resolve. expanded = read_with_includes(path) for m in RE_ANY_TARGET.finditer(expanded): # noqa: FURB142 all_targets.add(m.group(1).strip().lower()) # Only record URL targets from the file itself, not from includes, # so we don't falsely report included targets as unreferenced. with open(path) as f: own_text = f.read() for m in RE_URL_TARGET.finditer(own_text): name = m.group(1).strip() url_targets[name.lower()] = ( name, path, line_number(own_text, m.start()), ) # Pass 2: collect all backtick references (with file + line). all_refs = [] # list of (lower-case name, original, file, lineno) referenced = set() # lower-case names of all referenced targets for path in args.files: with open(path) as f: text = f.read() for m in RE_REF.finditer(text): # references from the file itself only name = m.group(1).strip() all_refs.append(( name.lower(), name, path, line_number(text, m.start()), )) referenced.add(name.lower()) errors = [] # Check 1: URL targets that are never referenced. for key, (name, path, lineno) in url_targets.items(): if key not in referenced: errors.append( (path, lineno, f"unreferenced hyperlink target: {name!r}") ) # Check 2: backtick references with no matching target. for key, name, path, lineno in all_refs: if key not in all_targets: errors.append((path, lineno, f"unknown target name: {name!r}")) errors.sort() for path, lineno, msg in errors: print(f"{path}:{lineno}: {msg}") if errors: sys.exit(1) if __name__ == "__main__": main() ================================================ FILE: scripts/iotop.py ================================================ #!/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 disk I/O statistics. 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: $ 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 3260 giampao 0.00 B/s 0.00 B/s bash 3779 giampao 0.00 B/s 0.00 B/s gnome-session --session=ubuntu 3830 giampao 0.00 B/s 0.00 B/s /usr/bin/dbus-launch 3831 giampao 0.00 B/s 0.00 B/s //bin/dbus-daemon --fork --print-pid 5 3841 giampao 0.00 B/s 0.00 B/s /usr/lib/at-spi-bus-launcher 3845 giampao 0.00 B/s 0.00 B/s /bin/dbus-daemon 3848 giampao 0.00 B/s 0.00 B/s /usr/lib/at-spi2-core/at-spi2-registryd 3862 giampao 0.00 B/s 0.00 B/s /usr/lib/gnome-settings-daemon Author: Giampaolo Rodola' """ import sys import time try: import curses except ImportError: sys.exit('platform not supported') import psutil from psutil._common import bytes2human win = curses.initscr() lineno = 0 def printl(line, highlight=False): """A thin wrapper around curses's addstr().""" global lineno try: if highlight: line += " " * (win.getmaxyx()[1] - len(line)) win.addstr(lineno, 0, line, curses.A_REVERSE) else: win.addstr(lineno, 0, line, 0) except curses.error: lineno = 0 win.refresh() raise else: lineno += 1 def poll(interval): """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 = list(psutil.process_iter()) for p in procs.copy(): try: p._before = p.io_counters() except psutil.Error: procs.remove(p) continue disks_before = psutil.disk_io_counters() # sleep some time time.sleep(interval) # then retrieve the same info again 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 # after the interval for p in procs: p._read_per_sec = p._after.read_bytes - p._before.read_bytes p._write_per_sec = p._after.write_bytes - p._before.write_bytes p._total = p._read_per_sec + p._write_per_sec disks_read_per_sec = disks_after.read_bytes - disks_before.read_bytes disks_write_per_sec = disks_after.write_bytes - disks_before.write_bytes # sort processes by total disk IO so that the more intensive # ones get listed first processes = sorted(procs, key=lambda p: p._total, reverse=True) return (processes, disks_read_per_sec, disks_write_per_sec) def refresh_window(procs, disks_read, disks_write): """Print results on screen by using curses.""" curses.endwin() templ = "{:<5} {:<7} {:>11} {:>11} {}" win.erase() disks_tot = "Total DISK READ: {} | Total DISK WRITE: {}".format( bytes2human(disks_read), bytes2human(disks_write), ) printl(disks_tot) header = templ.format("PID", "USER", "DISK READ", "DISK WRITE", "COMMAND") printl(header, highlight=True) for p in procs: line = templ.format( p.pid, p._username[:7], bytes2human(p._read_per_sec), bytes2human(p._write_per_sec), p._cmdline, ) try: 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) lineno = 0 interval = 0.5 time.sleep(interval) except (KeyboardInterrupt, SystemExit): pass finally: tear_down() if __name__ == '__main__': main() ================================================ FILE: scripts/killall.py ================================================ #!/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.""" import os import sys import psutil def main(): if len(sys.argv) != 2: sys.exit(f"usage: {__file__} name") else: name = sys.argv[1] killed = [] for proc in psutil.process_iter(): if proc.name() == name and proc.pid != os.getpid(): proc.kill() killed.append(proc.pid) if not killed: sys.exit(f"{name}: no process found") else: sys.exit(0) if __name__ == '__main__': main() ================================================ FILE: scripts/meminfo.py ================================================ #!/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. $ python3 scripts/meminfo.py MEMORY ------ Total : 9.7G Available : 4.9G Percent : 49.0 Used : 8.2G Free : 1.4G Active : 5.6G Inactive : 2.1G Buffers : 341.2M Cached : 3.2G SWAP ---- Total : 0B Used : 0B Free : 0B Percent : 0.0 Sin : 0B Sout : 0B """ import psutil from psutil._common import bytes2human def pprint_ntuple(nt): for name in nt._fields: value = getattr(nt, name) if name != 'percent': value = bytes2human(value) print('{:<10} : {:>7}'.format(name.capitalize(), value)) def main(): print('MEMORY\n------') pprint_ntuple(psutil.virtual_memory()) print('\nSWAP\n----') pprint_ntuple(psutil.swap_memory()) if __name__ == '__main__': main() ================================================ FILE: scripts/netstat.py ================================================ #!/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. $ 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 tcp 127.0.0.1:47072 127.0.0.1:45884 ESTABLISHED 13646 chrome tcp 127.0.0.1:45884 - LISTEN 13651 GoogleTalkPlugi tcp 127.0.0.1:60948 - LISTEN 13651 GoogleTalkPlugi tcp 172.17.42.1:49102 127.0.0.1:19305 CLOSE_WAIT 13651 GoogleTalkPlugi tcp 172.17.42.1:55797 127.0.0.1:443 CLOSE_WAIT 13651 GoogleTalkPlugi ... """ import socket 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 = { (AF_INET, SOCK_STREAM): 'tcp', (AF_INET6, SOCK_STREAM): 'tcp6', (AF_INET, SOCK_DGRAM): 'udp', (AF_INET6, SOCK_DGRAM): 'udp6', } def main(): 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(['pid', 'name']): proc_names[p.info['pid']] = p.info['name'] for c in psutil.net_connections(kind='inet'): laddr = f"{c.laddr[0]}:{c.laddr[1]}" raddr = "" if c.raddr: 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, name[:15], ) print(line) if __name__ == '__main__': main() ================================================ FILE: scripts/nettop.py ================================================ #!/usr/bin/env python3 # # $Id: iotop.py 1160 2011-10-14 18:50:36Z g.rodola@gmail.com $ # # 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 real-time network statistics. Author: Giampaolo Rodola' $ python3 scripts/nettop.py ----------------------------------------------------------- total bytes: sent: 1.49 G received: 4.82 G total packets: sent: 7338724 received: 8082712 wlan0 TOTAL PER-SEC ----------------------------------------------------------- bytes-sent 1.29 G 0.00 B/s bytes-recv 3.48 G 0.00 B/s pkts-sent 7221782 0 pkts-recv 6753724 0 eth1 TOTAL PER-SEC ----------------------------------------------------------- bytes-sent 131.77 M 0.00 B/s bytes-recv 1.28 G 0.00 B/s pkts-sent 0 0 pkts-recv 1214470 0 """ import sys import time try: import curses except ImportError: sys.exit('platform not supported') import psutil from psutil._common import bytes2human lineno = 0 win = curses.initscr() def printl(line, highlight=False): """A thin wrapper around curses's addstr().""" global lineno try: if highlight: line += " " * (win.getmaxyx()[1] - len(line)) win.addstr(lineno, 0, line, curses.A_REVERSE) else: win.addstr(lineno, 0, line, 0) except curses.error: lineno = 0 win.refresh() raise else: lineno += 1 def poll(interval): """Retrieve raw stats within an interval window.""" tot_before = psutil.net_io_counters() pnic_before = psutil.net_io_counters(pernic=True) # sleep some time time.sleep(interval) tot_after = psutil.net_io_counters() pnic_after = psutil.net_io_counters(pernic=True) return (tot_before, tot_after, pnic_before, pnic_after) def refresh_window(tot_before, tot_after, pnic_before, pnic_after): """Print stats on screen.""" global lineno # totals printl( "total bytes: sent: {:<10} received: {}".format( bytes2human(tot_after.bytes_sent), bytes2human(tot_after.bytes_recv), ) ) # per-network interface details: let's sort network interfaces so # that the ones which generated more traffic are shown first 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} {:>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', )) printl(templ.format( "bytes-recv", bytes2human(stats_after.bytes_recv), bytes2human( stats_after.bytes_recv - stats_before.bytes_recv) + '/s', )) printl(templ.format( "pkts-sent", stats_after.packets_sent, stats_after.packets_sent - stats_before.packets_sent, )) printl(templ.format( "pkts-recv", stats_after.packets_recv, stats_after.packets_recv - stats_before.packets_recv, )) 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 = 0.5 except (KeyboardInterrupt, SystemExit): pass finally: tear_down() if __name__ == '__main__': main() ================================================ FILE: scripts/pidof.py ================================================ #!/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. $ pidof python 1140 1138 1136 1134 1133 1129 1127 1125 1121 1120 1119 """ import sys import psutil def pidof(pgname): # search for matches in the process name and cmdline return [ str(proc.pid) for proc in psutil.process_iter(['name', 'cmdline']) if proc.info["name"] == pgname or (proc.info["cmdline"] and proc.info["cmdline"][0] == pgname) ] def main(): if len(sys.argv) != 2: sys.exit(f"usage: {__file__} pgname") else: pgname = sys.argv[1] pids = pidof(pgname) if pids: print(" ".join(pids)) if __name__ == '__main__': main() ================================================ FILE: scripts/pmap.py ================================================ #!/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 macOS and 'procstat -v' on BSD. Report memory map of a process. $ python3 scripts/pmap.py 32402 Address RSS Mode Mapping 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 00002b29bb203000 8K rw-p [anon] 00002b29bb220000 528K rw-p [anon] 00002b29bb2d8000 768K rw-p [anon] 00002b29bb402000 4K r--p /lib/x86_64-linux-gnu/ld-2.17.so 00002b29bb403000 8K rw-p /lib/x86_64-linux-gnu/ld-2.17.so 00002b29bb405000 60K r-xp /lib/x86_64-linux-gnu/libpthread-2.17.so 00002b29bb41d000 0K ---p /lib/x86_64-linux-gnu/libpthread-2.17.so 00007fff94be6000 48K rw-p [stack] 00007fff94dd1000 4K r-xp [vdso] ffffffffff600000 0K r-xp [vsyscall] ... """ import shutil import sys import psutil from psutil._common 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 ') p = psutil.Process(int(sys.argv[1])) 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 line = templ.format( m.addr.split('-')[0].zfill(16), bytes2human(m.rss), m.perms, 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() ================================================ FILE: scripts/procinfo.py ================================================ #!/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. Author: Giampaolo Rodola' $ 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 socket import sys import psutil from psutil._common import bytes2human 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 psutil.POSIX: fmt = "\x1b[1;32m{:<13}\x1b[0m {}".format(a, b) else: fmt = "{:<11} {}".format(a, b) print(fmt) 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: proc = psutil.Process(pid) pinfo = proc.as_dict(ad_value=ACCESS_DENIED) except psutil.NoSuchProcess as err: sys.exit(str(err)) # collect other proc info with proc.oneshot(): try: parent = proc.parent() parent = f"({parent.name()})" if parent else "" except psutil.Error: parent = '' 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_('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 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_('status', pinfo['status']) 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}", ) 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: type = 'UDP' else: type = 'UNIX' lip, lport = conn.laddr if not conn.raddr: rip, rport = '*', '*' else: rip, rport = conn.raddr line = template.format( type, f"{lip}:{lport}", f"{rip}:{rport}", conn.status, ) print_('', line) else: print_('connections', '') 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: 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()) ================================================ FILE: scripts/procsmem.py ================================================ #!/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. Processes are sorted by their "USS" (Unique Set Size) memory, which is probably the most representative metric for determining how much memory is actually being used by a process. This is similar to "smem" cmdline utility on Linux: https://www.selenic.com/smem/ Author: Giampaolo Rodola' ~/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 """ import sys import psutil if not hasattr(psutil.Process, "memory_footprint"): sys.exit("can't retrieve USS memory on this platform") 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 f"{value:.1f}{s}" return f"{n}B" def main(): ad_pids = [] procs = [] for p in psutil.process_iter(): 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 = "{:<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] 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._rss), convert_bytes(p._vms), cmd, ) print(line) if ad_pids: print(f"warning: access denied for {len(ad_pids)} pids") if __name__ == '__main__': sys.exit(main()) ================================================ FILE: scripts/ps.py ================================================ #!/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'. $ 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 shutil import time import psutil from psutil._common import bytes2human def main(): today_day = datetime.date.today() # 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.info['create_time']: ctime = datetime.datetime.fromtimestamp(p.info['create_time']) if ctime.date() == today_day: ctime = ctime.strftime("%H:%M") else: ctime = ctime.strftime("%b%d") else: ctime = '' if p.info['cpu_times']: cputime = time.strftime( "%M:%S", time.localtime(sum(p.info['cpu_times'])) ) else: cputime = '' user = p.info['username'] if not user and psutil.POSIX: try: user = p.uids()[0] except psutil.Error: pass if user and psutil.WINDOWS and '\\' in user: user = user.split('\\')[1] if not user: user = '' user = user[:9] vms = ( bytes2human(p.info['memory_info'].vms) if p.info['memory_info'] is not None else '' ) rss = ( bytes2human(p.info['memory_info'].rss) if p.info['memory_info'] is not None else '' ) memp = ( round(p.info['memory_percent'], 1) if p.info['memory_percent'] is not None else '' ) nice = int(p.info['nice']) if p.info['nice'] else '' if p.info['cmdline']: cmdline = ' '.join(p.info['cmdline']) else: cmdline = p.info['name'] status = p.info['status'][:5] if p.info['status'] else '' line = templ.format( user, p.info['pid'], memp, vms, rss, nice, status, ctime, cputime, cmdline, ) print(line[: shutil.get_terminal_size()[0]]) if __name__ == '__main__': main() ================================================ FILE: scripts/pstree.py ================================================ #!/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 as a tree structure. $ python3 scripts/pstree.py 0 ? |- 1 init | |- 289 cgmanager | |- 616 upstart-socket-bridge | |- 628 rpcbind | |- 892 upstart-file-bridge | |- 907 dbus-daemon | |- 978 avahi-daemon | | `_ 979 avahi-daemon | |- 987 NetworkManager | | |- 2242 dnsmasq | | `_ 10699 dhclient | |- 993 polkitd | |- 1061 getty | |- 1066 su | | `_ 1190 salt-minion... ... """ import collections import sys import psutil def print_tree(parent, tree, indent=''): try: name = psutil.Process(parent).name() except psutil.Error: name = "?" print(parent, name) if parent not in tree: return children = tree[parent][:-1] for child in children: sys.stdout.write(indent + "|- ") print_tree(child, tree, indent + "| ") child = tree[parent][-1] sys.stdout.write(indent + "`_ ") print_tree(child, tree, indent + " ") def main(): # construct a dict where 'values' are all the processes # having 'key' as their parent tree = collections.defaultdict(list) for p in psutil.process_iter(): try: tree[p.ppid()].append(p.pid) except (psutil.NoSuchProcess, psutil.ZombieProcess): pass # on systems supporting PID 0, PID 0's parent is usually 0 if 0 in tree and 0 in tree[0]: tree[0].remove(0) print_tree(min(tree), tree) if __name__ == '__main__': main() ================================================ FILE: scripts/sensors.py ================================================ #!/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() ================================================ FILE: scripts/temperatures.py ================================================ #!/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() ================================================ FILE: scripts/top.py ================================================ #!/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. Author: Giampaolo Rodola' $ 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 datetime import sys import time try: import curses except ImportError: sys.exit('platform not supported') import psutil from psutil._common import bytes2human win = curses.initscr() lineno = 0 colors_map = dict(green=3, red=10, yellow=4) 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)) flags |= curses.A_STANDOUT win.addstr(lineno, 0, line, flags) except curses.error: lineno = 0 win.refresh() raise else: lineno += 1 # --- /curses stuff def poll(interval): # sleep some time time.sleep(interval) procs = [] 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', ]) try: procs_status[p.dict['status']] += 1 except KeyError: procs_status[p.dict['status']] = 1 except psutil.NoSuchProcess: pass else: procs.append(p) # return processes sorted by CPU percent usage 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) empty_dashes = " " * (40 - len(dashes)) return dashes, empty_dashes # cpu usage percs = psutil.cpu_percent(interval=0, percpu=True) for cpu_num, perc in enumerate(percs): dashes, empty_dashes = get_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) line = " Mem [{}{}] {:>5}% {:>6} / {}".format( dashes, empty_dashes, mem.percent, bytes2human(mem.used), bytes2human(mem.total), ) printl(line, color=get_color(mem.percent)) # swap usage swap = psutil.swap_memory() dashes, empty_dashes = get_dashes(swap.percent) line = " Swap [{}{}] {:>5}% {:>6} / {}".format( dashes, empty_dashes, swap.percent, bytes2human(swap.used), bytes2human(swap.total), ) printl(line, color=get_color(swap.percent)) # processes number and status st = [] for x, y in procs_status.items(): if y: 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 = 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 = "{:<6} {:<8} {:>4} {:>6} {:>6} {:>5} {:>5} {:>9} {:>2}" win.erase() header = templ.format( "PID", "USER", "NI", "VIRT", "RES", "CPU%", "MEM%", "TIME+", "NAME", ) print_header(procs_status, len(procs)) 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 = "{}:{}.{}".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: p.dict['memory_percent'] = round(p.dict['memory_percent'], 1) else: p.dict['memory_percent'] = '' if p.dict['cpu_percent'] is None: p.dict['cpu_percent'] = '' 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: 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() ================================================ FILE: scripts/who.py ================================================ #!/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 currently logged in. $ 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 import psutil def main(): users = psutil.users() for user in users: 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"), f"({user.host or ''})", proc_name, ) print(line) if __name__ == '__main__': main() ================================================ FILE: scripts/winservices.py ================================================ #!/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"""List all Windows services installed. $ python3 scripts/winservices.py AeLookupSvc (Application Experience) status: stopped, start: manual, username: localSystem, pid: None binpath: C:\Windows\system32\svchost.exe -k netsvcs ALG (Application Layer Gateway Service) status: stopped, start: manual, username: NT AUTHORITY\LocalService, pid: None binpath: C:\Windows\System32\alg.exe APNMCP (Ask Update Service) status: running, start: automatic, username: LocalSystem, pid: 1108 binpath: "C:\Program Files (x86)\AskPartnerNetwork\Toolbar\apnmcp.exe" AppIDSvc (Application Identity) status: stopped, start: manual, username: NT Authority\LocalService, pid: None binpath: C:\Windows\system32\svchost.exe -k LocalServiceAndNoImpersonation 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(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__': sys.exit(main()) ================================================ FILE: setup.py ================================================ #!/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. """Cross-platform lib for process and system monitoring in Python.""" import contextlib import glob import io import os import pathlib import shutil import struct import subprocess import sys import sysconfig import tempfile import warnings with warnings.catch_warnings(): warnings.simplefilter("ignore") try: import setuptools from setuptools import Extension from setuptools import setup except ImportError: if "CIBUILDWHEEL" in os.environ: raise setuptools = None from distutils.core import Extension from distutils.core import setup 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 _common = load_module(ROOT_DIR / "psutil" / "_common.py") 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 hilite = _common.hilite PYPY = '__pypy__' in sys.builtin_module_names PY36_PLUS = sys.version_info[:2] >= (3, 6) PY37_PLUS = sys.version_info[:2] >= (3, 7) CP36_PLUS = PY36_PLUS and sys.implementation.name == "cpython" CP37_PLUS = PY37_PLUS and sys.implementation.name == "cpython" Py_GIL_DISABLED = sysconfig.get_config_var("Py_GIL_DISABLED") # Test deps, installable via `pip install .[test]` or # `make install-pydeps-test`. TEST_DEPS = [ "psleak", "pytest", "pytest-instafail", "pytest-xdist", "setuptools", 'pywin32 ; os_name == "nt" and implementation_name != "pypy"', 'wheel ; os_name == "nt" and implementation_name != "pypy"', 'wmi ; os_name == "nt" and implementation_name != "pypy"', ] # Linter deps, installable via `pip install .[lint]` or # `make install-pydeps-lint`. LINT_DEPS = [ "black", "ruff", "sphinx-lint", "toml-sort", ] # Development deps, installable via `pip install .[dev]` or # `make install-pydeps-dev`. DEV_DEPS = [ *TEST_DEPS, *LINT_DEPS, "abi3audit", "check-manifest", "coverage", "packaging", "pylint", # not enforced "pyperf", "pypinfo", "pytest-cov", "requests", "sphinx", "sphinx_rtd_theme", "twine", "validate-pyproject[all]", "virtualenv", "vulture", "wheel", 'colorama ; os_name == "nt"', 'pyreadline3 ; os_name == "nt"', ] # 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() macros.append(('PSUTIL_VERSION', int(VERSION.replace('.', '')))) # Py_LIMITED_API lets us create a single wheel which works with multiple # python versions, including unreleased ones. if setuptools and CP36_PLUS and (MACOS or LINUX) and not Py_GIL_DISABLED: py_limited_api = {"py_limited_api": True} options = {"bdist_wheel": {"py_limited_api": "cp36"}} macros.append(('Py_LIMITED_API', '0x03060000')) elif setuptools and CP37_PLUS and WINDOWS and not Py_GIL_DISABLED: # PyErr_SetFromWindowsErr / PyErr_SetFromWindowsErrWithFilename are # part of the stable API/ABI starting with CPython 3.7 py_limited_api = {"py_limited_api": True} options = {"bdist_wheel": {"py_limited_api": "cp37"}} macros.append(('Py_LIMITED_API', '0x03070000')) 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 @contextlib.contextmanager def silenced_output(): with contextlib.redirect_stdout(io.StringIO()): with contextlib.redirect_stderr(io.StringIO()): yield def has_python_h(): include_dir = sysconfig.get_path("include") return os.path.exists(os.path.join(include_dir, "Python.h")) def get_sysdeps(): if LINUX: pyimpl = "pypy" if PYPY else "python" if shutil.which("dpkg"): return "sudo apt-get install gcc {}3-dev".format(pyimpl) elif shutil.which("rpm"): return "sudo yum install gcc {}3-devel".format(pyimpl) elif shutil.which("pacman"): return "sudo pacman -S gcc python" elif shutil.which("apk"): return "sudo apk add gcc {}3-dev musl-dev linux-headers".format( pyimpl ) elif MACOS: return "xcode-select --install" elif FREEBSD: if shutil.which("pkg"): return "pkg install gcc python3" elif shutil.which("mport"): # MidnightBSD return "mport install gcc python3" elif OPENBSD: return "pkg_add -v gcc python3" elif NETBSD: return "pkgin install gcc python3" elif SUNOS: return "pkg install gcc" def print_install_instructions(): reasons = [] if not shutil.which("gcc"): reasons.append("gcc is not installed.") if not has_python_h(): reasons.append("Python header files are not installed.") if reasons: sysdeps = get_sysdeps() if sysdeps: s = "psutil could not be compiled from sources. " s += " ".join(reasons) s += " Try running:\n" s += " {}".format(sysdeps) print(hilite(s, color="red", bold=True), file=sys.stderr) def unix_can_compile(c_code): from distutils.errors import CompileError from distutils.unixccompiler import UnixCCompiler with tempfile.NamedTemporaryFile( suffix='.c', delete=False, mode="wt" ) as f: f.write(c_code) tempdir = tempfile.mkdtemp() try: compiler = UnixCCompiler() # https://github.com/giampaolo/psutil/pull/1568 if os.getenv('CC'): compiler.set_executable('compiler_so', os.getenv('CC')) with silenced_output(): compiler.compile([f.name], output_dir=tempdir) compiler.compile([f.name], output_dir=tempdir) except CompileError: return False else: return True finally: os.remove(f.name) shutil.rmtree(tempdir) if WINDOWS: def get_winver(): maj, min = sys.getwindowsversion()[0:2] return "0x0{}".format((maj * 100) + min) if sys.getwindowsversion()[0] < 6: 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) 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), # see: https://github.com/giampaolo/psutil/issues/348 ('PSAPI_VERSION', 1), ]) if Py_GIL_DISABLED: macros.append(('Py_GIL_DISABLED', 1)) ext = Extension( 'psutil._psutil_windows', sources=( sources + ["psutil/_psutil_windows.c"] + glob.glob("psutil/arch/windows/*.c") ), define_macros=macros, libraries=[ "advapi32", "kernel32", "netapi32", "pdh", "PowrProf", "psapi", "shell32", "ws2_32", ], # extra_compile_args=["/W 4"], # extra_link_args=["/DEBUG"], **py_limited_api, ) elif MACOS: macros.extend([("PSUTIL_OSX", 1), ("PSUTIL_MACOS", 1)]) ext = Extension( 'psutil._psutil_osx', sources=( sources + ["psutil/_psutil_osx.c"] + glob.glob("psutil/arch/osx/*.c") ), define_macros=macros, extra_link_args=[ '-framework', 'CoreFoundation', '-framework', 'IOKit', ], **py_limited_api, ) elif FREEBSD: macros.append(("PSUTIL_FREEBSD", 1)) ext = Extension( 'psutil._psutil_bsd', 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=( 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_bsd', 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 "): macros.append(("PSUTIL_ETHTOOL_MISSING_TYPES", 1)) macros.append(("PSUTIL_LINUX", 1)) ext = Extension( 'psutil._psutil_linux', 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=( 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_aix', sources=( sources + ["psutil/_psutil_aix.c"] + glob.glob("psutil/arch/aix/*.c") ), libraries=["perfstat"], define_macros=macros, **py_limited_api, ) else: sys.exit("platform {} is not supported".format(sys.platform)) def main(): kwargs = dict( name='psutil', version=VERSION, 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', 'performance', 'metrics', 'agent', 'observability', ], # fmt: on author='Giampaolo Rodola', author_email='g.rodola@gmail.com', url='https://github.com/giampaolo/psutil', platforms='Platform Independent', license='BSD-3-Clause', packages=['psutil'], ext_modules=[ext], options=options, classifiers=[ 'Development Status :: 5 - Production/Stable', 'Environment :: Console', 'Intended Audience :: Developers', 'Intended Audience :: Information Technology', 'Intended Audience :: System Administrators', 'Operating System :: MacOS :: MacOS X', 'Operating System :: Microsoft :: Windows :: Windows 10', 'Operating System :: Microsoft :: Windows :: Windows 11', 'Operating System :: Microsoft :: Windows :: Windows 7', 'Operating System :: Microsoft :: Windows :: Windows 8', 'Operating System :: Microsoft :: Windows :: Windows 8.1', 'Operating System :: Microsoft :: Windows :: Windows Server 2003', 'Operating System :: Microsoft :: Windows :: Windows Server 2008', 'Operating System :: Microsoft :: Windows :: Windows Vista', 'Operating System :: Microsoft :: Windows', 'Operating System :: Microsoft', 'Operating System :: OS Independent', 'Operating System :: POSIX :: AIX', '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 :: 3', 'Programming Language :: Python :: Implementation :: CPython', 'Programming Language :: Python :: Implementation :: PyPy', 'Programming Language :: Python', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: Software Development :: Libraries', 'Topic :: System :: Benchmark', 'Topic :: System :: Hardware', 'Topic :: System :: Monitoring', 'Topic :: System :: Networking :: Monitoring :: Hardware Watchdog', 'Topic :: System :: Networking :: Monitoring', 'Topic :: System :: Networking', 'Topic :: System :: Operating System', 'Topic :: System :: Systems Administration', 'Topic :: Utilities', ], ) if setuptools is not None: extras_require = { "test": TEST_DEPS, "lint": LINT_DEPS, "dev": DEV_DEPS, } kwargs.update( python_requires=">=3.7", extras_require=extras_require, zip_safe=False, ) 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", "sdist", "bdist", "develop") ) ): print_install_instructions() if __name__ == '__main__': main() ================================================ FILE: tests/README.md ================================================ # Instructions for running tests Install deps (e.g. pytest): .. code-block:: bash make install-pydeps-test Run tests: .. code-block:: bash make test Run tests in parallel (faster): .. code-block:: bash make test-parallel Run a specific test: .. code-block:: bash make test ARGS=tests.test_system.TestDiskAPIs Test C extension memory leaks: .. code-block:: bash make test-memleaks # Running tests on Windows Same as above, just replace `make` with `make.bat`, e.g.: .. code-block:: bash make.bat install-pydeps-test make.bat test set ARGS=-k tests.test_system.TestDiskAPIs && make.bat test ================================================ FILE: tests/__init__.py ================================================ # 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 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 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 try: import pytest except ImportError: pytest = None 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 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', 'IS_64BIT', "HAS_PROC_CPU_AFFINITY", "HAS_CPU_FREQ", "HAS_PROC_ENVIRON", "HAS_PROC_IO_COUNTERS", "HAS_PROC_IONICE", "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", "MACOS_11PLUS", "MACOS_12PLUS", "COVERAGE", "AARCH64", "PYTEST_PARALLEL", # subprocesses 'pyrun', 'terminate', 'reap_children', 'spawn_subproc', 'spawn_zombie', 'spawn_children_pair', # 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', # 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', # sync primitives 'call_until', 'wait_for_pid', 'wait_for_file', # 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 # 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` # are we a 64 bit process? IS_64BIT = sys.maxsize > 2**32 # 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") 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_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") 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() # On Windows, starting with python 3.7, 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 sys.version_info >= (3, 7) 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] sproc = subprocess.Popen(cmd, **kwds) _subprocesses_started.add(sproc) wait_for_file(testfn, delete=True, empty=True) finally: safe_rmpath(testfn) else: sproc = subprocess.Popen(cmd, **kwds) _subprocesses_started.add(sproc) wait_for_pid(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) else: subp, tfile = pyrun(s) child = psutil.Process(subp.pid) grandchild_pid = int(wait_for_file(testfn, 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, sys, time, socket, contextlib child_pid = os.fork() if child_pid > 0: time.sleep(3000) else: # this is the zombie process with socket.socket(socket.AF_UNIX) as s: s.connect('{unix_file}') pid = bytes(str(os.getpid()), 'ascii') s.sendall(pid) """) 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("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 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) # 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: for p in children: terminate(p, wait_timeout=None) _, 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) # =================================================================== # --- 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: stop_at = time.time() + self.timeout while time.time() < 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 @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.time() + GLOBAL_TIMEOUT while time.time() < 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 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 # =================================================================== 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. 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"): 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', (), {}), ('children', (), {'recursive': True}), ('connections', (), {}), # deprecated ('is_running', (), {}), ('memory_full_info', (), {}), # deprecated ('oneshot', (), {}), ('parent', (), {}), ('parents', (), {}), ('pid', (), {}), ('wait', (0,), {}), ] getters = [ ('cmdline', (), {}), ('cpu_times', (), {}), ('create_time', (), {}), ('cwd', (), {}), ('exe', (), {}), ('memory_info', (), {}), ('memory_info_ex', (), {}), ('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_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=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 assert retries > 1, retries return decorator 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 return pytest.skip("raises AccessDenied") 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 = ( f"{fun.__name__!r} was skipped because it raised" " NotImplementedError" ) return pytest.skip(msg) return wrapper 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.socket(family, SOCK_STREAM) as ll: ll.bind(addr) ll.listen(5) 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. """ if not hasattr(typing, "get_origin") and sys.version_info[:2] <= ( 3, 7, ): return None 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): from _bootstrap import load_module return load_module(path) # =================================================================== # --- 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() and 'wow64' not in 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)) ================================================ FILE: tests/test_aix.py ================================================ #!/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 pytest from . import sh @pytest.mark.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\S+)\s+" r"(?P\S+)\s+" r"(?P\S+)\s+" r"(?P\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 ================================================ FILE: tests/test_bsd.py ================================================ #!/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 shutil import time import psutil from psutil import BSD from psutil import FREEBSD from psutil import NETBSD from psutil import OPENBSD from . import HAS_BATTERY from . import TOLERANCE_SYS_MEM from . import PsutilTestCase from . import pytest from . import retry_on_failure from . import sh from . import spawn_subproc from . import terminate if BSD: PAGESIZE = psutil._psplatform.cext.getpagesize() # muse requires root privileges MUSE_AVAILABLE = os.getuid() == 0 and shutil.which("muse") else: PAGESIZE = None 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* # ===================================================================== @pytest.mark.skipif(not BSD, reason="BSD only") class BSDTestCase(PsutilTestCase): """Generic tests common to all BSD variants.""" @classmethod def setUpClass(cls): cls.pid = spawn_subproc().pid @classmethod def tearDownClass(cls): terminate(cls.pid) @pytest.mark.skipif(NETBSD, reason="-o lstart doesn't work on NETBSD") def test_process_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_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}") @pytest.mark.skipif( not shutil.which("sysctl"), reason="sysctl cmd not available" ) def test_cpu_count_logical(self): syst = sysctl("hw.ncpu") assert psutil.cpu_count(logical=True) == syst @pytest.mark.skipif( not shutil.which("sysctl"), reason="sysctl cmd not available" ) @pytest.mark.skipif( NETBSD, reason="skipped on NETBSD" # we check /proc/meminfo ) def test_virtual_memory_total(self): num = sysctl('hw.physmem') assert num == psutil.virtual_memory().total @pytest.mark.skipif( not shutil.which("ifconfig"), reason="ifconfig cmd not available" ) 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]) # ===================================================================== # --- FreeBSD # ===================================================================== @pytest.mark.skipif(not FREEBSD, reason="FREEBSD only") class FreeBSDTestCase(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") @pytest.mark.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_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: # / /... # 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 # --- 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 # --- virtual_memory(); tests against muse @pytest.mark.skipif(not MUSE_AVAILABLE, reason="muse not installed") def test_muse_vmem_total(self): num = muse('Total') assert psutil.virtual_memory().total == num @pytest.mark.skipif(not MUSE_AVAILABLE, reason="muse not installed") @retry_on_failure() def test_muse_vmem_active(self): num = muse('Active') assert abs(psutil.virtual_memory().active - num) < TOLERANCE_SYS_MEM @pytest.mark.skipif(not MUSE_AVAILABLE, reason="muse not installed") @retry_on_failure() def test_muse_vmem_inactive(self): num = muse('Inactive') assert abs(psutil.virtual_memory().inactive - num) < TOLERANCE_SYS_MEM @pytest.mark.skipif(not MUSE_AVAILABLE, reason="muse not installed") @retry_on_failure() def test_muse_vmem_wired(self): num = muse('Wired') assert abs(psutil.virtual_memory().wired - num) < TOLERANCE_SYS_MEM @pytest.mark.skipif(not MUSE_AVAILABLE, reason="muse not installed") @retry_on_failure() def test_muse_vmem_cached(self): num = muse('Cache') assert abs(psutil.virtual_memory().cached - num) < TOLERANCE_SYS_MEM @pytest.mark.skipif(not MUSE_AVAILABLE, reason="muse not installed") @retry_on_failure() def test_muse_vmem_free(self): num = muse('Free') assert abs(psutil.virtual_memory().free - num) < TOLERANCE_SYS_MEM @pytest.mark.skipif(not MUSE_AVAILABLE, reason="muse not installed") @retry_on_failure() def test_muse_vmem_buffers(self): num = muse('Buffer') assert abs(psutil.virtual_memory().buffers - num) < 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 # --- 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 @pytest.mark.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 @pytest.mark.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 @pytest.mark.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 # ===================================================================== @pytest.mark.skipif(not OPENBSD, reason="OPENBSD only") class OpenBSDTestCase(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 # ===================================================================== @pytest.mark.skipif(not NETBSD, reason="NETBSD only") class NetBSDTestCase(PsutilTestCase): @staticmethod def parse_meminfo(look_for): with open('/proc/meminfo') as f: for line in f: if line.startswith(look_for): return int(line.split()[1]) * 1024 raise ValueError(f"can't find {look_for}") # --- virtual mem def test_vmem_total(self): assert psutil.virtual_memory().total == self.parse_meminfo("MemTotal:") def test_vmem_free(self): assert ( abs(psutil.virtual_memory().free - self.parse_meminfo("MemFree:")) < TOLERANCE_SYS_MEM ) def test_vmem_buffers(self): assert ( abs( psutil.virtual_memory().buffers - self.parse_meminfo("Buffers:") ) < TOLERANCE_SYS_MEM ) def test_vmem_shared(self): assert ( abs( psutil.virtual_memory().shared - self.parse_meminfo("MemShared:") ) < TOLERANCE_SYS_MEM ) def test_vmem_cached(self): assert ( abs(psutil.virtual_memory().cached - self.parse_meminfo("Cached:")) < TOLERANCE_SYS_MEM ) # --- swap mem def test_swapmem_total(self): assert ( abs(psutil.swap_memory().total - self.parse_meminfo("SwapTotal:")) < TOLERANCE_SYS_MEM ) def test_swapmem_free(self): assert ( abs(psutil.swap_memory().free - self.parse_meminfo("SwapFree:")) < TOLERANCE_SYS_MEM ) def test_swapmem_used(self): smem = psutil.swap_memory() assert smem.used == smem.total - smem.free # --- others 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") assert abs(psutil.cpu_stats().interrupts - interrupts) < 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") assert abs(psutil.cpu_stats().ctx_switches - ctx_switches) < 1000 ================================================ FILE: tests/test_connections.py ================================================ #!/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 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 skip_on_access_denied from . import tcp_socketpair from . import unix_socketpair from . import wait_for_file 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 @pytest.mark.xdist_group(name="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 exlucde 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): @pytest.mark.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='???') @pytest.mark.xdist_group(name="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 @pytest.mark.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 @pytest.mark.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 @pytest.mark.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 @pytest.mark.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 @pytest.mark.xdist_group(name="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. @pytest.mark.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 # commenteed. # 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() @pytest.mark.skipif(not POSIX, reason="POSIX only") @pytest.mark.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) tcp4_addr = eval(wait_for_file(testfile, delete=True)) udp4_proc = self.pyrun(udp4_template) udp4_addr = eval(wait_for_file(testfile, delete=True)) if supports_ipv6(): tcp6_proc = self.pyrun(tcp6_template) tcp6_addr = eval(wait_for_file(testfile, delete=True)) udp6_proc = self.pyrun(udp6_template) udp6_addr = eval(wait_for_file(testfile, 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 becayse 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} @pytest.mark.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) pids = [] 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) pids.append(sproc.pid) # sync for fname in fnames: wait_for_file(fname) 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 ================================================ FILE: tests/test_contracts.py ================================================ #!/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 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 AARCH64 from . import GITHUB_ACTIONS 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 # =================================================================== # --- 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") @pytest.mark.skipif( GITHUB_ACTIONS and LINUX, reason="unsupported on GITHUB_ACTIONS + LINUX", ) 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 @pytest.mark.skipif( MACOS and AARCH64 and not HAS_CPU_FREQ, reason="not supported" ) 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 == bool(platform.libc_ver() != ("", "")) else: assert hasit == MACOS or WINDOWS or BSD def test_heap_trim(self): hasit = hasattr(psutil, "heap_trim") if LINUX: assert hasit == bool(platform.libc_ver() != ("", "")) 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) @pytest.mark.skipif( GITHUB_ACTIONS and LINUX, reason="unsupported on GITHUB_ACTIONS + LINUX", ) 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_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) @pytest.mark.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) @pytest.mark.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) 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) @pytest.mark.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) @pytest.mark.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))) @pytest.mark.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 ================================================ FILE: tests/test_heap.py ================================================ #!/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 pytest 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 PsutilTestCase from . import retry_on_failure # 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})" ) @pytest.mark.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 @pytest.mark.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) @pytest.mark.skipif(MACOS, reason="not supported on MACOS") @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 @pytest.mark.skipif(not WINDOWS, reason="WINDOWS only") @pytest.mark.xdist_group(name="serial") 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 ================================================ FILE: tests/test_linux.py ================================================ #!/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 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 . import AARCH64 from . import GITHUB_ACTIONS from . import GLOBAL_TIMEOUT from . import HAS_BATTERY from . import HAS_CPU_FREQ from . import HAS_PROC_RLIMIT from . import RISCV64 from . import TOLERANCE_DISK_USAGE from . import TOLERANCE_SYS_MEM from . import PsutilTestCase from . import ThreadTask from . import call_until from . import pytest from . import reload_module from . import retry_on_failure from . import safe_rmpath from . import sh from . import skip_on_not_implemented if LINUX: from psutil._pslinux import CLOCK_TICKS from psutil._pslinux import RootFsDeviceFinder 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 @pytest.mark.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}") 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(): 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 TestSystemVirtualMemoryAgainstFree(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 TestSystemVirtualMemoryAgainstVmstat(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 TestSystemVirtualMemoryMocks(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 # ===================================================================== # --- system swap memory # ===================================================================== class TestSystemSwapMemory(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 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('psutil._pslinux.cext.linux_sysinfo') as m: swap = psutil.swap_memory() assert not m.called import psutil._psutil_linux as cext _, _, _, _, total, free, unit_multiplier = cext.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 # ===================================================================== # --- system CPU # ===================================================================== class TestSystemCPUCountLogical(LinuxTestCase): @pytest.mark.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 @pytest.mark.skipif( not os.path.exists("/sys/devices/system/cpu"), reason="/sys/devices/system/cpu does not exist", ) def test_against_sysdev_cpu_num(self): 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 @pytest.mark.skipif( not shutil.which("nproc"), reason="nproc utility not available" ) def test_against_nproc(self): num = int(sh("nproc --all")) assert psutil.cpu_count(logical=True) == num @pytest.mark.skipif( not shutil.which("lscpu"), reason="lscpu utility not available" ) 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() fake_file = io.BytesIO(cpuinfo_data) with mock.patch( 'psutil._common.open', return_value=fake_file, create=True ) as m: assert 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 with mock_open_content({"/proc/cpuinfo": b""}) as m: assert psutil._pslinux.cpu_count_logical() == original assert m.called class TestSystemCPUCountCores(LinuxTestCase): @pytest.mark.skipif( not shutil.which("lscpu"), reason="lscpu utility not available" ) def test_against_lscpu(self): out = sh("lscpu -p") core_ids = set() for line in out.split('\n'): if not line.startswith('#'): fields = line.split(',') core_ids.add(fields[1]) assert psutil.cpu_count(logical=False) == len(core_ids) @pytest.mark.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 TestSystemCPUFrequency(LinuxTestCase): @pytest.mark.skipif(not HAS_CPU_FREQ, reason="not supported") @pytest.mark.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() @pytest.mark.skipif(not HAS_CPU_FREQ, reason="not supported") @pytest.mark.skipif( AARCH64 or RISCV64, reason=f"{platform.machine()} does not report 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) @pytest.mark.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 @pytest.mark.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 name == '/proc/cpuinfo': return io.BytesIO(b"cpu MHz : 100\ncpu MHz : 400") 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=2 ): 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 @pytest.mark.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 class TestSystemCPUStats(LinuxTestCase): # XXX: fails too often. # def test_ctx_switches(self): # vmstat_value = vmstat("context switches") # psutil_value = psutil.cpu_stats().ctx_switches # assert abs(vmstat_value - psutil_value) < 500 def test_interrupts(self): vmstat_value = vmstat("interrupts") psutil_value = psutil.cpu_stats().interrupts assert abs(vmstat_value - psutil_value) < 500 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 TestSystemNetIfAddrs(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: assert get_ipv4_broadcast(name) == '0.0.0.0' 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) @pytest.mark.skipif( not shutil.which("ip"), reason="'ip' command not available" ) @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 @pytest.mark.skipif( not shutil.which("ip"), reason="'ip' command not available" ) @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 # XXX - not reliable when having virtual NICs installed by Docker. # @pytest.mark.skipif(not shutil.which("ip"), # reason="'ip' utility not available") # 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(r"^\d+:", line): # found += 1 # name = line.split(':')[1].strip() # assert name in nics # assert len(nics) == found class TestSystemNetIfStats(LinuxTestCase): @pytest.mark.skipif( not shutil.which("ifconfig"), reason="ifconfig utility not available" ) 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()) @pytest.mark.skipif( not shutil.which("ifconfig"), reason="ifconfig utility not available" ) def test_flags(self): # first line looks like this: # "eth0: flags=4163 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 TestSystemNetIOCounters(LinuxTestCase): @pytest.mark.skipif( not shutil.which("ifconfig"), reason="ifconfig utility not available" ) @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 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 TestSystemNetConnections(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 # ===================================================================== # --- system disks # ===================================================================== class TestSystemDiskPartitions(LinuxTestCase): @pytest.mark.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( '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 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 TestSystemDiskIoCounters(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() 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() @pytest.mark.skipif(GITHUB_ACTIONS, reason="unsupported on GITHUB_ACTIONS") 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 @pytest.mark.skipif( not shutil.which("findmnt"), reason="findmnt utility not available" ) @pytest.mark.skipif(GITHUB_ACTIONS, reason="unsupported on GITHUB_ACTIONS") def test_against_findmnt(self): psutil_value = RootFsDeviceFinder().find() findmnt_value = sh("findmnt -o SOURCE -rn /") assert psutil_value == findmnt_value def test_disk_partitions_mocked(self): with mock.patch( 'psutil._pslinux.cext.disk_partitions', return_value=[('/dev/root', '/', 'ext4', 'rw')], ) as m: part = psutil.disk_partitions()[0] assert m.called if not GITHUB_ACTIONS: assert part.device != "/dev/root" assert part.device == RootFsDeviceFinder().find() else: assert part.device == "/dev/root" # ===================================================================== # --- 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() @pytest.mark.xdist_group(name="serial") 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 # ===================================================================== @pytest.mark.skipif(not HAS_BATTERY, reason="no battery") class TestSensorsBattery(LinuxTestCase): @pytest.mark.skipif( not shutil.which("acpi"), reason="acpi utility not available" ) def test_percent(self): out = sh("acpi -b") acpi_value = int(out.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 @pytest.mark.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 againt /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 class TestSensorsBatteryEmulated(LinuxTestCase): def test_it(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.time() + GLOBAL_TIMEOUT while True: for file in p.open_files(): if file.path == os.path.abspath(fname): return file elif time.time() > 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={} ) as m: assert psutil._pslinux.Process(os.getpid()).terminal() is None assert m.called 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() @pytest.mark.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_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_info_ex(self): mem = psutil.Process().memory_info_ex() assert mem.rss == mem.rss_anon + mem.rss_file + mem.rss_shmem 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): min_, max_ = map(int, value.split('-')) assert self.proc.cpu_affinity() == list(range(min_, max_ + 1)) 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: self.proc._proc._get_eligible_cpus() if '-' in str(value): assert not m.called else: assert 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 ================================================ FILE: tests/test_memleaks.py ================================================ #!/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 functools import os from psleak import MemoryLeakTestCase import psutil 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 . 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_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 create_sockets from . import get_testfn from . import process_namespace from . import pytest from . import skip_on_access_denied from . import spawn_subproc from . import system_namespace from . import terminate cext = psutil._psplatform.cext thisproc = psutil.Process() MemoryLeakTestCase.retries = 30 # minimize false positives MemoryLeakTestCase.verbosity = 1 TIMES = MemoryLeakTestCase.times FEW_TIMES = int(TIMES / 10) # =================================================================== # Process class # =================================================================== class TestProcessObjectLeaks(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) @pytest.mark.skipif(not POSIX, reason="POSIX only") def test_uids(self): self.execute(self.proc.uids) @pytest.mark.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)) @pytest.mark.skipif(not HAS_PROC_IONICE, reason="not supported") def test_ionice(self): self.execute(self.proc.ionice) @pytest.mark.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)) @pytest.mark.skipif(not HAS_PROC_IONICE, reason="not supported") @pytest.mark.skipif(WINDOWS, reason="not on WINDOWS") def test_ionice_set_badarg(self): fun = functools.partial(cext.proc_ioprio_set, os.getpid(), -1, 0) self.execute_w_exc(OSError, fun, retries=20) @pytest.mark.skipif(not HAS_PROC_IO_COUNTERS, reason="not supported") def test_io_counters(self): self.execute(self.proc.io_counters) @pytest.mark.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) @pytest.mark.skipif(not WINDOWS, reason="WINDOWS only") def test_num_handles(self): self.execute(self.proc.num_handles) @pytest.mark.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): kw = {"times": 50} if WINDOWS else {} self.execute(self.proc.threads, **kw) def test_cpu_times(self): self.execute(self.proc.cpu_times) @pytest.mark.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) def test_memory_info_ex(self): self.execute(self.proc.memory_info_ex) @pytest.mark.skipif(not HAS_PROC_MEMORY_FOOTPRINT, reason="not supported") def test_memory_footprint(self): self.execute(self.proc.memory_footprint) @pytest.mark.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) @pytest.mark.skipif(not HAS_PROC_CPU_AFFINITY, reason="not supported") def test_cpu_affinity(self): self.execute(self.proc.cpu_affinity) @pytest.mark.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)) @pytest.mark.skipif(not HAS_PROC_CPU_AFFINITY, reason="not supported") def test_cpu_affinity_set_badarg(self): self.execute_w_exc( ValueError, lambda: self.proc.cpu_affinity([-1]), retries=20 ) def test_open_files(self): kw = {"times": 10, "retries": 30} if WINDOWS else {} with open(get_testfn(), 'w'): self.execute(self.proc.open_files, **kw) @pytest.mark.skipif(not HAS_PROC_MEMORY_MAPS, reason="not supported") @pytest.mark.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) @pytest.mark.skipif(not LINUX, reason="LINUX only") @pytest.mark.skipif(not HAS_PROC_RLIMIT, reason="not supported") def test_rlimit(self): self.execute(lambda: self.proc.rlimit(psutil.RLIMIT_NOFILE)) @pytest.mark.skipif(not LINUX, reason="LINUX only") @pytest.mark.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)) @pytest.mark.skipif(not LINUX, reason="LINUX only") @pytest.mark.skipif(not HAS_PROC_RLIMIT, reason="not supported") def test_rlimit_set_badarg(self): self.execute_w_exc( (OSError, ValueError), lambda: self.proc.rlimit(-1), retries=20 ) # Windows implementation is based on a single system-wide # function (tested later). @pytest.mark.skipif(WINDOWS, reason="worthless on WINDOWS") def test_net_connections(self): # TODO: UNIX sockets are temporarily implemented by parsing # 'pfiles' cmd output; we don't want that part of the code to # be executed. times = FEW_TIMES if LINUX else self.times with create_sockets(): kind = 'inet' if SUNOS else 'all' self.execute(lambda: self.proc.net_connections(kind), times=times) @pytest.mark.skipif(not HAS_PROC_ENVIRON, reason="not supported") def test_environ(self): self.execute(self.proc.environ) @pytest.mark.skipif(not WINDOWS, reason="WINDOWS only") def test_proc_oneshot(self): self.execute(lambda: cext.proc_oneshot(os.getpid())) class TestTerminatedProcessLeaks(TestProcessObjectLeaks): """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 def test_cpu_affinity_set_badarg(self): raise pytest.skip("skip") 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 cext.proc_oneshot(self.proc.pid) except ProcessLookupError: pass self.execute(call) @pytest.mark.skipif(not WINDOWS, reason="WINDOWS only") class TestProcessDualImplementation(MemoryLeakTestCase): def test_cmdline_peb_true(self): self.execute(lambda: cext.proc_cmdline(os.getpid(), use_peb=True)) def test_cmdline_peb_false(self): self.execute(lambda: cext.proc_cmdline(os.getpid(), use_peb=False)) # =================================================================== # system APIs # =================================================================== class TestModuleFunctionsLeaks(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) @pytest.mark.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) @pytest.mark.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 @pytest.mark.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) @pytest.mark.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 @pytest.mark.skipif(not HAS_NET_IO_COUNTERS, reason="not supported") def test_net_io_counters(self): self.execute(lambda: psutil.net_io_counters(nowrap=False)) @pytest.mark.skipif(MACOS and os.getuid() != 0, reason="need root access") def test_net_connections(self): # always opens and handle on Windows() (once) psutil.net_connections(kind='all') times = FEW_TIMES if LINUX else self.times with create_sockets(): self.execute( lambda: psutil.net_connections(kind='all'), times=times ) def test_net_if_addrs(self): if WINDOWS: # Calling GetAdaptersAddresses() for the first time # allocates internal OS handles. These handles persist for # the lifetime of the process, causing psleak to report # "unclosed handles". Call it here first to avoid false # positives. psutil.net_if_addrs() # 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 @pytest.mark.skipif(not HAS_SENSORS_BATTERY, reason="not supported") def test_sensors_battery(self): self.execute(psutil.sensors_battery) @pytest.mark.skipif(not HAS_SENSORS_TEMPERATURES, reason="not supported") @pytest.mark.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) @pytest.mark.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): if WINDOWS: # The first time this is called it allocates internal OS # handles. These handles persist for the lifetime of the # process, causing psleak to report "unclosed handles". # Call it here first to avoid false positives. psutil.users() self.execute(psutil.users) def test_set_debug(self): self.execute(lambda: psutil._set_debug(False)) @pytest.mark.skipif(not HAS_HEAP_INFO, reason="not supported") def test_heap_info(self): self.execute(psutil.heap_info) @pytest.mark.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(cext.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: cext.winservice_query_config(name)) def test_win_service_get_status(self): name = next(psutil.win_service_iter()).name() self.execute(lambda: cext.winservice_query_status(name)) def test_win_service_get_description(self): name = next(psutil.win_service_iter()).name() self.execute(lambda: cext.winservice_query_descr(name)) ================================================ FILE: tests/test_misc.py ================================================ #!/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 sys from unittest import mock import psutil from psutil import WINDOWS from psutil._common import bcat 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 wrap_numbers from . import HAS_NET_IO_COUNTERS from . import PsutilTestCase from . import process_namespace from . import pytest from . import reload_module from . import system_namespace # =================================================================== # --- Test classes' repr(), str(), ... # =================================================================== class TestSpecialMethods(PsutilTestCase): def test_check_pid_range(self): with pytest.raises(OverflowError): psutil._psplatform.cext.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')" ) def test_process__eq__(self): p1 = psutil.Process() p2 = psutil.Process() assert p1 == p2 p2._ident = (0, 0) assert p1 != p2 assert p1 != 'foo' def test_process__hash__(self): s = {psutil.Process(), psutil.Process()} assert len(s) == 1 # =================================================================== # --- 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', '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_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 def test_sanity_version_check(self): # see: https://github.com/giampaolo/psutil/issues/564 with mock.patch( "psutil._psplatform.cext.version", return_value="0.0.0" ): with pytest.raises(ImportError) as cm: reload_module(psutil) assert "version conflict" in str(cm.value).lower() # =================================================================== # --- 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_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" # =================================================================== # --- 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('?!?') @pytest.mark.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 == ({}, {}, {}) ================================================ FILE: tests/test_osx.py ================================================ #!/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 . import AARCH64 from . import CI_TESTING from . import HAS_BATTERY from . import HAS_CPU_FREQ from . import TOLERANCE_DISK_USAGE from . import TOLERANCE_SYS_MEM from . import PsutilTestCase from . import pytest from . import retry_on_failure from . import sh 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._psplatform.cext.getpagesize() ) @pytest.mark.skipif(not MACOS, reason="MACOS only") class MacosTestCase(PsutilTestCase): pass class TestProcess(MacosTestCase): @classmethod def setUpClass(cls): cls.pid = spawn_subproc().pid @classmethod def tearDownClass(cls): terminate(cls.pid) def test_process_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)) class TestSystemAPIs(MacosTestCase): # --- disk @retry_on_failure() 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 assert abs(usage.free - free) < TOLERANCE_DISK_USAGE assert abs(usage.used - used) < TOLERANCE_DISK_USAGE # --- cpu 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) @pytest.mark.skipif( MACOS and AARCH64 and not HAS_CPU_FREQ, reason="not available on MACOS + AARCH64", ) 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") # --- virtual mem def test_vmem_total(self): sysctl_hwphymem = sysctl('sysctl hw.memsize') assert sysctl_hwphymem == psutil.virtual_memory().total @pytest.mark.skipif( CI_TESTING and MACOS and AARCH64, reason="skipped on MACOS + ARM64 + CI_TESTING", ) @retry_on_failure() def test_vmem_free(self): vmstat_val = vm_stat("free") psutil_val = psutil.virtual_memory().free assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM @pytest.mark.skipif( CI_TESTING and MACOS and AARCH64, reason="skipped on MACOS + ARM64 + CI_TESTING", ) @retry_on_failure() def test_vmem_active(self): vmstat_val = vm_stat("active") psutil_val = psutil.virtual_memory().active assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM # XXX: fails too often @pytest.mark.skipif(CI_TESTING, reason="skipped on CI_TESTING") @retry_on_failure() def test_vmem_inactive(self): vmstat_val = vm_stat("inactive") psutil_val = psutil.virtual_memory().inactive assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM @retry_on_failure() def test_vmem_wired(self): vmstat_val = vm_stat("wired") psutil_val = psutil.virtual_memory().wired assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM # --- swap mem @retry_on_failure() def test_swapmem_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_swapmem_sout(self): vmstat_val = vm_stat("Pageout") psutil_val = psutil.swap_memory().sout assert abs(psutil_val - vmstat_val) < TOLERANCE_SYS_MEM # --- network 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]) # --- sensors_battery @pytest.mark.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) # --- others 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 ================================================ FILE: tests/test_posix.py ================================================ #!/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 shutil 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 . import AARCH64 from . import HAS_NET_IO_COUNTERS from . import PYTHON_EXE from . import PsutilTestCase from . import pytest from . import retry_on_failure from . import sh from . import skip_on_access_denied from . import spawn_subproc from . import terminate if POSIX: import mmap import resource 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. """ 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) @pytest.mark.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() @pytest.mark.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 @pytest.mark.skipif(SUNOS, reason="not reliable on SUNOS") @pytest.mark.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 @retry_on_failure() def test_num_ctx_switches(self): ru = resource.getrusage(resource.RUSAGE_SELF) cws = psutil.Process().num_ctx_switches() tol = 50 if "PYTEST_XDIST_WORKER_COUNT" in os.environ: tol *= int(os.environ["PYTEST_XDIST_WORKER_COUNT"]) if MACOS: assert cws.voluntary + cws.involuntary == pytest.approx( ru.ru_nvcsw + ru.ru_nivcsw, abs=tol * 2 ) else: assert cws.voluntary == pytest.approx(ru.ru_nvcsw, abs=tol) assert cws.involuntary == pytest.approx(ru.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() def test_page_faults(self): ru = resource.getrusage(resource.RUSAGE_SELF) pf = psutil.Process().page_faults() tol = 5 assert pf.minor == pytest.approx(ru.ru_minflt, abs=tol) assert pf.major == pytest.approx(ru.ru_majflt, abs=tol) @pytest.mark.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): mem = psutil.Process().memory_info_ex() if not hasattr(mem, "peak_rss"): return pytest.skip("not supported") ru = resource.getrusage(resource.RUSAGE_SELF) # VmHWM (from /proc/pid/status) and ru_maxrss both track peak # RSS but are synced independently. Allow 5% tolerance. if MACOS: rss_diff = abs(mem.peak_rss - ru.ru_maxrss) else: rss_diff = abs(mem.peak_rss - ru.ru_maxrss * 1024) 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 @pytest.mark.skipif(SUNOS, reason="unreliable on SUNOS") @pytest.mark.skipif(not shutil.which("ifconfig"), reason="no ifconfig cmd") @pytest.mark.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}" ) @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: try: pid = int(line.split()[-2]) except ValueError: pid = int(line.split()[-1]) 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 @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}") with self.subTest(psutil=str(psutil.users()), who=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 @pytest.mark.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.device) 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 class TestMisc(PosixTestCase): def test_getpagesize(self): pagesize = psutil._psplatform.cext.getpagesize() assert pagesize > 0 assert pagesize == resource.getpagesize() assert pagesize == mmap.PAGESIZE ================================================ FILE: tests/test_process.py ================================================ #!/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 textwrap 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 NETBSD from psutil import OPENBSD from psutil import OSX from psutil import POSIX from psutil import WINDOWS 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_FOOTPRINT from . import HAS_PROC_MEMORY_MAPS from . import HAS_PROC_RLIMIT from . import HAS_PROC_THREADS from . import MACOS_11PLUS 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_c_exe from . import create_py_exe 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 wait_for_pid # =================================================================== # --- 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) @pytest.mark.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))) @pytest.mark.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())) @pytest.mark.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 @pytest.mark.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 @pytest.mark.skipif(not HAS_PROC_IONICE, reason="not supported") @pytest.mark.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) @pytest.mark.skipif(not HAS_PROC_IONICE, reason="not supported") @pytest.mark.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) @pytest.mark.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 @pytest.mark.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)) @pytest.mark.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) @pytest.mark.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) @pytest.mark.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)) @pytest.mark.xdist_group(name="serial") 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 @pytest.mark.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 @pytest.mark.skipif(not HAS_PROC_THREADS, reason="not supported") 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) @pytest.mark.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 def test_memory_info_ex(self): p = psutil.Process() mem = p.memory_info_ex() self.check_proc_memory(mem) total = psutil.virtual_memory().total for name in mem._fields: if name != "vms": value = getattr(mem, name) assert value <= total def test_memory_info_ex_fields_order(self): mem = psutil.Process().memory_info_ex() common = ("rss", "vms") assert mem._fields[:2] == common if LINUX: assert mem._fields[2:] == ( "shared", "text", "data", "peak_rss", "peak_vms", "rss_anon", "rss_file", "rss_shmem", "swap", "hugetlb", ) elif MACOS: assert mem._fields[2:] == ( "peak_rss", "rss_anon", "rss_file", "wired", "compressed", "phys_footprint", ) elif WINDOWS: assert mem._fields[2:] == ( "peak_rss", "peak_vms", "virtual", "peak_virtual", "paged_pool", "nonpaged_pool", "peak_paged_pool", "peak_nonpaged_pool", ) else: assert mem._fields == psutil.Process().memory_info_ex()._fields @pytest.mark.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 @pytest.mark.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 @pytest.mark.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() p.memory_percent() with pytest.raises(ValueError): p.memory_percent(memtype="?!?") if LINUX or MACOS or WINDOWS: p.memory_percent(memtype='uss') 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): cmdline = [ PYTHON_EXE, "-c", "import time; [time.sleep(0.1) for x in range(100)]", ] p = self.spawn_psproc(cmdline) 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_long_cmdline(self): cmdline = [PYTHON_EXE] cmdline.extend(["-v"] * 50) cmdline.extend( ["-c", "import time; [time.sleep(0.1) for x in range(100)]"] ) p = self.spawn_psproc(cmdline) # XXX - flaky test: exclude the python exe which, for some # reason, and only sometimes, on OSX appears different. cmdline = cmdline[1:] if OPENBSD: # XXX: for some reason the test process may turn into a # zombie (don't know why). try: assert p.cmdline()[1:] == cmdline except psutil.ZombieProcess: return pytest.skip("OPENBSD: process turned into zombie") else: ret = p.cmdline()[1:] if NETBSD and ret == []: # https://github.com/giampaolo/psutil/issues/2250 return pytest.skip("OPENBSD: returned EBUSY") assert ret == 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) @pytest.mark.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() @pytest.mark.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 if 'USERDOMAIN' in os.environ: assert domain == os.environ['USERDOMAIN'] 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())) @pytest.mark.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)) @pytest.mark.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]) @pytest.mark.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) # TODO: #595 @pytest.mark.skipif(BSD, reason="broken on BSD") 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() filenames = [os.path.normcase(x.path) for x in files] assert os.path.normcase(testfn) in filenames if LINUX: for file in files: if file.path == testfn: assert file.position == 1024 for file in files: assert os.path.isfile(file.path), file # another process cmdline = ( f"import time; f = open(r'{testfn}', 'r'); [time.sleep(0.1) for x" " in range(100)];" ) p = self.spawn_psproc([PYTHON_EXE, "-c", cmdline]) 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: assert os.path.normcase(testfn) in filenames for file in filenames: assert os.path.isfile(file), file # TODO: #595 @pytest.mark.skipif(BSD, reason="broken on BSD") 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}") 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() @pytest.mark.skipif(not POSIX, reason="POSIX only") @pytest.mark.xdist_group(name="serial") 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) @pytest.mark.skipif( OPENBSD or NETBSD, reason="not reliable on OPENBSD & NETBSD" ) 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 parent.children() assert not 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 = parent.children() children2 = 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 parent.children() assert not 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 = parent.children() children2 = 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 = 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_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 resut 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) @pytest.mark.skipif(not POSIX, reason="POSIX only") def test_zombie_process(self): parent, zombie = self.spawn_zombie() self.assert_proc_zombie(zombie) if hasattr(psutil._psplatform.cext, "proc_is_zombie"): assert not psutil._psplatform.cext.proc_is_zombie(os.getpid()) assert psutil._psplatform.cext.proc_is_zombie(zombie.pid) parent.terminate() parent.wait() zombie.wait() @pytest.mark.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 @pytest.mark.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_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_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) @pytest.mark.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 @pytest.mark.skipif(not HAS_PROC_ENVIRON, reason="not supported") @pytest.mark.skipif(not POSIX, reason="POSIX only") @pytest.mark.skipif( MACOS_11PLUS, reason="macOS 11+ can't get another process environment, issue #2084", ) @pytest.mark.skipif( NETBSD, reason="sometimes fails on `assert is_running()`" ) def test_weird_environ(self): # environment variables can contain values without an equals sign code = textwrap.dedent(""" #include #include 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); } """) cexe = create_c_exe(self.get_testfn(), c_code=code) sproc = self.spawn_subproc( [cexe], stdin=subprocess.PIPE, stderr=subprocess.PIPE ) p = psutil.Process(sproc.pid) wait_for_pid(p.pid) assert p.is_running() # Wait for process to exec or exit. assert sproc.stderr.read() == b"" if MACOS and CI_TESTING: try: env = p.environ() except psutil.AccessDenied: # XXX: fails sometimes with: # PermissionError from 'sysctl(KERN_PROCARGS2) -> EIO' return else: env = p.environ() assert env == {"A": "1", "C": "3"} sproc.communicate() assert sproc.returncode == 0 # =================================================================== # --- 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) @pytest.mark.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 @pytest.mark.skipif(NETBSD, reason="fails on NETBSD") 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.time() + GLOBAL_TIMEOUT while time.time() < 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() @pytest.mark.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() @pytest.mark.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 @pytest.mark.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 @pytest.mark.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], ) @pytest.mark.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 @pytest.mark.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) @pytest.mark.skipif( not hasattr(select, "kqueue"), reason="MACOS and BSD only" ) def test_kqueue_race(self): self.assert_wait_pid_race("select.kqueue", select.kqueue) @pytest.mark.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() @pytest.mark.skipif(MACOS and GITHUB_ACTIONS, reason="hangs on OSX + CI") 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", "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 proc.terminate() if POSIX: assert proc.wait(5) == -signal.SIGTERM else: assert proc.wait(5) == signal.SIGTERM 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 ================================================ FILE: tests/test_process_all.py ================================================ #!/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 enum import errno import multiprocessing 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 PYTEST_PARALLEL 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 create_sockets from . import is_namedtuple from . import is_win_secure_system_proc from . import process_namespace # Cuts the time in half, but (e.g.) on macOS the process pool stays # alive after join() (multiprocessing bug?), messing up other tests. USE_PROC_POOL = LINUX and not CI_TESTING and not PYTEST_PARALLEL def proc_info(pid): tcase = PsutilTestCase() def check_exception(exc, proc, name, ppid): assert exc.pid == pid if exc.name is not None: assert exc.name == name if isinstance(exc, psutil.ZombieProcess): tcase.assert_proc_zombie(proc) if exc.ppid is not None: assert exc.ppid >= 0 assert exc.ppid == ppid elif isinstance(exc, psutil.NoSuchProcess): tcase.assert_proc_gone(proc) str(exc) repr(exc) def do_wait(): if pid != 0: try: proc.wait(0) except psutil.Error as exc: check_exception(exc, proc, name, ppid) try: proc = psutil.Process(pid) except psutil.NoSuchProcess: tcase.assert_pid_gone(pid) return {} try: d = proc.as_dict(['ppid', 'name']) except psutil.NoSuchProcess: tcase.assert_proc_gone(proc) else: name, ppid = d['name'], d['ppid'] info = {'pid': proc.pid} ns = process_namespace(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): try: ret = fun() except psutil.Error as exc: check_exception(exc, proc, name, ppid) continue else: check_fun_type_hints(fun, ret) if is_namedtuple(ret): check_ntuple_type_hints(ret) info[fun_name] = ret do_wait() return info 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) # Using a pool in a CI env may result in deadlock, see: # https://github.com/giampaolo/psutil/issues/2104 if USE_PROC_POOL: # The 'fork' method is the only one that does not # create a "resource_tracker" process. The problem # when creating this process is that it ignores # SIGTERM and SIGINT, and this makes "reap_children" # hang... The following code should run on python-3.4 # and later. multiprocessing.set_start_method('fork') self.pool = multiprocessing.Pool() def tearDown(self): psutil._set_debug(True) if USE_PROC_POOL: self.pool.terminate() self.pool.join() def iter_proc_info(self): # Fixes "can't pickle : it's not the # same object as test_process_all.proc_info". from tests.test_process_all import proc_info if USE_PROC_POOL: return self.pool.imap_unordered(proc_info, psutil.pids()) else: ls = [proc_info(pid) for pid in psutil.pids()] return ls def test_all(self): failures = [] for info in self.iter_proc_info(): 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 += '-' * 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 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, "" 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 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_percent(self, ret, info): assert isinstance(ret, float) assert 0.0 <= ret <= 100.0, ret 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_info_ex(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): with create_sockets(): 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 memory_percent(self, ret, info): assert isinstance(ret, float) assert 0 <= ret <= 100, ret def is_running(self, ret, info): assert isinstance(ret, bool) 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) ================================================ FILE: tests/test_scripts.py ================================================ #!/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 psutil import WINDOWS 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 SCRIPTS_DIR = pathlib.Path(ROOT_DIR) / "scripts" INTERNAL_SCRIPTS_DIR = SCRIPTS_DIR / "internal" # =================================================================== # --- Tests scripts in scripts/ directory # =================================================================== @pytest.mark.skipif( CI_TESTING and not os.path.exists(SCRIPTS_DIR), reason="can't find scripts/ directory", ) class TestExampleScripts(PsutilTestCase): @staticmethod def assert_stdout(exe, *args): env = PYTHON_EXE_ENV.copy() env.pop("PSUTIL_DEBUG", None) # avoid spamming to stderr exe = os.path.join(SCRIPTS_DIR, exe) 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 @staticmethod def assert_syntax(exe): exe = os.path.join(SCRIPTS_DIR, exe) with open(exe, encoding="utf8") as f: src = f.read() ast.parse(src) 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" ) @pytest.mark.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())) @pytest.mark.skipif(CI_TESTING and not psutil.users(), reason="no users") 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') def test_ifconfig(self): self.assert_stdout('ifconfig.py') @pytest.mark.skipif(not HAS_PROC_MEMORY_MAPS, reason="not supported") def test_pmap(self): self.assert_stdout('pmap.py', str(os.getpid())) @pytest.mark.skipif(not HAS_PROC_MEMORY_FOOTPRINT, reason="not supported") def test_procsmem(self): self.assert_stdout('procsmem.py') 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 @pytest.mark.skipif(not WINDOWS, reason="WINDOWS only") def test_winservices(self): self.assert_stdout('winservices.py') def test_cpu_distribution(self): self.assert_syntax('cpu_distribution.py') @pytest.mark.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') @pytest.mark.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') @pytest.mark.skipif(not HAS_SENSORS_BATTERY, reason="not supported") @pytest.mark.skipif(not HAS_BATTERY, reason="no battery") def test_battery(self): self.assert_stdout('battery.py') @pytest.mark.skipif(not HAS_SENSORS_BATTERY, reason="not supported") @pytest.mark.skipif(not HAS_BATTERY, reason="no battery") def test_sensors(self): self.assert_stdout('sensors.py') # =================================================================== # --- Tests scripts in scripts/internal/ directory # =================================================================== @pytest.mark.skipif( CI_TESTING and not os.path.exists(INTERNAL_SCRIPTS_DIR), reason="can't find scripts/internal/ directory", ) class TestInternalScripts(PsutilTestCase): @staticmethod def ls(): for name in os.listdir(INTERNAL_SCRIPTS_DIR): if name.endswith(".py"): yield os.path.join(INTERNAL_SCRIPTS_DIR, name) 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 @pytest.mark.skipif(not LINUX, reason="not on LINUX") @pytest.mark.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 ================================================ FILE: tests/test_sudo.py ================================================ #!/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 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") 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) ================================================ FILE: tests/test_sunos.py ================================================ #!/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 pytest from . import sh @pytest.mark.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')) ================================================ FILE: tests/test_system.py ================================================ #!/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 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._common import broadcast_addr from . import AARCH64 from . import ASCII_FS from . import CI_TESTING 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 PYPY from . import UNICODE_SUFFIX from . import PsutilTestCase from . import check_net_address from . import pytest from . import retry_on_failure # =================================================================== # --- 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.info.keys()) == ['pid'] # yield again for p in psutil.process_iter(attrs=['pid']): assert list(p.info.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.info['cpu_times'] is None assert p.info['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.info['cpu_times'] is flag assert p.info['pid'] >= 0 assert m.called 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): @pytest.mark.skipif( PYPY and WINDOWS, reason="spawn_subproc() unreliable on PYPY + WINDOWS", ) 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.time() gone, alive = psutil.wait_procs(procs, timeout=0.01, callback=callback) assert time.time() - 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') @pytest.mark.skipif( PYPY and WINDOWS, reason="spawn_subproc() unreliable on PYPY + WINDOWS", ) 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() @pytest.mark.skipif( CI_TESTING and not psutil.users(), reason="unreliable on CI" ) def test_users(self): 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) @pytest.mark.skipif(not HAS_HEAP_INFO, reason="not supported") def test_heap_info(self): m = psutil.heap_info() assert m.heap_used > 0 if MACOS: assert m.mmap_used == 0 # not supported else: assert m.mmap_used > 0 if WINDOWS: assert m.heap_count >= 0 @pytest.mark.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: # 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 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.time() + GLOBAL_TIMEOUT while time.time() < 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 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) # 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.time() + GLOBAL_TIMEOUT while True: if time.time() >= 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 @pytest.mark.skipif( (CI_TESTING and OPENBSD) or MACOS, reason="unreliable on OPENBSD + CI" ) @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. On OpenBSD the sum of per-CPUs is # higher for some reason. 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: with self.subTest( field=field, base=str(base), per_cpu=str(per_cpu) ): assert ( abs(getattr(base, field) - getattr(summed_values, field)) < 2 ) 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 @pytest.mark.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() 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 OSError ENOENT is expected across # all platforms fname = self.get_testfn() with pytest.raises(FileNotFoundError): psutil.disk_usage(fname) @pytest.mark.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 @pytest.mark.skipif( LINUX and not os.path.exists('/proc/diskstats'), reason="/proc/diskstats not available on this linux version", ) @pytest.mark.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): @pytest.mark.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]) @pytest.mark.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, 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) 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) @pytest.mark.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( 'psutil._psplatform.cext.net_if_mtu', side_effect=OSError(errno.ENODEV, ""), ) as m: ret = psutil.net_if_stats() assert ret == {} assert m.called class TestSensorsAPIs(PsutilTestCase): @pytest.mark.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 @pytest.mark.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 @pytest.mark.skipif(not HAS_SENSORS_BATTERY, reason="not supported") @pytest.mark.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) @pytest.mark.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 ================================================ FILE: tests/test_testutils.py ================================================ #!/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 retry from . import safe_mkdir from . import safe_rmpath from . import system_namespace from . import tcp_socketpair from . import terminate from . import unix_socketpair from . import wait_for_file 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_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 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() @pytest.mark.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) class TestNetUtils(PsutilTestCase): def bind_socket(self): port = get_free_port() with bind_socket(addr=('', port)) as s: assert s.getsockname()[1] == port @pytest.mark.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 @pytest.mark.skipif(not POSIX, reason="POSIX only") @pytest.mark.skipif( NETBSD or FREEBSD, reason="/var/run/log UNIX socket opened by default" ) @pytest.mark.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() 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()) ================================================ FILE: tests/test_type_hints.py ================================================ #!/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 functools import sys import types import pytest import psutil 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 system_namespace @pytest.mark.skipif( sys.version_info[:2] <= (3, 7), reason="not supported on Python <= 3.7" ) 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) # ===================================================================== # --- 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)) @pytest.mark.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): @pytest.mark.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") @pytest.mark.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") @pytest.mark.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]) @pytest.mark.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") @pytest.mark.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") @pytest.mark.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") @pytest.mark.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") ================================================ FILE: tests/test_unicode.py ================================================ #!/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 NETBSD from psutil import OPENBSD from psutil import POSIX from psutil import WINDOWS from . import ASCII_FS from . import CI_TESTING from . import HAS_NET_CONNECTIONS_UNIX from . import HAS_PROC_ENVIRON from . import HAS_PROC_MEMORY_MAPS from . import INVALID_UNICODE_SUFFIX from . import PYPY 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 skip_on_access_denied 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) # =================================================================== # 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") @pytest.mark.xdist_group(name="serial") @pytest.mark.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 @pytest.mark.skipif(PYPY and WINDOWS, reason="fails on PYPY + WINDOWS") @pytest.mark.skipif( NETBSD or OPENBSD, reason="broken on NETBSD or OPENBSD" ) 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) @pytest.mark.skipif(not POSIX, reason="POSIX only") @pytest.mark.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): conn = psutil.Process().net_connections('unix')[0] assert isinstance(conn.laddr, str) if not conn.laddr and MACOS and CI_TESTING: return pytest.skip("unreliable on OSX") assert conn.laddr == name @pytest.mark.skipif(not POSIX, reason="POSIX only") @pytest.mark.skipif( not HAS_NET_CONNECTIONS_UNIX, reason="can't list UNIX sockets" ) @skip_on_access_denied() def test_net_connections(self): def find_sock(cons): for conn in cons: if os.path.basename(conn.laddr).startswith(TESTFN_PREFIX): return conn raise ValueError("connection not found") 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) @pytest.mark.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) @pytest.mark.skipif(CI_TESTING, reason="unreliable on CI") 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 @pytest.mark.skipif(not HAS_PROC_ENVIRON, reason="not supported") @pytest.mark.skipif(PYPY and WINDOWS, reason="segfaults on PYPY + WINDOWS") 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 ================================================ FILE: tests/test_windows.py ================================================ #!/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 glob import os import platform import re import signal import socket import subprocess import sys import time import warnings from unittest import mock import psutil from psutil import WINDOWS from . import GITHUB_ACTIONS from . import HAS_BATTERY from . import IS_64BIT from . import PYPY from . import TOLERANCE_DISK_USAGE from . import TOLERANCE_SYS_MEM from . import PsutilTestCase from . import pytest from . import retry_on_failure from . import sh 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 convert_oserror cext = psutil._psplatform.cext @pytest.mark.skipif(not WINDOWS, reason="WINDOWS only") @pytest.mark.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 TestCpuAPIs(WindowsTestCase): @pytest.mark.skipif( 'NUMBER_OF_PROCESSORS' not in os.environ, reason="NUMBER_OF_PROCESSORS env var is not available", ) def test_cpu_count_vs_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_cpu_count_vs_GetSystemInfo(self): # Will likely fail on many-cores systems: # https://stackoverflow.com/questions/31209256 assert psutil.cpu_count() == win32api.GetSystemInfo()[5] def test_cpu_count_logical_vs_wmi(self): w = wmi.WMI() procs = sum( proc.NumberOfLogicalProcessors for proc in w.Win32_Processor() ) assert psutil.cpu_count() == procs def test_cpu_count_cores_vs_wmi(self): w = wmi.WMI() cores = sum(proc.NumberOfCores for proc in w.Win32_Processor()) assert psutil.cpu_count(logical=False) == cores def test_cpu_count_vs_cpu_times(self): assert psutil.cpu_count() == len(psutil.cpu_times(percpu=True)) def test_cpu_times_irq_field(self): t = psutil.cpu_times() assert t.irq >= 0 with pytest.warns(DeprecationWarning, match="interrupt"): assert t.interrupt == t.irq def test_cpu_freq(self): w = wmi.WMI() proc = w.Win32_Processor()[0] assert abs(proc.CurrentClockSpeed - psutil.cpu_freq().current) < 100 assert proc.MaxClockSpeed == psutil.cpu_freq().max class TestVirtualMemory(WindowsTestCase): def test_total(self): w = wmi.WMI().Win32_ComputerSystem()[0] assert int(w.TotalPhysicalMemory) == psutil.virtual_memory().total 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 ) class TestSystemAPIs(WindowsTestCase): def test_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" ) 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 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_total_swapmem(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_swapmem(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 # @pytest.mark.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())) # Note: this test is not very reliable @retry_on_failure() 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 = {x.ProcessId for x in w} psutil_pids = set(psutil.pids()) assert wmi_pids == psutil_pids @retry_on_failure() 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 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}") @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 def test_disk_partitions(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 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( 'psutil._pswindows.cext.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_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) assert ( ps_names & wmi_names ), f"no common entries in {ps_names}, {wmi_names}" 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_uptime(self): # ...against GetTickCount64() (Windows < 7, does not include # time spent during suspend / hybernate). ms = ctypes.windll.kernel32.GetTickCount64() secs = ms / 1000.0 assert abs(cext.uptime() - secs) < 0.5 # =================================================================== # 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 @pytest.mark.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 ) @pytest.mark.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) @pytest.mark.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_no_battery(self): with mock.patch( "psutil._pswindows.cext.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( "psutil._pswindows.cext.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( "psutil._pswindows.cext.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( "psutil._pswindows.cext.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 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_info_ex() 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_info_ex(self): win = win32process.GetProcessMemoryInfo(self.OpenProcess(self.pid)) ps = psutil.Process(self.pid).memory_info_ex() 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("psutil._psplatform.cext.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 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 # This fail on github because using virtualenv for test environment @pytest.mark.skipif( GITHUB_ACTIONS, reason="unreliable path on GITHUB_ACTIONS" ) 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 # --- @pytest.mark.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( "psutil._psplatform.cext.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( "psutil._psplatform.cext.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( "psutil._psplatform.cext.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( "psutil._psplatform.cext.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( "psutil._psplatform.cext.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 = cext.proc_cmdline(pid, use_peb=True) b = cext.proc_cmdline(pid, use_peb=False) except OSError as err: err = convert_oserror(err) if not isinstance( err, (psutil.AccessDenied, psutil.NoSuchProcess) ): raise else: assert a == b @pytest.mark.skipif(not WINDOWS, reason="WINDOWS only") class RemoteProcessTestCase(PsutilTestCase): """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() proc.wait() if output == str(not IS_64BIT): return filename test_args = ["-c", "import sys; sys.stdin.read()"] def setUp(self): super().setUp() other_python = self.find_other_interpreter() if other_python is None: return pytest.skip( "could not find interpreter with opposite bitness" ) if IS_64BIT: self.python64 = sys.executable self.python32 = other_python else: self.python64 = other_python self.python32 = sys.executable env = os.environ.copy() env["THINK_OF_A_NUMBER"] = str(os.getpid()) self.proc32 = self.spawn_subproc( [self.python32] + self.test_args, env=env, stdin=subprocess.PIPE ) self.proc64 = self.spawn_subproc( [self.python64] + self.test_args, env=env, stdin=subprocess.PIPE ) def tearDown(self): super().tearDown() self.proc32.communicate() self.proc64.communicate() def test_cmdline_32(self): p = psutil.Process(self.proc32.pid) assert len(p.cmdline()) == 3 assert p.cmdline()[1:] == self.test_args def test_cmdline_64(self): p = psutil.Process(self.proc64.pid) assert len(p.cmdline()) == 3 assert p.cmdline()[1:] == self.test_args def test_cwd_32(self): p = psutil.Process(self.proc32.pid) assert p.cwd() == os.getcwd() def test_cwd_64(self): p = psutil.Process(self.proc64.pid) assert p.cwd() == os.getcwd() def test_environ_32(self): p = psutil.Process(self.proc32.pid) e = p.environ() assert "THINK_OF_A_NUMBER" in e assert e["THINK_OF_A_NUMBER"] == str(os.getpid()) def test_environ_64(self): p = psutil.Process(self.proc64.pid) try: p.environ() except psutil.AccessDenied: pass # =================================================================== # Windows services # =================================================================== @pytest.mark.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._psplatform.cext.ERROR_SERVICE_DOES_NOT_EXIST ) ERROR_ACCESS_DENIED = psutil._psplatform.cext.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( "psutil._psplatform.cext.winservice_query_status", side_effect=exc ): with pytest.raises(psutil.NoSuchProcess): service.status() with mock.patch( "psutil._psplatform.cext.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( "psutil._psplatform.cext.winservice_query_status", side_effect=exc ): with pytest.raises(psutil.AccessDenied): service.status() with mock.patch( "psutil._psplatform.cext.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)