smem2.smem2

   1import os
   2import pwd
   3import re
   4import sys
   5from dataclasses import dataclass, field
   6from typing import Set
   7
   8
   9@dataclass
  10class SmemConfig:
  11    """Stores the configuration for smem2.
  12
  13    This dataclass holds all the configuration options for smem2,
  14    mostly populated from command-line arguments.
  15    """
  16
  17    # from parse_arguments
  18    no_header: bool = False
  19    columns: str = ""
  20    autosize: bool = False
  21    realmem: str | None = None
  22    kernel: str | None = None
  23    basename: bool = False
  24    quiet: bool = False
  25    processfilter: str | None = None
  26    mapfilter: str | None = None
  27    userfilter: str | None = None
  28    pid: int | None = None
  29    ignorecase: bool = False
  30    mappings: bool = False
  31    users: bool = False
  32    system: bool = False
  33    sysdetail: bool = False
  34    groupcmd: bool = False
  35    percent: bool = False
  36    abbreviate: bool = False
  37    totals: bool = False
  38    totalsonly: bool = False
  39    format: str = "raw"
  40    numeric: bool = False
  41    sort: str | None = None
  42    reverse: bool = False
  43    cmd_width: int = -1
  44    name_width: int = -1
  45    user_width: int = -1
  46    mapping_width: int = -1
  47
  48    # from setdatasources and other globals
  49    # these are not set by user but determined at runtime
  50    rssdetail: bool = False
  51    pssdetail: bool = True
  52    rollup: bool = True
  53    swappss: bool = False
  54    ownpid: int = 0
  55    ignore_autosize: Set[str] = field(default_factory=set)
  56
  57
  58class UIDCache(object):
  59    """A cache for user ID to username mappings.
  60
  61    This class avoids repeated lookups of UIDs by caching the results.
  62    """
  63
  64    def __init__(self):
  65        """Initializes the UIDCache."""
  66        self._cache = {}
  67
  68    def __call__(self, uid):
  69        """Retrieves the username for a given UID, populating the cache if necessary.
  70
  71        Args:
  72            uid (int): The user ID to look up.
  73
  74        Returns:
  75            str: The username associated with the UID.
  76        """
  77        return self._cache.setdefault(uid, self._getpwuid(uid))
  78
  79    @staticmethod
  80    def _getpwuid(uid):
  81        """Gets the username for a UID.
  82
  83        Args:
  84            uid (int): The user ID.
  85
  86        Returns:
  87            str: The username, or the UID as a string if the lookup fails.
  88        """
  89        try:
  90            return pwd.getpwuid(uid)[0]
  91        except KeyError:
  92            return str(uid)
  93
  94
  95class Proc(object):
  96    """Helper class to handle /proc/ filesystem data"""
  97
  98    def __init__(self):
  99        """Initializes the Proc helper."""
 100        pass
 101
 102    @staticmethod
 103    def listdir():
 104        """Lists the contents of /proc.
 105
 106        Returns:
 107            list[str]: A list of filenames in /proc.
 108        """
 109        return os.listdir("/proc")
 110
 111    @staticmethod
 112    def read(filename):
 113        """Reads a file from the /proc filesystem.
 114
 115        Args:
 116            filename (str): The name of the file in /proc to read.
 117
 118        Returns:
 119            str: The content of the file.
 120
 121        Raises:
 122            RuntimeError: If the file does not exist.
 123        """
 124        if not os.path.exists("/proc/" + filename):
 125            raise RuntimeError(
 126                f"File /proc/{filename} does not exist, are you sure you are running on a Linux system?"
 127            )
 128        return open("/proc/" + filename).read()
 129
 130    def readlines(self, filename):
 131        """Reads a file from /proc and splits it into lines.
 132
 133        Args:
 134            filename (str): The name of the file in /proc to read.
 135
 136        Returns:
 137            list[str]: A list of lines from the file.
 138        """
 139        return self.read(filename).splitlines(True)
 140
 141    def version(self):
 142        """Gets the Linux kernel version string.
 143
 144        Returns:
 145            str: The first line of /proc/version.
 146        """
 147        return self.readlines("version")[0]
 148
 149
 150class MemData(Proc):
 151    """Class accessing and storing /proc/meminfo data"""
 152
 153    def __init__(self):
 154        """Initializes MemData and parses /proc/meminfo."""
 155        self._memdata = {}
 156
 157        regex = re.compile("(?P<name>\\S+):\\s+(?P<amount>\\d+) kB")
 158        for line in self.readlines("meminfo"):
 159            match = regex.match(line)
 160            if match:
 161                self._memdata[match.group("name").lower()] = int(match.group("amount"))
 162
 163    def __call__(self, entry):
 164        """Retrieves a value from the stored meminfo data.
 165
 166        Args:
 167            entry (str): The key for the meminfo data to retrieve (e.g., 'memtotal').
 168
 169        Returns:
 170            int: The value from /proc/meminfo in kilobytes.
 171        """
 172        return self._memdata[entry]
 173
 174
 175class ProcessData(Proc):
 176    """Helper class to handle /proc/<pid> filesystem data"""
 177
 178    def __init__(self, config: SmemConfig):
 179        """Initializes ProcessData.
 180
 181        Args:
 182            config (SmemConfig): The smem2 configuration.
 183        """
 184        self._uidcache = UIDCache()
 185        self.config = config
 186
 187    def _iskernel(self, pid):
 188        """Checks if a process ID belongs to a kernel thread.
 189
 190        Kernel threads have an empty command line.
 191
 192        Args:
 193            pid (str): The process ID.
 194
 195        Returns:
 196            bool: True if the PID is a kernel thread, False otherwise.
 197        """
 198        return self.pidcmd(pid) == ""
 199
 200    @staticmethod
 201    def _stat(pid):
 202        """Gets the stat result for a process.
 203
 204        Args:
 205            pid (str): The process ID.
 206
 207        Returns:
 208            os.stat_result: The result of os.stat() on /proc/<pid>.
 209        """
 210        return os.stat("/proc/" + pid)
 211
 212    def pids(self):
 213        """Gets a list of process IDs.
 214
 215        Filters the list based on the configuration (e.g., specific PID).
 216        Excludes kernel threads and the smem2 process itself if a filter is active.
 217
 218        Returns:
 219            list[int]: A list of process IDs.
 220        """
 221        return [
 222            int(e)
 223            for e in self.listdir()
 224            if e.isdigit()
 225            and not self._iskernel(e)
 226            and ((self.config.pid and self.config.pid == int(e)) or not self.config.pid)
 227            and not ((int(e) == self.config.ownpid) and self.config.processfilter)
 228        ]
 229        # exclude own process when processfilter
 230
 231    def mapdata(self, pid):
 232        """Gets the smaps data for a process.
 233
 234        It prefers using smaps_rollup for performance if available and configured.
 235
 236        Args:
 237            pid (str): The process ID.
 238
 239        Returns:
 240            list[str]: The lines from the smaps or smaps_rollup file, or an empty list on error.
 241        """
 242        if self.config.rollup:
 243            try:
 244                return self.readlines(
 245                    "%s/smaps_rollup" % pid
 246                )  # smaps_rollup new from kernel 4.14, at least 7x faster for non maping listing
 247            except Exception:
 248                pass
 249        try:
 250            return self.readlines("%s/smaps" % pid)
 251        except (RuntimeError, PermissionError):
 252            return []
 253
 254    def pidcmd(self, pid):
 255        """Gets the command line for a process.
 256
 257        Args:
 258            pid (str): The process ID.
 259
 260        Returns:
 261            str: The command line of the process, or '?' on error.
 262        """
 263        try:
 264            c = self.read("%s/cmdline" % pid)[:-1]
 265            c = c.replace("\0", " ")
 266            if self.config.basename and not c == "":
 267                c = os.path.basename(c.split()[0])
 268            return c
 269        except Exception:
 270            return "?"
 271
 272    def piduser(self, pid):
 273        """Gets the UID of the process owner.
 274
 275        Args:
 276            pid (str): The process ID.
 277
 278        Returns:
 279            int: The user ID of the process owner, or -1 on error.
 280        """
 281        try:
 282            return self._stat("%d" % pid).st_uid
 283        except Exception:
 284            return -1
 285
 286    def username(self, uid):
 287        """Gets the username for a UID.
 288
 289        Args:
 290            uid (int): The user ID.
 291
 292        Returns:
 293            str: The username, or '?' if the UID is -1.
 294        """
 295        return "?" if uid == -1 else self._uidcache(uid)
 296
 297    def pidusername(self, pid):
 298        """Gets the username of the process owner.
 299
 300        Args:
 301            pid (int or str): The process ID.
 302
 303        Returns:
 304            str: The username of the process owner.
 305        """
 306        return self.username(self.piduser(pid))
 307
 308    def pidtostr(self, pid):
 309        """Converts a PID to a string.
 310
 311        Args:
 312            pid (int): The process ID.
 313
 314        Returns:
 315            str: The process ID as a string.
 316        """
 317        return str(pid)
 318
 319    def pidname(self, pid):
 320        """Gets the process name (from /proc/<pid>/comm).
 321
 322        Args:
 323            pid (str): The process ID.
 324
 325        Returns:
 326            str: The name of the process, or '?' on error.
 327        """
 328        try:
 329            return self.read("%s/comm" % pid)[:-1]
 330        except Exception:
 331            return "?"
 332
 333
 334def totalmem(config: SmemConfig):
 335    """Calculates the total memory to be used as a reference for percentages.
 336
 337    It can be based on real memory from dmidecode, a user-provided value,
 338    or the 'MemTotal' value from /proc/meminfo.
 339
 340    Args:
 341        config (SmemConfig): The smem2 configuration.
 342
 343    Returns:
 344        int: The total memory in kilobytes.
 345    """
 346    if config.realmem:
 347        return fromunits(config.realmem) / 1024
 348    else:
 349        if config.system or config.sysdetail:
 350            try:
 351                # only for systems running directly on HW
 352                ram = (
 353                    os.popen(
 354                        "dmidecode --type memory 2> /dev/null|awk '/Size: [0-9]+ MB/{sum+=$2};END{print sum}'",
 355                    )
 356                    .read()
 357                    .strip()
 358                )
 359                if ram.isdigit():
 360                    return fromunits(str(int(ram)) + "M") / 1024
 361            except Exception:
 362                pass
 363
 364        return MemData()("memtotal")
 365
 366
 367def pidmaps(pid, proc: ProcessData, config: SmemConfig, nomaps=False):
 368    """Parses the memory maps for a given process.
 369
 370    It reads /proc/<pid>/smaps or /proc/<pid>/smaps_rollup to get memory
 371    usage information for each mapping.
 372
 373    Args:
 374        pid (int or str): The process ID.
 375        proc (ProcessData): The ProcessData instance.
 376        config (SmemConfig): The smem2 configuration.
 377        nomaps (bool, optional): If True, only read the first mapping entry,
 378            used for feature detection. Defaults to False.
 379
 380    Returns:
 381        dict: A dictionary of memory mappings, where keys are start addresses.
 382    """
 383    maps: dict = {}
 384    start = None
 385    status = None
 386    if config.rollup or config.pssdetail or config.rssdetail:
 387        try:
 388            status = proc.readlines("%s/status" % pid)
 389        except (RuntimeError, PermissionError):
 390            status = None
 391
 392    for l in proc.mapdata(pid):
 393        f = l.split()
 394        if f[-1] == "kB":
 395            maps[start][f[0][:-1].lower()] = int(f[1])
 396        elif "-" in f[0] and ":" not in f[0]:  # looks like a mapping range
 397            start, end = f[0].split("-")
 398            start = int(start, 16)
 399            name = "<anonymous>"
 400            if len(f) > 5:
 401                name = f[5]
 402                if config.basename:
 403                    name = os.path.basename(name)
 404            maps[start] = dict(
 405                end=int(end, 16),
 406                perm=f[1],
 407                offset=int(f[2], 16),
 408                major=int(f[3].split(":")[0], 16),
 409                minor=int(f[3].split(":")[1], 16),
 410                inode=int(f[4]),
 411                name=name,
 412                pss=0,
 413                rss=0,
 414                uss=0,
 415                swap=0,
 416                swappss=0,
 417                pcent=0,
 418                size=0,
 419            )
 420            if config.pssdetail:
 421                (
 422                    maps[start]["pss_anon"],
 423                    maps[start]["pss_file"],
 424                    maps[start]["pss_shmem"],
 425                ) = (0, 0, 0)
 426
 427            # for nomaps mode: stop reading mappings
 428            if nomaps:
 429                break
 430
 431    # add pss, rss, uss if available from smaps
 432    if not config.rollup:
 433        if not config.pssdetail:
 434            for m in maps:
 435                maps[m]["uss"] = maps[m].get("private_clean", 0) + maps[m].get(
 436                    "private_dirty", 0
 437                )
 438                maps[m]["pss"] = maps[m]["uss"] + maps[m].get("shared_clean", 0) / 2
 439                maps[m]["rss"] = maps[m].get("shared_clean", 0) + maps[m].get(
 440                    "shared_dirty", 0
 441                )
 442        if config.rssdetail and status:
 443            # from /proc/pid/status
 444            for s in status:
 445                if "RssAnon" in s:
 446                    maps[start]["rss_anon"] = int(s.split()[1])
 447                elif "RssFile" in s:
 448                    maps[start]["rss_file"] = int(s.split()[1])
 449                elif "RssShmem" in s:
 450                    maps[start]["rss_shmem"] = int(s.split()[1])
 451
 452        # Parse VmSize for VSS calculation
 453        if status:
 454            for s in status:
 455                if "VmSize:" in s:
 456                    # Set size for the last mapping (rollup case) or all mappings
 457                    if config.rollup and start:
 458                        maps[start]["size"] = int(s.split()[1])
 459                    else:
 460                        # For non-rollup, distribute VmSize across all mappings
 461                        total_size = int(s.split()[1])
 462                        if maps:
 463                            size_per_map = (
 464                                total_size // len(maps) if len(maps) > 0 else 0
 465                            )
 466                            for m in maps:
 467                                maps[m]["size"] = size_per_map
 468                    break
 469
 470    # Apply mapfilter if specified
 471    if config.mapfilter and not nomaps:
 472        f = {}
 473        for m in maps:
 474            if not filters(config.mapfilter, m, config, lambda x: maps[x]["name"]):
 475                f[m] = maps[m]
 476        return f
 477    return maps
 478
 479
 480def maptotals(pids, proc: ProcessData, config: SmemConfig):
 481    """Aggregates memory usage data for a list of pids, including map details.
 482
 483    For each process, it gets memory totals (PSS, RSS, USS, etc.) and
 484    detailed mapping information. It applies process and user filters.
 485
 486    Args:
 487        pids (list[int]): A list of process IDs.
 488        proc (ProcessData): The ProcessData instance.
 489        config (SmemConfig): The smem2 configuration.
 490
 491    Returns:
 492        dict: A dictionary where keys are process IDs and values are dictionaries
 493              containing memory totals and mapping details for each process.
 494    """
 495    pt: dict = {}
 496    for p in pids:
 497        if filters(
 498            config.processfilter, p, config, proc.pidcmd, proc.pidtostr, proc.pidname
 499        ) or filters(config.userfilter, p, config, proc.pidusername):
 500            continue
 501        maps = pidmaps(p, proc, config)
 502        if maps:
 503            pt[p] = {}
 504            pt[p]["maps"] = maps
 505            totals = pidtotals(p, proc, config)
 506            # Flatten the totals into the main dict for compatibility with display code
 507            pt[p].update(totals)
 508    return pt
 509
 510
 511def pidtotals(pid, proc: ProcessData, config: SmemConfig):
 512    """Calculates the total memory usage (PSS, RSS, USS, etc.) for a single process.
 513
 514    It sums up the values from all memory mappings of the process.
 515
 516    Args:
 517        pid (int or str): The process ID.
 518        proc (ProcessData): The ProcessData instance.
 519        config (SmemConfig): The smem2 configuration.
 520
 521    Returns:
 522        dict: A dictionary with total PSS, RSS, USS, Swap, etc., for the process.
 523    """
 524    totals: dict = {}
 525    maps = pidmaps(pid, proc, config)
 526    if maps:
 527        maplist = maps.values()
 528        totals["pss"] = sum([m.get("pss", 0) for m in maplist])
 529        totals["rss"] = sum([m.get("rss", 0) for m in maplist])
 530        private_clean = sum(m.get("private_clean", 0) for m in maplist)
 531        private_dirty = sum(m.get("private_dirty", 0) for m in maplist)
 532        totals["uss"] = private_clean + private_dirty
 533        totals["swap"] = sum([m.get("swap", 0) for m in maplist])
 534        totals["size"] = sum([m.get("size", 0) for m in maplist])
 535        totals["maps"] = len(maps)
 536        if config.swappss:
 537            totals["swappss"] = sum([m.get("swappss", 0) for m in maplist])
 538        if config.pssdetail:
 539            totals["pss_anon"] = sum([m.get("pss_anon", 0) for m in maplist])
 540            totals["pss_file"] = sum([m.get("pss_file", 0) for m in maplist])
 541            totals["pss_shmem"] = sum([m.get("pss_shmem", 0) for m in maplist])
 542        if config.rssdetail:
 543            totals["rss_anon"] = sum([m.get("rss_anon", 0) for m in maplist])
 544            totals["rss_file"] = sum([m.get("rss_file", 0) for m in maplist])
 545            totals["rss_shmem"] = sum([m.get("rss_shmem", 0) for m in maplist])
 546    return totals
 547
 548
 549def usertotals(pids, proc: ProcessData, config: SmemConfig):
 550    """Aggregates memory usage by user.
 551
 552    It groups processes by user and calculates the total memory usage for each user.
 553
 554    Args:
 555        pids (list[int]): A list of process IDs to analyze.
 556        proc (ProcessData): The ProcessData instance.
 557        config (SmemConfig): The smem2 configuration.
 558
 559    Returns:
 560        dict: A dictionary where keys are user IDs and values are dictionaries
 561              containing process lists and memory totals for each user.
 562    """
 563    ut: dict = {}
 564    for p in pids:
 565        if filters(
 566            config.processfilter, p, config, proc.pidcmd, proc.pidtostr, proc.pidname
 567        ) or filters(config.userfilter, p, config, proc.pidusername):
 568            continue
 569        u = proc.piduser(p)
 570        if u not in ut:
 571            ut[u] = {"pids": [], "name": "?"}
 572            ut[u]["name"] = proc.username(u)
 573        ut[u]["pids"].append(p)
 574
 575    # get totals per user
 576    for u in ut:
 577        ut[u]["totals"] = processtotals(ut[u]["pids"], proc, config)
 578    return ut
 579
 580
 581def cmdtotals(pids, proc: ProcessData, config: SmemConfig):
 582    """Aggregates memory usage by command line.
 583
 584    It groups processes by their command line and calculates the total memory
 585    usage for each command.
 586
 587    Args:
 588        pids (list[int]): A list of process IDs to analyze.
 589        proc (ProcessData): The ProcessData instance.
 590        config (SmemConfig): The smem2 configuration.
 591
 592    Returns:
 593        dict: A dictionary where keys are command lines and values are
 594              dictionaries containing process lists and memory totals.
 595    """
 596    # totals per command
 597    ct: dict = {}
 598
 599    for p in pids:
 600        if filters(
 601            config.processfilter, p, config, proc.pidcmd, proc.pidtostr, proc.pidname
 602        ) or filters(config.userfilter, p, config, proc.pidusername):
 603            continue
 604        cmdline = proc.pidcmd(p)
 605        if not cmdline:
 606            continue
 607
 608        parts = cmdline.split()
 609        if not parts:
 610            continue
 611        c = parts[0]
 612
 613        # if multiple processes per command, then a list of pids
 614        if c in ct:
 615            ct[c]["pids"].append(p)
 616        else:
 617            # first pid for this command
 618            ct[c] = {"pids": [p]}
 619
 620    # get totals per command
 621    for c in ct:
 622        ct[c]["totals"] = processtotals(ct[c]["pids"], proc, config)
 623        if "totals" in ct[c] and ct[c]["totals"]:
 624            ct[c]["name"] = c
 625            ct[c]["user"] = proc.pidusername(ct[c]["pids"][0])
 626
 627    # remove commands with empty totals
 628    for c in list(ct.keys()):
 629        if "totals" not in ct[c] or not ct[c]["totals"]:
 630            del ct[c]
 631    return ct
 632
 633
 634def sortmaps(totals, key):
 635    """Sorts a dictionary of totals by a given key.
 636
 637    Args:
 638        totals (dict): A dictionary where values are another dictionary
 639                       containing a 'totals' key.
 640        key (str): The key within the nested 'totals' dictionary to sort by.
 641
 642    Returns:
 643        list: A sorted list of the input dictionary's values.
 644    """
 645    # sort by key
 646    return sorted(totals.values(), key=lambda x: x["totals"][key], reverse=True)
 647
 648
 649def units(x):
 650    """Converts a value in bytes to a human-readable string with units (K, M, G).
 651
 652    Args:
 653        x (int or float): The value in bytes.
 654
 655    Returns:
 656        str: A human-readable string representation of the value.
 657    """
 658    if x > 1024 * 1024 * 1024:
 659        return "%.1fG" % (x / (1024.0 * 1024 * 1024))
 660    if x > 1024 * 1024:
 661        return "%.1fM" % (x / (1024.0 * 1024))
 662    if x > 1024:
 663        return "%.1fK" % (x / 1024.0)
 664    return str(x)
 665
 666
 667def fromunits(x):
 668    """Converts a human-readable string with units (K, M, G, etc.) to bytes.
 669
 670    Args:
 671        x (str): The string with a value and unit (e.g., "1024M").
 672
 673    Returns:
 674        int: The value in bytes.
 675
 676    Raises:
 677        SystemExit: If the unit is not recognized.
 678    """
 679    s = dict(
 680        k=2**10,
 681        K=2**10,
 682        kB=2**10,
 683        KB=2**10,
 684        M=2**20,
 685        MB=2**20,
 686        G=2**30,
 687        GB=2**30,
 688        T=2**40,
 689        TB=2**40,
 690    )
 691    for k, v in list(s.items()):
 692        if x.endswith(k):
 693            return int(float(x[: -len(k)]) * v)
 694    sys.stderr.write("Memory size should be written with units, for example 1024M\n")
 695    sys.exit(-1)
 696
 697
 698def processtotals(pids, proc: ProcessData, config: SmemConfig):
 699    """Sums up memory usage totals for a list of processes.
 700
 701    Args:
 702        pids (list[int]): The list of process IDs.
 703        proc (ProcessData): The ProcessData instance.
 704        config (SmemConfig): The smem2 configuration.
 705
 706    Returns:
 707        dict: A dictionary with the summed PSS, RSS, USS, etc., for the
 708              given processes.
 709    """
 710    # Sums up totals of a pid list
 711    t = {"uss": 0, "pss": 0, "rss": 0, "swap": 0, "size": 0}
 712    if config.swappss:
 713        t["swappss"] = 0
 714    for p in pids:
 715        pt = pidtotals(p, proc, config)
 716        if pt:
 717            for k in t:
 718                if k in pt:
 719                    t[k] += pt[k]
 720    return t
 721
 722
 723def get_process_data(proc: ProcessData, config: SmemConfig):
 724    """Collects and returns memory usage data for each process.
 725
 726    Args:
 727        proc (ProcessData): The ProcessData instance.
 728        config (SmemConfig): The smem2 configuration.
 729
 730    Returns:
 731        dict: A dictionary containing memory data for each process,
 732              as returned by maptotals.
 733    """
 734    # Collect process data
 735    pids = proc.pids()
 736    data = maptotals(pids, proc, config)
 737    return data
 738
 739
 740def get_map_data(proc: ProcessData, config: SmemConfig):
 741    """Collects and returns memory usage data aggregated by mapping name.
 742
 743    Args:
 744        proc (ProcessData): The ProcessData instance.
 745        config (SmemConfig): The smem2 configuration.
 746
 747    Returns:
 748        dict: A dictionary containing memory data aggregated by mapping name.
 749    """
 750    # Collect map data - aggregate by mapping name
 751    pids = proc.pids()
 752    data = mapnametotals(pids, proc, config)
 753    return data
 754
 755
 756def mapnametotals(pids, proc: ProcessData, config: SmemConfig):
 757    """Aggregates memory usage by mapping name across a list of processes.
 758
 759    It iterates through processes and their memory maps, summing up memory
 760    statistics for each unique mapping name.
 761
 762    Args:
 763        pids (list[int]): A list of process IDs.
 764        proc (ProcessData): The ProcessData instance.
 765        config (SmemConfig): The smem2 configuration.
 766
 767    Returns:
 768        dict: A dictionary where keys are mapping names and values are
 769              dictionaries of aggregated memory statistics.
 770    """
 771    totals: dict = {}
 772    for pid in pids:
 773        # Apply filters like the original version
 774        if filters(
 775            config.processfilter, pid, config, proc.pidcmd, proc.pidtostr, proc.pidname
 776        ) or filters(config.userfilter, pid, config, proc.pidusername):
 777            continue
 778        try:
 779            maps = pidmaps(pid, proc, config)
 780            seen = {}
 781            for m in list(maps.keys()):
 782                name = maps[m]["name"]
 783                if name not in totals:
 784                    t = dict(
 785                        size=0,
 786                        rss=0,
 787                        pss=0,
 788                        shared_clean=0,
 789                        shared_dirty=0,
 790                        private_clean=0,
 791                        count=0,
 792                        private_dirty=0,
 793                        referenced=0,
 794                        swap=0,
 795                        pids=0,
 796                    )
 797                    if config.swappss:
 798                        t["swappss"] = 0
 799                else:
 800                    t = totals[name]
 801                for k in t:
 802                    t[k] += maps[m].get(k, 0)
 803                t["count"] += 1
 804                if name not in seen:
 805                    t["pids"] += 1
 806                    seen[name] = 1
 807                totals[name] = t
 808        except (OSError, IOError):
 809            continue
 810    return totals
 811
 812
 813def get_user_data(proc: ProcessData, config: SmemConfig):
 814    """Collects and returns memory usage data aggregated by user.
 815
 816    Args:
 817        proc (ProcessData): The ProcessData instance.
 818        config (SmemConfig): The smem2 configuration.
 819
 820    Returns:
 821        dict: A dictionary containing memory data aggregated by user.
 822    """
 823    # Collect user data
 824    pids = proc.pids()
 825    data = usertotals(pids, proc, config)
 826    return data
 827
 828
 829def get_cmd_data(proc: ProcessData, config: SmemConfig):
 830    """Collects and returns memory usage data aggregated by command.
 831
 832    Args:
 833        proc (ProcessData): The ProcessData instance.
 834        config (SmemConfig): The smem2 configuration.
 835
 836    Returns:
 837        dict: A dictionary containing memory data aggregated by command.
 838    """
 839    # Collect cmd data
 840    pids = proc.pids()
 841    data = cmdtotals(pids, proc, config)
 842    return data
 843
 844
 845def get_system_data(proc: ProcessData, config: SmemConfig):
 846    """Collects and returns system-wide memory usage data.
 847
 848    This provides a breakdown of memory usage by different system components
 849    like kernel, firmware, userspace, etc.
 850
 851    Args:
 852        proc (ProcessData): The ProcessData instance.
 853        config (SmemConfig): The smem2 configuration.
 854
 855    Returns:
 856        list[tuple]: A list of tuples, where each tuple represents a memory
 857                     area and its usage in PSS and RSS.
 858    """
 859    t = totalmem(config)
 860    m = MemData()
 861    mt = m("memtotal")
 862    f = m("memfree")
 863    kernel = kernelsize(config)
 864
 865    # total amount mapped into userspace (ie mapped an unmapped pages) /dev/zero mappings
 866    u = m("anonpages") + m("mapped")
 867
 868    # total amount used by hardware
 869    fh = int(max(t - mt - kernel, 0))
 870
 871    # total amount allocated by kernel not for userspace
 872    kd = mt - f - u
 873
 874    # total amount in kernel caches
 875    kdc = m("buffers") + m("sreclaimable") + m("cached") - m("mapped")
 876
 877    if config.sysdetail:
 878        shmp = mapshared(proc, config)  # shared memory mapped by processes
 879        mapzero = mapdevzero(
 880            proc, config
 881        )  # dev/zero mapped as files should be subtracted from files Mapped from userspace
 882        mapped = m("mapped") - mapzero
 883        modules = kernelmodsize(proc, config)
 884        shm = m("shmem") - shmp
 885
 886        mounts = proc.readlines("mounts")
 887        ramfs = 0
 888        for r in mounts:
 889            if "ramfs" in r:
 890                try:
 891                    ramfs += int(
 892                        (os.popen("du -sk %s" % r.split()[1]).read()).split()[0]
 893                    )
 894                except Exception:
 895                    pass
 896        filecache = m("cached") - mapped - shm - ramfs
 897        unknown = (
 898            mt
 899            - f
 900            - u
 901            - (
 902                modules
 903                + m("pagetables")
 904                + m("kernelstack")
 905                + m("slab")
 906                + m("buffers")
 907                + filecache
 908                + shm
 909                + ramfs
 910            )
 911        )
 912        if unknown < 0:
 913            unknown = 0
 914
 915    lines: list[tuple]
 916    if config.sysdetail:
 917        lines = [
 918            ("firmware/hardware", fh, 0, 0),
 919            ("kernel image", kernel, 0, 0),
 920            ("kernel modules", modules, 0, 0),
 921            ("page tables", m("pagetables"), 0, 0),
 922            ("kernel stack", m("kernelstack"), 0, 0),
 923            ("slab (all/SReclaimable)", m("slab"), m("sreclaimable"), 0),
 924            ("buffers", m("buffers"), m("buffers"), 0),
 925            ("cached (w/o mapped,tmpfs,ramfs)", filecache, filecache, 0),
 926            ("shared (non process tmpfs)", shm, 0, 0),
 927            ("ramfs", ramfs, 0, 0),
 928            ("unknown", unknown, 0, 0),
 929            ("processes (all/mapped files)", u, mapped, 0),
 930            ("free memory", f, f, 0),
 931        ]
 932        if "all" in config.columns or "details" in config.columns:
 933            line_all: list[tuple] = [
 934                ("-------------------------------", 0, 0, 0),
 935                ("/dev/zero mapped", 0, 0, mapzero),
 936                ("shared by processes", 0, 0, shmp),
 937                ("unevictable", 0, 0, m("unevictable")),
 938                ("dirty (unwritten to file)", 0, 0, m("dirty")),
 939                ("swapped", 0, 0, m("swaptotal") - m("swapfree")),
 940                ("available (estimated)", 0, 0, m("memavailable")),
 941            ]
 942            lines = lines + line_all
 943    else:
 944        lines = [
 945            ("firmware/hardware", fh, 0),
 946            ("kernel image", kernel, 0),
 947            ("kernel dynamic memory", kd, kdc),
 948            ("userspace memory", u, m("mapped")),
 949            ("free memory", f, f),
 950        ]
 951    return lines
 952
 953
 954def mapdevzero(proc: ProcessData, config: SmemConfig):
 955    """Calculates memory mapped to /dev/zero.
 956
 957    Some Linux versions count memory mapped to /dev/zero as 'Mapped' instead
 958    of 'AnonPages'. This function calculates that amount.
 959
 960    Args:
 961        proc (ProcessData): The ProcessData instance.
 962        config (SmemConfig): The smem2 configuration.
 963
 964    Returns:
 965        int: Total PSS of memory mapped to /dev/zero, in kilobytes.
 966    """
 967    ps = proc.pids()
 968    config.mapfilter = "^/dev/zero$"
 969    pt = maptotals(ps, proc, config)
 970    t = 0.0
 971    for r in pt:
 972        t += pt[r]["pss"]
 973    return int(t)
 974
 975
 976def mapshared(proc: ProcessData, config: SmemConfig):
 977    """Calculates memory shared by multiple processes (via SYSV IPC).
 978
 979    Args:
 980        proc (ProcessData): The ProcessData instance.
 981        config (SmemConfig): The smem2 configuration.
 982
 983    Returns:
 984        int: Total PSS of memory from SYSV shared segments, in kilobytes.
 985    """
 986    ps = proc.pids()
 987    config.mapfilter = "^/SYSV*"
 988    pt = maptotals(ps, proc, config)
 989    t = 0.0
 990    for r in pt:
 991        t += pt[r]["pss"]
 992    return int(t)
 993
 994
 995def kernelsize(config: SmemConfig):
 996    """Determines the size of the kernel image from the file specified.
 997
 998    Args:
 999        config (SmemConfig): The smem2 configuration.
1000
1001    Returns:
1002        int: The kernel image size in kilobytes.
1003    """
1004    kernelsize_val = 0
1005    if config.kernel:
1006        try:
1007            d = os.popen("size %s" % config.kernel).readlines()[1].split()
1008            if int(d[1]) == 0:  # data part missing, seems like packed file
1009                # try some heuristic to find gzipped part in kernel image
1010                with open(config.kernel, "rb") as f:
1011                    packedkernel = f.read()
1012                pos = packedkernel.find(b"\x1f\x8b")
1013                if pos >= 0 and pos < 25000:
1014                    if not config.quiet:
1015                        sys.stderr.write(
1016                            "Parameter '%s' should be an original uncompressed compiled kernel file.\n"
1017                            % config.kernel
1018                        )
1019                        sys.stderr.write(
1020                            "Maybe uncompressed kernel can be extracted by the command:\n"
1021                            "  dd if=%s bs=1 skip=%d | gzip -d >%s.unpacked\n\n"
1022                            % (config.kernel, pos, config.kernel)
1023                        )
1024            else:
1025                kernelsize_val = int(int(d[3]) / 1024 + 0.5)
1026        except Exception:
1027            pass  # Fail silently if size command fails or kernel file is not found
1028    return kernelsize_val
1029
1030
1031def kernelmodsize(proc: ProcessData, config: SmemConfig):
1032    """Calculates the total size of loaded kernel modules.
1033
1034    It reads /proc/modules to get the size of each module.
1035
1036    Args:
1037        proc (ProcessData): The ProcessData instance.
1038        config (SmemConfig): The smem2 configuration.
1039
1040    Returns:
1041        int: The total size of kernel modules in kilobytes.
1042    """
1043    ms = 0.0
1044    try:
1045        md = proc.readlines("modules")
1046        for m in md:
1047            ms += int(m.split()[1])
1048        ms /= 1024
1049    except Exception:
1050        if not config.quiet:
1051            sys.stderr.write("Detection of kernel modules size failed\n")
1052    return int(ms)
1053
1054
1055def setdatasources(config: SmemConfig, proc: ProcessData):
1056    """Detects kernel features and updates the configuration accordingly.
1057
1058    It checks for support of PSS, SwapPSS, and detailed PSS/RSS reporting
1059    by inspecting the smaps of the current process. It also determines if
1060    the faster smaps_rollup can be used.
1061
1062    Args:
1063        config (SmemConfig): The smem2 configuration object to update.
1064        proc (ProcessData): The ProcessData instance.
1065
1066    Returns:
1067        SmemConfig: The updated configuration object.
1068    """
1069    """New kernel features detection"""
1070    config.ownpid = os.getpid()
1071
1072    config.rssdetail = False
1073    config.pssdetail = True
1074    config.rollup = True
1075    rd = proc.readlines("%s/status" % config.ownpid)
1076    for r in rd:
1077        if "RssAnon:" in r:
1078            config.rssdetail = True
1079            break
1080
1081    map_data = pidmaps(config.ownpid, proc, config, nomaps=True)
1082    map_data = map_data[list(map_data.keys())[0]]
1083
1084    if "pss" not in map_data and not config.quiet:
1085        sys.stderr.write("Warning: Kernel does not appear to support PSS measurement\n")
1086
1087    if "swappss" in map_data:
1088        config.swappss = True
1089    else:
1090        config.swappss = False
1091        if not config.quiet:
1092            sys.stderr.write(
1093                "Warning: Kernel does not appear to support SwapPSS measurement\n"
1094            )
1095
1096    if "pss_anon" in map_data:
1097        config.pssdetail = True
1098    else:
1099        config.pssdetail = False
1100        if not config.quiet:
1101            sys.stderr.write(
1102                "Warning: Kernel does not appear to support Pss Anon/File/Shmem measurement\n"
1103            )
1104
1105    """ some smem2 features need full smaps"""
1106    if (
1107        config.mapfilter
1108        or config.mappings
1109        or "maps" in config.columns
1110        or ("all" in config.columns and not config.groupcmd)
1111    ):
1112        config.rollup = False
1113    return config
1114
1115
1116def filters(opt, arg, config: SmemConfig, *sources):
1117    """A generic filter function based on regular expressions.
1118
1119    It checks if a given argument should be filtered out by matching a regex
1120    against one or more source strings.
1121
1122    Args:
1123        opt (str or None): The regex pattern to search for. If None or empty,
1124            the function returns False.
1125        arg: The argument to pass to the source functions (e.g., a PID).
1126        config (SmemConfig): The smem2 configuration (for ignorecase flag).
1127        *sources (callable): Variable length list of functions that take `arg`
1128            and return a string to be searched.
1129
1130    Returns:
1131        bool: True if the item should be filtered out (no match found),
1132              False otherwise (a match was found or no filter is active).
1133    """
1134    if not opt:
1135        return False
1136    for f in sources:
1137        if re.search(opt, f(arg), re.I if config.ignorecase else 0):
1138            return False
1139    return True