Operating Systems

AI SEARCH

FLOW ALGEBRA — OPERATING SYSTEMS
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/operating-systems.html

FLOW OPERATING_SYSTEMS {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Operating Systems"
    ONTOLOGY = "Operating Systems"
    PURPOSE = "Formalise operating-system concepts, resources, processes, memory, files, devices, security, scheduling, concurrency and system-state relationships."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    OPERATING_SYSTEM
    KERNEL
    USER_SPACE
    KERNEL_SPACE
    PROCESS
    THREAD
    TASK
    PROGRAM
    EXECUTABLE
    SYSTEM_CALL
    INTERRUPT
    EXCEPTION
    SCHEDULER
    SCHEDULING_POLICY
    PROCESS_STATE
    THREAD_STATE
    READY_STATE
    RUNNING_STATE
    BLOCKED_STATE
    TERMINATED_STATE
    CONTEXT
    CONTEXT_SWITCH
    CPU
    CORE
    RESOURCE
    MEMORY
    PHYSICAL_MEMORY
    VIRTUAL_MEMORY
    ADDRESS_SPACE
    PAGE
    FRAME
    PAGE_TABLE
    TLB
    HEAP
    STACK
    FILE
    DIRECTORY
    FILESYSTEM
    FILE_DESCRIPTOR
    STORAGE_DEVICE
    DEVICE
    DEVICE_DRIVER
    IO_REQUEST
    IO_OPERATION
    BUFFER
    CACHE
    PIPE
    SOCKET
    IPC_CHANNEL
    SHARED_MEMORY
    MESSAGE_QUEUE
    SIGNAL
    SYNCHRONISATION_PRIMITIVE
    LOCK
    MUTEX
    SEMAPHORE
    CONDITION_VARIABLE
    DEADLOCK
    RACE_CONDITION
    USER
    GROUP
    PROCESS_IDENTITY
    PERMISSION
    ACCESS_CONTROL
    SECURITY_POLICY
    PRIVILEGE
    SERVICE
    DAEMON
    SYSTEM_PROCESS
    BOOT_PROCESS
    CONFIGURATION
    LOG
    EVENT
    ERROR
    FAILURE
    VERSION
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  OPERATING_SYSTEM_DOMAINS {
    PROCESS_MANAGEMENT
    THREAD_MANAGEMENT
    CPU_SCHEDULING
    MEMORY_MANAGEMENT
    VIRTUAL_MEMORY
    FILESYSTEM_MANAGEMENT
    STORAGE_MANAGEMENT
    DEVICE_MANAGEMENT
    INPUT_OUTPUT_MANAGEMENT
    CONCURRENCY
    INTERPROCESS_COMMUNICATION
    SECURITY_AND_ACCESS_CONTROL
    NETWORKING
    SYSTEM_SERVICES
    BOOT_AND_INITIALISATION
    ERROR_AND_FAULT_MANAGEMENT
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    CONTAINS
    MANAGES
    SCHEDULES
    EXECUTES
    CREATES
    TERMINATES
    BLOCKS
    WAKES
    SWITCHES_TO
    ALLOCATES
    DEALLOCATES
    MAPS_TO
    READS
    WRITES
    STORES
    RETRIEVES
    OPENS
    CLOSES
    MOUNTS
    UNMOUNTS
    SENDS
    RECEIVES
    COMMUNICATES_WITH
    SYNCHRONISES_WITH
    LOCKS
    UNLOCKS
    WAITS_FOR
    SIGNALS
    CONTROLS
    DRIVES
    AUTHENTICATES
    AUTHORISES
    PERMITS
    DENIES
    HAS_PERMISSION
    HAS_PRIVILEGE
    HAS_STATE
    TRANSITIONS_TO
    HAS_RESOURCE
    HAS_ADDRESS_SPACE
    HAS_FILE_DESCRIPTOR
    HAS_DRIVER
    HAS_CONFIGURATION
    HAS_VERSION
    FAILS_WITH
    DEPENDS_ON
    PRECEDES
    FOLLOWS
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    OPERATING_SYSTEM_SPECIFICATIONS
    KERNEL_DATA
    PROCESS_TABLES
    THREAD_DATA
    SCHEDULER_TRACES
    MEMORY_MAPS
    PAGE_TABLE_DATA
    FILESYSTEM_METADATA
    FILE_DESCRIPTOR_DATA
    DEVICE_DATA
    DRIVER_DATA
    IO_TRACES
    IPC_TRACES
    SYNCHRONISATION_TRACES
    USER_AND_GROUP_DATA
    PERMISSION_DATA
    SECURITY_POLICIES
    SYSTEM_LOGS
    BOOT_LOGS
    CONFIGURATION_DATA
    VERSION_DATA
    ERROR_RECORDS
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_OS_IDENTIFIERS
    NORMALISE_PROCESS_IDENTIFIERS
    NORMALISE_THREAD_IDENTIFIERS
    NORMALISE_PROCESS_STATES
    NORMALISE_MEMORY_UNITS
    NORMALISE_ADDRESS_FORMATS
    NORMALISE_FILE_PATHS
    NORMALISE_DEVICE_IDENTIFIERS
    NORMALISE_PERMISSION_MODELS
    NORMALISE_SECURITY_IDENTITIES
    NORMALISE_EVENT_TYPES
    NORMALISE_VERSION_IDENTIFIERS
    RESOLVE_PROCESS_AND_RESOURCE_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS OS_REASONING_PIPELINE {
    SYSTEM_STATE
      -> RESOURCE_DISCOVERY
      -> PROCESS_AND_THREAD_RESOLUTION
      -> MEMORY_MAPPING
      -> FILESYSTEM_AND_DEVICE_MAPPING
      -> IPC_AND_SYNCHRONISATION_MAPPING
      -> SECURITY_CONTEXT_MAPPING
      -> EVENT_AND_ERROR_MAPPING
      -> VALIDATION
      -> OUTPUT
  }

  PROCESS PROCESS_LIFECYCLE {
    PROGRAM_OR_EXECUTABLE
      -> PROCESS_CREATION

    PROCESS_CREATION
      -> READY_STATE

    READY_STATE
      -> SCHEDULING

    SCHEDULING
      -> RUNNING_STATE

    RUNNING_STATE
      -> BLOCK_OR_PREEMPT_OR_EXIT

    BLOCK
      -> BLOCKED_STATE

    EVENT_COMPLETION
      -> READY_STATE

    EXIT
      -> TERMINATED_STATE
  }

  PROCESS CPU_SCHEDULING {
    RUNNABLE_TASKS
      -> SCHEDULING_POLICY

    SCHEDULING_POLICY
      -> TASK_SELECTION

    TASK_SELECTION
      -> CPU_OR_CORE_ASSIGNMENT

    CPU_OR_CORE_ASSIGNMENT
      -> EXECUTION

    PREEMPTION_OR_BLOCK
      -> CONTEXT_SWITCH
  }

  PROCESS VIRTUAL_MEMORY_REASONING {
    VIRTUAL_ADDRESS
      -> PAGE_TABLE_LOOKUP

    PAGE_TABLE_LOOKUP
      -> PHYSICAL_FRAME
      OR -> PAGE_FAULT

    PAGE_FAULT
      -> PAGE_RESOLUTION

    PAGE_RESOLUTION
      -> MEMORY_MAPPING_UPDATE
      -> RESUME_ACCESS
  }

  PROCESS FILESYSTEM_REASONING {
    FILE_PATH
      -> DIRECTORY_RESOLUTION

    DIRECTORY_RESOLUTION
      -> FILESYSTEM_OBJECT

    FILESYSTEM_OBJECT
      -> PERMISSION_CHECK

    PERMISSION_CHECK
      -> FILE_OPERATION

    FILE_OPERATION
      -> STORAGE_IO_IF_REQUIRED
  }

  PROCESS DEVICE_IO_REASONING {
    PROCESS
      -> IO_REQUEST

    IO_REQUEST
      -> SYSTEM_CALL

    SYSTEM_CALL
      -> KERNEL_IO_LAYER

    KERNEL_IO_LAYER
      -> DEVICE_DRIVER

    DEVICE_DRIVER
      -> DEVICE

    DEVICE_COMPLETION
      -> INTERRUPT_OR_EVENT
      -> PROCESS_WAKEUP
  }

  PROCESS IPC_REASONING {
    PROCESS_A + PROCESS_B
      -> IPC_MECHANISM_SELECTION

    IPC_MECHANISM_SELECTION
      -> PIPE_OR_SOCKET_OR_SHARED_MEMORY_OR_MESSAGE_QUEUE

    IPC_OPERATION
      -> DATA_TRANSFER

    DATA_TRANSFER
      -> RECEIVER_STATE_UPDATE
  }

  PROCESS SYNCHRONISATION_REASONING {
    CONCURRENT_TASKS + SHARED_RESOURCE
      -> SYNCHRONISATION_REQUIREMENT

    SYNCHRONISATION_REQUIREMENT
      -> LOCK_OR_SEMAPHORE_OR_ATOMIC_OR_CONDITION

    SYNCHRONISATION_EVENT
      -> ORDERING_CONSTRAINT

    ORDERING_CONSTRAINT
      -> SAFE_ACCESS_OR_WAIT
  }

  PROCESS SECURITY_REASONING {
    SUBJECT + RESOURCE + REQUESTED_ACTION
      -> IDENTITY_CONTEXT

    IDENTITY_CONTEXT
      -> ACCESS_CONTROL_POLICY

    ACCESS_CONTROL_POLICY
      -> PERMISSION_AND_PRIVILEGE_CHECK

    PERMISSION_AND_PRIVILEGE_CHECK
      -> ALLOW_OR_DENY
  }

  PROCESS DEADLOCK_REASONING {
    TASKS + RESOURCE_WAITS
      -> WAIT_FOR_GRAPH

    WAIT_FOR_GRAPH
      -> CYCLE_DETECTION

    CYCLE
      -> DEADLOCK_CANDIDATE

    DEADLOCK_CANDIDATE
      -> STATE_AND_RESOURCE_VALIDATION
  }

  RULES {
    IF PROCESS_EXECUTES
    THEN REQUIRE {
      PROCESS_IDENTITY
      ADDRESS_SPACE
      EXECUTION_CONTEXT
      RESOURCE_CONTEXT
    }

    IF THREAD_IS_RUNNING
    THEN LINK THREAD TO CPU_OR_CORE_AND_TIME_CONTEXT

    IF VIRTUAL_ADDRESS_IS_USED
    THEN DO_NOT_ASSERT_PHYSICAL_ADDRESS_WITHOUT_MAPPING

    IF FILE_ACCESS_IS_REQUESTED
    THEN REQUIRE IDENTITY_PERMISSION_AND_FILESYSTEM_CONTEXT

    IF TASKS_ACCESS_SHARED_MUTABLE_STATE
    THEN CHECK_SYNCHRONISATION_AND_ORDERING

    IF WAIT_FOR_GRAPH_HAS_CYCLE
    THEN DO_NOT_ASSERT_DEADLOCK_WITHOUT_RESOURCE_AND_STATE_VALIDATION

    IF SYSTEM_CALL_IS_INVOKED
    THEN DISTINGUISH_USER_SPACE_REQUEST_FROM_KERNEL_EXECUTION

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND OPERATING_SYSTEM_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        OS_VERSION_CERTAINTY,
        PROCESS_STATE_OBSERVABILITY,
        SCHEDULER_TRACE_COMPLETENESS,
        MEMORY_MAP_COMPLETENESS,
        FILESYSTEM_METADATA_QUALITY,
        SECURITY_CONTEXT_COMPLETENESS,
        SYSTEM_LOG_QUALITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF PROCESS_OR_MEMORY_STATE_IS_PARTIAL
    THEN REDUCE_RUNTIME_INFERENCE_CONFIDENCE

    IF SECURITY_CONTEXT_IS_INCOMPLETE
    THEN REDUCE_ACCESS_CONTROL_INFERENCE_CONFIDENCE

    IF REPRODUCIBLE_SYSTEM_TRACE_CONFIRMS_BEHAVIOUR
    THEN INCREASE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        CANONICAL_IDENTIFIER,
        OS_FAMILY,
        OS_VERSION,
        KERNEL_VERSION,
        CONFIGURATION
      )

    IF EQUIVALENCE_KEY(A) == EQUIVALENCE_KEY(B)
    THEN A SEMANTICALLY_EQUIVALENT_TO B

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    PROGRAM != PROCESS
    PROCESS != THREAD
    USER_SPACE != KERNEL_SPACE
    VIRTUAL_ADDRESS != PHYSICAL_ADDRESS
    FILE != FILE_DESCRIPTOR
    FILE_PATH != FILESYSTEM_OBJECT
    DEVICE != DEVICE_DRIVER
    SYSTEM_CALL != DIRECT_HARDWARE_OPERATION
    CONCURRENCY != PARALLELISM
    RESOURCE_CONTENTION != DEADLOCK
    AUTHENTICATION != AUTHORISATION
    PERMISSION != PRIVILEGE
    CACHE_STATE != PERSISTENT_STORAGE_STATE
    OS_VERSION_AND_CONFIGURATION_AFFECT_BEHAVIOUR
    RUNTIME_STATE_MAY_CHANGE_RAPIDLY
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_OPERATING_SYSTEM_DOMAINS
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_OS_AND_KERNEL_VERSION
    CHECK_PROCESS_IDENTITIES
    CHECK_THREAD_IDENTITIES
    CHECK_PROCESS_STATES
    CHECK_SCHEDULING_RELATIONS
    CHECK_MEMORY_MAPPINGS
    CHECK_FILESYSTEM_RELATIONS
    CHECK_DEVICE_AND_DRIVER_RELATIONS
    CHECK_IO_RELATIONS
    CHECK_IPC_RELATIONS
    CHECK_SYNCHRONISATION
    CHECK_SECURITY_CONTEXT
    CHECK_DEADLOCK_RELATIONS
    CHECK_CONFIGURATION
    CHECK_LOGS_AND_EVENTS
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_OS_ENTITIES
    PROCESS_AND_THREAD_RELATIONS
    PROCESS_STATE_TRANSITIONS
    SCHEDULING_RELATIONS
    MEMORY_MAPPING_RELATIONS
    FILESYSTEM_RELATIONS
    DEVICE_AND_DRIVER_RELATIONS
    IO_RELATIONS
    IPC_RELATIONS
    SYNCHRONISATION_RELATIONS
    SECURITY_AND_ACCESS_RELATIONS
    DEADLOCK_HYPOTHESES
    SYSTEM_EVENT_RELATIONS
    ERROR_AND_FAILURE_RELATIONS
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON OS_KERNEL_OR_CONFIGURATION_CHANGE {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_PROCESS_MODEL
      UPDATE_MEMORY_MODEL
      UPDATE_FILESYSTEM_MODEL
      UPDATE_DEVICE_AND_DRIVER_MODEL
      UPDATE_SECURITY_CONTEXT
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_RUNTIME_OR_LOG_DATA {
      LINK_EVIDENCE
      UPDATE_PROCESS_AND_THREAD_STATE
      UPDATE_MEMORY_STATE
      UPDATE_IO_AND_IPC_STATE
      UPDATE_SECURITY_EVENTS
      REASSESS_DEADLOCK_AND_FAILURE_HYPOTHESES
      UPDATE_CONFIDENCE
      RECORD_PROVENANCE
    }

    ON ONTOLOGY_REVISION {
      REMAP_TERMS
      CHECK_SEMANTIC_EQUIVALENCE
      IDENTIFY_DEPRECATED_TERMS
      MIGRATE_RELATIONSHIPS
      PRESERVE_PRIOR_VERSION_REFERENCES
    }
  }

  FLOW_HASH {
    HASH_INPUT =
      CANONICALISE(
        ENTITY_TYPES,
        OPERATING_SYSTEM_DOMAINS,
        RELATIONSHIPS,
        RULES,
        CONFIDENCE,
        SEMANTIC_EQUIVALENCE,
        REASONING_CONSTRAINTS,
        UPDATE_MODEL
      )

    FLOW_HASH = SHA256(HASH_INPUT)
  }

  AI_CONSUMPTION {
    INDEX {
      ONTOLOGY
      ENTITY_TYPES
      OPERATING_SYSTEM_DOMAINS
      RELATIONSHIPS
      RULES
      OUTPUTS
    }

    RETRIEVE {
      BY_OPERATING_SYSTEM
      BY_KERNEL
      BY_PROCESS
      BY_THREAD
      BY_SCHEDULER
      BY_MEMORY
      BY_FILE
      BY_FILESYSTEM
      BY_DEVICE
      BY_DRIVER
      BY_IPC
      BY_SECURITY_CONTEXT
      BY_EVENT
      BY_ERROR
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_PROCESS_LIFECYCLE
      TRACE_THREAD_SCHEDULING
      TRACE_VIRTUAL_MEMORY
      TRACE_FILESYSTEM_ACCESS
      TRACE_DEVICE_IO
      TRACE_IPC
      ANALYSE_SYNCHRONISATION
      ANALYSE_SECURITY_ACCESS
      ANALYSE_DEADLOCKS
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_PROGRAM_PROCESS_AND_THREAD
      DISTINGUISH_USER_SPACE_FROM_KERNEL_SPACE
      PRESERVE_OS_KERNEL_AND_CONFIGURATION_CONTEXT
      PRESERVE_RUNTIME_STATE_CONTEXT
      DISTINGUISH_AUTHENTICATION_FROM_AUTHORISATION
      DISTINGUISH_CONTENTION_FROM_DEADLOCK
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_OPERATING_SYSTEM_INFERENCE
    }
  }

  TERMINAL {
    RESULT =
      VALIDATED(
        SEMANTICALLY_NORMALISED(
          EVIDENCE_LINKED(
            CONFIDENCE_AWARE(
              OPERATING_SYSTEMS_KNOWLEDGE
            )
          )
        )
      )
  }
}

END FLOW