submodule Cisco-IOS-XR-sysmgr-oper-sub1 {

    yang-version 1;

    belongs-to Cisco-IOS-XR-sysmgr-oper {
        prefix Cisco-IOS-XR-sysmgr-oper;
    }

    import cisco-semver {
      prefix semver;
    }

    organization "Cisco Systems, Inc.";

    contact
      "Cisco Systems, Inc.
     Customer Service
     
     Postal: 170 West Tasman Drive
     San Jose, CA 95134
     
     Tel: +1 800 553-NETS
     
     E-mail: cs-yang@cisco.com";

    description
      "This submodule contains a collection of YANG definitions
     for Cisco IOS-XR sysmgr package operational data.
     
     Copyright (c) 2013-2019 by Cisco Systems, Inc.
     All rights reserved.";

    revision "2019-04-05" {
      description
        "Establish semantic version baseline.";
    }

    revision "2019-02-18" {
      description
        "Added good description for bag fields.";
    }

    revision "2015-11-09" {
      description "IOS XR 6.0 revision.";
    }

    semver:module-version "1.0.1";

    typedef Placement-state {
      type enumeration {
        enum "place-null" {
          value 0;
          description
            "Process runs everywhere (ubiquitous)";
        }
        enum "place-placeable" {
          value 1;
          description
            "Process runs on node chosen by PlaceD";
        }
        enum "place-dlrsc-tracker" {
          value 2;
          description
            "Process runs on dSDRSC only";
        }
        enum "place-rack-centric" {
          value 3;
          description
            "Process runs on RP of each rack";
        }
        enum "place-dsc-tracker" {
          value 4;
          description
            "Process runs on DSC only";
        }
      }
      description "Process placement state";
    }

    typedef Process-state {
      type enumeration {
        enum "none" {
          value 0;
          description "NONE";
        }
        enum "run" {
          value 1;
          description "RUN";
        }
        enum "exited" {
          value 2;
          description "EXITED";
        }
        enum "hold" {
          value 3;
          description "HOLD";
        }
        enum "wait" {
          value 4;
          description "WAIT";
        }
        enum "restart" {
          value 5;
          description "RESTART";
        }
        enum "initializing" {
          value 6;
          description "INITIALIZING";
        }
        enum "killed" {
          value 7;
          description "KILLED";
        }
        enum "queued" {
          value 8;
          description "QUEUED";
        }
        enum "error" {
          value 9;
          description "ERROR";
        }
        enum "tuple-set" {
          value 10;
          description "TUPLESET";
        }
        enum "unknown" {
          value 11;
          description "UNKNOWN";
        }
      }
      description "Process state";
    }

    grouping PROC-SEARCHPATH-INFO {
      description "process searchpath";
      leaf path {
        type string;
        description "process searchpath";
      }
    }  // grouping PROC-SEARCHPATH-INFO

    grouping LOG-INFO {
      description "Process log information";
      leaf log {
        type string;
        description "Process log";
      }
    }  // grouping LOG-INFO

    grouping PROC-BOOT-INFO {
      description "Process boot information";
      leaf last-process-started {
        type string;
        description
          "process that was started last in the band";
      }

      list standby-band-statistic {
        description
          "Statistics of Standby Band";
        uses BAND-STATS-INFO;
      }  // list standby-band-statistic

      list active-band-statistic {
        description
          "Statistics of Active Band";
        uses BAND-STATS-INFO;
      }  // list active-band-statistic

      list booted-process {
        description
          "List of booted processes";
        uses BOOTED-PROCESS-INFO;
      }  // list booted-process
    }  // grouping PROC-BOOT-INFO

    grouping PRIM-BOOTED-PROCESS-INFO {
      description
        "Process in primary boot order";
      leaf prim-time-stamp {
        type string;
        description "Primary Time Stamp";
      }

      leaf go-primary {
        type string;
        description "Go primary time stamp";
      }

      leaf level {
        type string;
        description "Level";
      }

      leaf band-name {
        type string;
        description "Band Name";
      }

      leaf jid {
        type int32;
        description "Job Id";
      }

      leaf instance-id {
        type int32;
        description "Instance number";
      }

      leaf avail-time-stamp {
        type string;
        description
          "TimeStamp process became available";
      }

      leaf avail {
        type string;
        description "Time since Avail";
      }

      leaf is-avail-timeout {
        type boolean;
        description "Is EOI timeout";
      }

      leaf process-name {
        type string;
        description "Name of the process";
      }
    }  // grouping PRIM-BOOTED-PROCESS-INFO

    grouping BOOTED-PROCESS-INFO {
      description "Process in boot order";
      leaf start-time-stamp {
        type string;
        description
          "TimeStamp of spawn after failover";
      }

      leaf started {
        type string;
        description "Time since started";
      }

      leaf level {
        type string;
        description "Level";
      }

      leaf jid {
        type int32;
        description "Job Id";
      }

      leaf instance-id {
        type int32;
        description "Instance number";
      }

      leaf ready-time-stamp {
        type string;
        description
          "TimeStamp the process became ready";
      }

      leaf ready {
        type string;
        description "Time since Ready";
      }

      leaf is-eoi-timeout {
        type boolean;
        description "Is EOI timeout";
      }

      leaf process-name {
        type string;
        description "Name of the process";
      }
    }  // grouping BOOTED-PROCESS-INFO

    grouping ACTIVE-BOOTED-PROCESS-INFO {
      description
        "Process in primary boot order";
      leaf active-time-stamp {
        type string;
        description
          "Timestamp it became Active after switchover";
      }

      leaf go-active {
        type string;
        description "Go Active time stamp";
      }

      leaf level {
        type string;
        description "Level";
      }

      leaf band-name {
        type string;
        description "Band Name";
      }

      leaf job-id {
        type int32;
        description "Job Id";
      }

      leaf instance-id {
        type int32;
        description "Instance number";
      }

      leaf avail-time-stamp {
        type string;
        description
          "Time taken to become available";
      }

      leaf avail {
        type string;
        description "Time since Avail";
      }

      leaf is-avail-timeout {
        type boolean;
        description "Timeout occured?";
      }

      leaf process-name {
        type string;
        description "Name of the process";
      }
    }  // grouping ACTIVE-BOOTED-PROCESS-INFO

    grouping BAND-STATS-INFO {
      description "Process band statistics";
      leaf level {
        type string;
        description "Level";
      }

      leaf band-name {
        type string;
        description "Band Name";
      }

      leaf band-finish-time {
        type string;
        description
          "Finish timestamp of the band";
      }

      leaf band-time {
        type string;
        description "Time spent on the band";
      }

      leaf finish-time {
        type string;
        description
          "Time taken to finish the band";
      }

      leaf idle-percentage {
        type string;
        units "percentage";
        description
          "Percentage of time it was idle";
      }

      leaf jid {
        type uint32;
        description "Jid";
      }

      leaf ready-time {
        type string;
        description "Ready Time";
      }

      leaf last-process {
        type string;
        description "Last Process Name";
      }
    }  // grouping BAND-STATS-INFO

    grouping PROC-FAILOVER-INFO {
      description "Process boot information";
      leaf failover-log {
        type string;
        description "Failover log message";
      }

      leaf critical-failover-elapsed-time {
        type string;
        description "Failover Time";
      }

      leaf last-process-started {
        type string;
        description
          "Last process started in the band";
      }

      leaf primary-failover-elapsed-time {
        type string;
        description "Primary failover time";
      }

      leaf last-primary-proc-started {
        type string;
        description
          "Last primary process started in the band";
      }

      list standby-band-statistic {
        description
          "Statistics of Standby Band";
        uses BAND-STATS-INFO;
      }  // list standby-band-statistic

      list active-band-statistic {
        description
          "Statistics of Active Band";
        uses BAND-STATS-INFO;
      }  // list active-band-statistic

      list active-ts-boot-proc {
        description
          "List of booted process as per avail time";
        uses ACTIVE-BOOTED-PROCESS-INFO;
      }  // list active-ts-boot-proc

      list start-ts-boot-proc {
        description
          "List of booted processes per start time";
        uses BOOTED-PROCESS-INFO;
      }  // list start-ts-boot-proc

      list primary-band-statistic {
        description
          "Statistics of Primary Band";
        uses BAND-STATS-INFO;
      }  // list primary-band-statistic

      list primary-ts-boot-proc {
        description
          "List of booted processes per primary time";
        uses PRIM-BOOTED-PROCESS-INFO;
      }  // list primary-ts-boot-proc

      list primary-start-ts-boot-proc {
        description
          "List of booted process per primary start time";
        uses BOOTED-PROCESS-INFO;
      }  // list primary-start-ts-boot-proc
    }  // grouping PROC-FAILOVER-INFO

    grouping ABORT-INFO {
      description "Abort information";
      leaf name {
        type string;
        description "Process name";
      }

      leaf timebuf {
        type string;
        description
          "Date and time of process abort";
      }

      leaf job-id {
        type uint32;
        description "Job ID";
      }

      leaf is-respawned {
        type string;
        description "Respawn information";
      }
    }  // grouping ABORT-INFO

    grouping PROC-ABORT-INFO {
      description
        "Process Abort information";
      leaf process-abort-count {
        type uint32;
        description
          "Number of Aborted Processes";
      }

      list process {
        description
          "Array of aborted processes";
        uses ABORT-INFO;
      }  // list process
    }  // grouping PROC-ABORT-INFO

    grouping BOOT-HOLD-INFO {
      description "Boot hold information";
      leaf boot-held-by-name {
        type string;
        description "Processs name";
      }

      leaf instance-id {
        type uint32;
        description "Instance number";
      }

      leaf jid {
        type uint32;
        description "Job ID";
      }
    }  // grouping BOOT-HOLD-INFO

    grouping PROC-BOOT-STALLED-INFO {
      description
        "Process Boot Stalled information";
      leaf spawn-status {
        type string;
        description
          "Spawn status of the processes";
      }

      list boot-hold {
        description
          "Boot hold information of the processes";
        uses BOOT-HOLD-INFO;
      }  // list boot-hold
    }  // grouping PROC-BOOT-STALLED-INFO

    grouping PROCESS-INFO {
      description "Process information";
      leaf name {
        type string;
        description "Process name";
      }

      leaf instance-id {
        type uint32;
        description "Instance number";
      }

      leaf args {
        type string;
        description "Arguments";
      }

      leaf jid {
        type uint32;
        description "Job ID";
      }

      leaf state {
        type Process-state;
        description "Process state";
      }

      leaf last-started {
        type string;
        description
          "Date and time of process last started";
      }

      leaf respawn-count {
        type uint8;
        description
          "No of times the process restarted";
      }

      leaf placement-state {
        type Placement-state;
        description "Type of Placement";
      }

      leaf is-mandatory {
        type boolean;
        description "Is process mandatory?";
      }

      leaf is-maintenance {
        type boolean;
        description "Is maintenance mode?";
      }
    }  // grouping PROCESS-INFO

    grouping PROCESSES-INFO {
      description "Processes information";
      leaf process-count {
        type uint32;
        description "Number of processes";
      }

      list process {
        description "Array of processes";
        uses PROCESS-INFO;
      }  // list process
    }  // grouping PROCESSES-INFO

    grouping PROC-VERBOSE-INFO {
      description
        "Process Verbose Information";
      leaf process-group {
        type string;
        description "Group Name";
      }

      leaf respawn-allowed {
        type int32;
        description "Can be restarted?";
      }

      leaf wait-for-exit {
        type int32;
        description
          "Wait until process exits";
      }

      leaf dynamic-tag {
        type int32;
        description
          "Interested in being verifer of the tuple";
      }

      leaf forced-stop {
        type int32;
        description
          "Signal that caused Forced stop";
      }

      leaf critical-process {
        type int32;
        description
          "If the process is critical";
      }

      leaf hold {
        type int32;
        description "Hold";
      }

      leaf transient {
        type int32;
        description "Transient process";
      }

      leaf tuple-cfgmgr {
        type int32;
        description
          "process started on tuple creation";
      }

      leaf standby-capable {
        type int32;
        description
          "capable of running on active and standby";
      }

      leaf edm-startup {
        type int32;
        description "EDM startup";
      }

      leaf placement {
        type int32;
        description "Placeable process";
      }

      leaf skip-kill-notif {
        type int32;
        description "Skip Kill Notif";
      }

      leaf init-proc {
        type int32;
        description "Init process";
      }

      leaf sysdb-event {
        type int32;
        description
          "Sysdb notification state";
      }

      leaf level-started {
        type int32;
        description
          "Process spawned on band";
      }

      leaf proc-avail {
        type int32;
        description "Process available";
      }

      leaf tuples-scanned {
        type int32;
        description "pcb has been Scanned";
      }

      leaf no-chkpt-start {
        type int32;
        description "No checkpoint start";
      }

      leaf in-shut-down {
        type int32;
        description "In Shut Down";
      }

      leaf sm-started {
        type int32;
        description "SM started";
      }

      leaf ignore-on-sc {
        type int32;
        description "Ignore on SC";
      }

      leaf ignore-on-easy-bake {
        type int32;
        description
          "Not run during EasyBake";
      }

      leaf pre-init {
        type int32;
        description
          "process started by boot script";
      }

      leaf eoi-received {
        type int32;
        description "EOI received";
      }

      leaf eoi-timeout {
        type int32;
        description "EOI Timeout";
      }

      leaf avail-timeout {
        type int32;
        description
          "Avail Timeout occured for this process";
      }

      leaf reserved-memory {
        type int32;
        description "Use Special Memory";
      }

      leaf allow-warned {
        type int32;
        description
          "Process started before its level";
      }

      leaf arg-change {
        type int32;
        description "Arg Change";
      }

      leaf restart-on-tuple {
        type int32;
        description
          "check the tuple on restart";
      }

      leaf boot-hold {
        type int32;
        description "Boot Hold";
      }

      leaf reg-id {
        type int32;
        description "Reg Id";
      }

      leaf memory-limit {
        type int32;
        description
          "Max memory a process can use";
      }

      leaf parent-job-id {
        type int32;
        description "Parent Job ID";
      }

      leaf tuple-index {
        type int32;
        description "Index of the tuple";
      }

      leaf dump-count {
        type int32;
        description "Dump Count";
      }

      leaf respawn-interval-user {
        type int32;
        description
          "User defined Respawn Interval";
      }

      leaf silent-restart-count {
        type int32;
        description "No of Silent Restarts";
      }

      leaf critical-tier {
        type int32;
        description "Failover Tier";
      }

      leaf exit-type {
        type int32;
        description "Exit Type";
      }

      leaf init-timeout {
        type int32;
        description "Timeout for EOI";
      }

      leaf restart-by-cmd {
        type int32;
        description "Restart by Command";
      }

      leaf boot-pref {
        type int32;
        description "Boot Pref";
      }

      leaf mdr-mbi-proc {
        type int32;
        description "Mdr Mbi";
      }

      leaf mdr-non-mbi-kld {
        type int32;
        description "Mdr Non Mbi Kld";
      }

      leaf mdr-mbi-kld {
        type int32;
        description "Mdr Mbi Kld";
      }

      leaf mdr-shut-delay {
        type int32;
        description "Mdr Shut Delay";
      }

      leaf mdr-keep-thru {
        type int32;
        description "Mdr Keep Thru";
      }

      leaf mdr-spoofer {
        type int32;
        description "spoofer process";
      }

      leaf mdr-spoofed {
        type int32;
        description "spoofed process";
      }

      leaf mdr-spoofed-last {
        type int32;
        description
          "Last process Mdr spoofed";
      }

      leaf mdr-spoofed-ready {
        type int32;
        description "Received Spoofed Ready";
      }

      leaf mdr-pcb-check {
        type int32;
        description "Mdr PCB Check";
      }

      leaf mdr-kill-tier {
        type int32;
        description "Mdr Kill Tier";
      }

      leaf mdr-kld {
        type int32;
        description "Mdr killed process";
      }

      leaf mdr-level {
        type int32;
        description "Mdr Level";
      }

      leaf fm-restart-cnt {
        type int32;
        description "FM restart count";
      }

      leaf self-managed {
        type int32;
        description "Self Managed process";
      }

      list tuple {
        description "Tuple";
        uses TUPLE-INFO;
      }  // list tuple

      list orig-tuple {
        description "Orig Tuple";
        uses TUPLE-INFO;
      }  // list orig-tuple
    }  // grouping PROC-VERBOSE-INFO

    grouping PROC-BASIC-DETAIL-VERBOSE-INFO {
      description
        "Process basic and detail and verbose information";
      container basic-info {
        description "Process Basic Info";
        uses PROC-BASIC-INFO;
      }  // container basic-info

      container detail-info {
        description "Process Detail Info";
        uses PROC-DETAIL-INFO;
      }  // container detail-info

      container verbose-info {
        description "Process Verbose Info";
        uses PROC-VERBOSE-INFO;
      }  // container verbose-info
    }  // grouping PROC-BASIC-DETAIL-VERBOSE-INFO

    grouping PROC-DETAIL-INFO {
      description
        "Process detail information";
      leaf running-path {
        type string;
        description "Executable path";
      }

      leaf package-path {
        type string;
        description "Install package path";
      }

      leaf job-id-link {
        type int32;
        description "Job Id Link";
      }

      leaf group-jid {
        type string;
        description "Group Jid";
      }

      leaf fail-count {
        type uint32;
        description
          "No of times spawn failed";
      }

      leaf restart-needed {
        type boolean;
        description
          "whether the process has to be restarted";
      }

      leaf init-process {
        type boolean;
        description
          "process that uses .init file";
      }

      leaf last-online {
        type string;
        description
          "Timestamp of last online";
      }

      leaf this-pcb {
        type string;
        description "This PCB";
      }

      leaf next-pcb {
        type string;
        description "Next PCB";
      }

      leaf envs {
        type string;
        description "Env variables";
      }

      leaf wait-for {
        type string;
        description "Wait For /dev/xxx";
      }

      leaf job-id-on-rp {
        type int32;
        description "Job ID on RP";
      }

      leaf is-standby-capable {
        type boolean;
        description
          "capable of running on active and standby";
      }

      leaf disable-kill {
        type boolean;
        description
          "Disallow process kill cli";
      }

      leaf send-avail {
        type boolean;
        description "Check avail";
      }

      leaf node-event-cli-info {
        type int32;
        description "Node Event CLI info";
      }

      leaf node-redundancy-state {
        type string;
        description "Redundancy role";
      }

      leaf role-event-cli-info {
        type int32;
        description
          "client interested in proc role change event";
      }

      leaf proc-role-state {
        type string;
        description "Proc Role State";
      }

      leaf standby-event-cli-info {
        type int32;
        description "Standby Event CLI info";
      }

      leaf cleanup-event-cli-info {
        type int32;
        description
          "Client registered for cleanup notification";
      }

      leaf band-ready-event-cli-info {
        type int32;
        description
          "Band Ready Event CLI Info";
      }

      leaf lr-event-cli-info {
        type int32;
        description "LR Event CLI Info";
      }

      leaf plane-ready-event-cli-info {
        type int32;
        description
          "Plane Ready Event CLI info";
      }

      leaf mdr-is-done-cli-info {
        type int32;
        description "MDR is done CLI Info";
      }
    }  // grouping PROC-DETAIL-INFO

    grouping PROC-BASIC-DETAIL-INFO {
      description
        "Process basic and detail information";
      container basic-info {
        description "Process Basic Info";
        uses PROC-BASIC-INFO;
      }  // container basic-info

      container detail-info {
        description "Process Detail Info";
        uses PROC-DETAIL-INFO;
      }  // container detail-info
    }  // grouping PROC-BASIC-DETAIL-INFO

    grouping PROC-CPU-TIME {
      description "Process CPU time";
      leaf user {
        type string;
        description "User time";
      }

      leaf system {
        type string;
        description "Kernel time";
      }

      leaf total {
        type string;
        description "Total time";
      }
    }  // grouping PROC-CPU-TIME

    grouping TUPLE-INFO {
      description
        "process tuple information";
      leaf tuple {
        type string;
        description "Tuple";
      }
    }  // grouping TUPLE-INFO

    grouping PROC-BASIC-INFO {
      description "proc basic information";
      container proc-cpu-time {
        description
          "Amt of time spent in user and kernel mode";
        uses PROC-CPU-TIME;
      }  // container proc-cpu-time

      leaf job-id-xr {
        type uint32;
        description "Job ID";
      }

      leaf process-id {
        type uint32;
        description "PID";
      }

      leaf process-name {
        type string;
        description "Name of the process";
      }

      leaf executable {
        type string;
        description
          "Executable name or path";
      }

      leaf active-path {
        type string;
        description "Active install Path";
      }

      leaf instance-id {
        type int32;
        description "Instance ID";
      }

      leaf args {
        type string;
        description "Args";
      }

      leaf version-id {
        type string;
        description "Version ID";
      }

      leaf respawn {
        type string;
        description "Respawn on/off";
      }

      leaf respawn-count {
        type int32;
        description
          "No of times the process got respawned";
      }

      leaf last-started {
        type string;
        description "Last Started timestamp";
      }

      leaf process-state {
        type string;
        description "State of the process";
      }

      leaf last-exit-status {
        type int32;
        description
          "status of the process if exited";
      }

      leaf last-exit-reason {
        type string;
        description "Last Exit due to";
      }

      leaf package-state {
        type string;
        description "State of the Package";
      }

      leaf started-on-config {
        type string;
        description
          "Started on Config of the tuple";
      }

      leaf feature-name {
        type string;
        description "Name of the feature";
      }

      leaf tag {
        type string;
        description "Tag";
      }

      leaf group {
        type string;
        description "Process Group";
      }

      leaf core {
        type string;
        description "Core";
      }

      leaf max-core {
        type int32;
        description
          "Maximum no of coredumps";
      }

      leaf level {
        type string;
        description "Level";
      }

      leaf mandatory {
        type boolean;
        description
          "This process is critical for the router to run";
      }

      leaf maint-mode-proc {
        type boolean;
        description "Is admin mode process?";
      }

      leaf placement-state {
        type string;
        description "Type of Placement";
      }

      leaf start-up-path {
        type string;
        description "Startup Path";
      }

      leaf memory-limit {
        type uint32;
        description
          "Max memory a process can use";
      }

      leaf ready {
        type string;
        description
          "Time take for Ready state";
      }

      leaf available {
        type string;
        description
          "Time Available since last respawn";
      }

      list registered-item {
        description "Tuples Registered";
        uses TUPLE-INFO;
      }  // list registered-item
    }  // grouping PROC-BASIC-INFO
  }  // submodule Cisco-IOS-XR-sysmgr-oper-sub1