cim_process.mof

Pegasus is an open-source implementationof the DMTF CIM and WBEM standards. It is designed to be por

// Copyright (c) 2005 DMTF.  All rights reserved.
// <change cr="DMTFCR01424.002" type ="modify">Unix Process Priority
// Correction</change>

// ==================================================================
//  CIM_Process
// ==================================================================
   [Version ( "2.10.0" ), Description (
       "Each instance of the CIM_Process class represents a single "
       "instance of a running program. A user of the OperatingSystem "
       "will typically see a Process as an application or task. Within "
       "an OperatingSystem, a Process is defined by a workspace of "
       "memory resources and environmental settings that are allocated "
       "to it. On a multitasking System, this workspace prevents "
       "intrusion of resources by other Processes. Additionally, a "
       "Process can execute as multiple Threads, all which run within "
       "the same workspace.")]
class CIM_Process : CIM_EnabledLogicalElement {

      [Key, Propagated ( "CIM_OperatingSystem.CSCreationClassName" ), 
       Description (
          "The scoping ComputerSystem's CreationClassName."), 
       MaxLen ( 256 )]
   string CSCreationClassName;

      [Key, Propagated ( "CIM_OperatingSystem.CSName" ), Description (
          "The scoping ComputerSystem's Name."), 
       MaxLen ( 256 )]
   string CSName;

      [Key, Propagated ( "CIM_OperatingSystem.CreationClassName" ), 
       Description (
          "The scoping OperatingSystem's CreationClassName."), 
       MaxLen ( 256 )]
   string OSCreationClassName;

      [Key, Propagated ( "CIM_OperatingSystem.Name" ), Description (
          "The scoping OperatingSystem's Name."), 
       MaxLen ( 256 )]
   string OSName;

      [Key, Description (
          "CreationClassName indicates the name of the class or the "
          "subclass used in the creation of an instance. When used "
          "with the other key properties of this class, this property "
          "allows all instances of this class and its subclasses to be "
          "uniquely identified."), 
       MaxLen ( 256 )]
   string CreationClassName;

      [Key, Description (
          "A string used to identify the Process. A Process ID is a "
          "kind of Process Handle."), 
       MaxLen ( 256 ), 
       MappingStrings { "MIF.DMTF|Process Information|001.1" }]
   string Handle;

      [Override ( "Name" ), Description (
          "The name of the process."), 
       MappingStrings { "MIF.DMTF|Process Information|001.6" }]
   string Name;

      [Description (
          "Priority indicates the urgency or importance of execution "
          "of a Process. Lower values reflect more favorable process "
          "scheduling. If a priority is not defined for a Process, a "
          "value of 0 should be used."), 
       MappingStrings { "MIF.DMTF|Process Information|001.10" }]
   uint32 Priority;

      [Description (
          "Indicates the current operating condition of the Process. "
          "Values include ready (2), running (3), and blocked (4), "
          "among others. The majority of the enumerated values are "
          "obvious. However, a few require additional explanation: \n"
          "7 (Terminated) describes that a process has naturally "
          "completed \n"
          "8 (Stopped) describes that a process has been prematurely "
          "'stopped' by a user or other request \n"
          "10 (Ready but Relinquished Processor) describes that a "
          "process is in the Ready state, but has voluntarily "
          "relinquished execution time to other processes. For "
          "example, this state may indicate a problem when the "
          "relinquishing process is not handling items on its queues. "
          "If these semantics cannot be detected, the process should "
          "report its state as 2 (\"Ready\"). \n"
          "11 (Hung) indicates that a process is not responding and "
          "should therefore not be given further execution time."), 
       ValueMap { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
          "10", "11" }, 
       Values { "Unknown", "Other", "Ready", "Running", "Blocked",
          "Suspended Blocked", "Suspended Ready", "Terminated",
          "Stopped", "Growing", "Ready But Relinquished Processor",
          "Hung" }, 
       MappingStrings { "MIF.DMTF|Process Information|001.9",
          "MIF.UNIX|Process Information|13.9" }]
   uint16 ExecutionState;

      [Description (
          "A string describing the state - used when the instance's "
          "ExecutionState property is set to 1 (\"Other\"). Other "
          "ExecutionDescription should be set to NULL when the "
          "Execution State property is any value other than 1.")]
   string OtherExecutionDescription;

      [Description (
          "Time that the Process began executing.")]
   datetime CreationDate;

      [Description (
          "Time that the Process was stopped or terminated.")]
   datetime TerminationDate;

      [Description (
          "Time in kernel mode, in milliseconds. If this information "
          "is not available, or if the operating system does not "
          "distinguish between time in kernel and in user mode, a "
          "value of 0 should be used."), 
       Units ( "MilliSeconds" ), 
       MappingStrings { "MIF.DMTF|Process Information|001.13" }]
   uint64 KernelModeTime;

      [Description (
          "Time in user mode, in milliseconds. If this information is "
          "not available, a value of 0 should be used. If the "
          "operating system does not distinguish between time in "
          "kernel mode and user mode, the time should be returned in "
          "this property."), 
       Units ( "MilliSeconds" ), 
       MappingStrings { "MIF.DMTF|Process Information|001.14" }]
   uint64 UserModeTime;

      [Description (
          "The amount of memory in bytes that a Process needs to "
          "execute efficiently, for an OperatingSystem that uses "
          "page-based memory management. If an insufficient amount of "
          "memory is available (< working set size), thrashing will "
          "occur. If this information is not known, NULL or 0 should "
          "be entered. If this data is provided, it could be monitored "
          "to understand a Process' changing memory requirements as "
          "execution proceeds."), 
       Units ( "Bytes" ), Gauge]
   uint64 WorkingSetSize;
};