Device Driver Ontology

AI SEARCH

FLOW ALGEBRA — DEVICE DRIVER ONTOLOGY
Semantic Library
Version: 4.0
Canonical Page:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/operating-systems/device-driver-ontology.html

FLOW DEVICE_DRIVER_ONTOLOGY {

  META {
    DOMAIN = "Computing Ontologies"
    SUBDOMAIN = "Operating Systems"
    ONTOLOGY = "Device Driver Ontology"
    PURPOSE = "Formalise device drivers, hardware interfaces, kernel integration, device discovery, initialisation, I/O requests, interrupts, configuration, errors and driver lifecycle relationships."
    LOCALE = "en-GB"
  }

  ENTITY_TYPES {
    DEVICE_DRIVER
    KERNEL_DRIVER
    USER_MODE_DRIVER
    CHARACTER_DRIVER
    BLOCK_DRIVER
    NETWORK_DRIVER
    BUS_DRIVER
    FILESYSTEM_DRIVER
    VIRTUAL_DRIVER
    DEVICE
    HARDWARE_DEVICE
    VIRTUAL_DEVICE
    DEVICE_CLASS
    DEVICE_IDENTIFIER
    VENDOR_IDENTIFIER
    PRODUCT_IDENTIFIER
    BUS
    INTERFACE
    PORT
    CONTROLLER
    HOST_CONTROLLER
    KERNEL
    OPERATING_SYSTEM
    KERNEL_MODULE
    MODULE
    DRIVER_BINARY
    DRIVER_PACKAGE
    DRIVER_VERSION
    FIRMWARE
    FIRMWARE_VERSION
    DEVICE_INSTANCE
    DEVICE_NODE
    DEVICE_HANDLE
    RESOURCE
    MEMORY_MAPPED_IO
    IO_PORT
    DMA
    DMA_BUFFER
    INTERRUPT
    INTERRUPT_REQUEST
    INTERRUPT_HANDLER
    IO_REQUEST
    READ_REQUEST
    WRITE_REQUEST
    CONTROL_REQUEST
    IOCTL
    REQUEST_QUEUE
    COMPLETION_EVENT
    DEVICE_STATE
    DRIVER_STATE
    INITIALISATION
    PROBE
    BIND
    UNBIND
    LOAD
    UNLOAD
    SUSPEND
    RESUME
    RESET
    POWER_STATE
    CONFIGURATION
    CAPABILITY
    PERMISSION
    ERROR
    TIMEOUT
    FAILURE
    LOG
    EVENT
    HARDWARE_REVISION
    OS_VERSION
    KERNEL_VERSION
    EVIDENCE
    CONFIDENCE_SCORE
    PROVENANCE_RECORD
  }

  RELATIONSHIPS {
    IS_A
    INSTANCE_OF
    PART_OF
    MANAGES
    CONTROLS
    DRIVES
    BINDS_TO
    UNBINDS_FROM
    SUPPORTS
    MATCHES
    PROBES
    INITIALISES
    CONFIGURES
    LOADS
    UNLOADS
    READS
    WRITES
    SENDS
    RECEIVES
    QUEUES
    COMPLETES
    HANDLES
    INTERRUPTS
    MAPS
    ALLOCATES
    DEALLOCATES
    TRANSFERS
    SUSPENDS
    RESUMES
    RESETS
    HAS_DEVICE_CLASS
    HAS_IDENTIFIER
    HAS_DRIVER_VERSION
    HAS_FIRMWARE_VERSION
    HAS_STATE
    TRANSITIONS_TO
    HAS_RESOURCE
    HAS_CAPABILITY
    HAS_PERMISSION
    HAS_CONFIGURATION
    HAS_HARDWARE_REVISION
    DEPENDS_ON
    PRECEDES
    FOLLOWS
    FAILS_WITH
    DERIVED_FROM
    INFERRED_FROM
    HAS_EVIDENCE
    HAS_CONFIDENCE
    HAS_PROVENANCE
    SEMANTICALLY_EQUIVALENT_TO
  }

  INPUTS {
    DRIVER_SPECIFICATIONS
    DRIVER_PACKAGES
    DRIVER_VERSION_DATA
    DEVICE_IDENTIFIERS
    DEVICE_CLASS_DATA
    BUS_AND_INTERFACE_DATA
    DEVICE_DISCOVERY_DATA
    PROBE_AND_BIND_LOGS
    KERNEL_MODULE_DATA
    IO_REQUEST_TRACES
    INTERRUPT_TRACES
    DMA_DATA
    RESOURCE_MAPPINGS
    POWER_STATE_DATA
    FIRMWARE_DATA
    CONFIGURATION_DATA
    ERROR_LOGS
    FAILURE_RECORDS
    HARDWARE_REVISION_DATA
    OS_VERSION_DATA
    KERNEL_VERSION_DATA
    ONTOLOGY_TERMS
  }

  NORMALISE {
    STANDARDISE_DRIVER_IDENTIFIERS
    NORMALISE_DRIVER_NAMES
    NORMALISE_DRIVER_VERSIONS
    NORMALISE_DEVICE_IDENTIFIERS
    NORMALISE_VENDOR_AND_PRODUCT_IDS
    NORMALISE_DEVICE_CLASSES
    NORMALISE_BUS_AND_INTERFACE_NAMES
    NORMALISE_RESOURCE_IDENTIFIERS
    NORMALISE_INTERRUPT_IDENTIFIERS
    NORMALISE_FIRMWARE_VERSIONS
    NORMALISE_POWER_STATES
    NORMALISE_HARDWARE_REVISIONS
    NORMALISE_OS_AND_KERNEL_VERSIONS
    NORMALISE_ERROR_TYPES
    RESOLVE_DRIVER_AND_DEVICE_IDENTITIES
    ALIGN_ONTOLOGY_TERMS
    REMOVE_DUPLICATES
    VALIDATE_METADATA
    PRESERVE_PROVENANCE
  }

  PROCESS DRIVER_LIFECYCLE {
    DRIVER_AVAILABLE
      -> DRIVER_LOAD

    DRIVER_LOAD
      -> KERNEL_OR_RUNTIME_REGISTRATION

    DEVICE_DISCOVERY
      -> DRIVER_MATCH

    DRIVER_MATCH
      -> PROBE

    PROBE
      -> BIND

    BIND
      -> INITIALISATION

    INITIALISATION
      -> OPERATIONAL_STATE

    DEVICE_REMOVAL_OR_DRIVER_UNLOAD
      -> UNBIND
      -> RESOURCE_RELEASE
      -> DRIVER_UNLOAD
  }

  PROCESS DEVICE_MATCHING {
    DEVICE_IDENTIFIER + DEVICE_CLASS + BUS_CONTEXT
      -> DRIVER_MATCH_RULES

    DRIVER_MATCH_RULES
      -> CANDIDATE_DRIVER_SET

    CANDIDATE_DRIVER_SET
      -> VERSION_AND_COMPATIBILITY_CHECK

    VERSION_AND_COMPATIBILITY_CHECK
      -> SELECTED_DRIVER_OR_NO_MATCH
  }

  PROCESS INITIALISATION_REASONING {
    BOUND_DRIVER + DEVICE
      -> RESOURCE_DISCOVERY

    RESOURCE_DISCOVERY
      -> MEMORY_OR_IO_MAPPING

    MEMORY_OR_IO_MAPPING
      -> INTERRUPT_SETUP

    INTERRUPT_SETUP
      -> DMA_SETUP_IF_REQUIRED

    DMA_SETUP_IF_REQUIRED
      -> DEVICE_CONFIGURATION

    DEVICE_CONFIGURATION
      -> READY_STATE
  }

  PROCESS IO_REASONING {
    APPLICATION_OR_KERNEL_CLIENT
      -> IO_REQUEST

    IO_REQUEST
      -> OS_IO_SUBSYSTEM

    OS_IO_SUBSYSTEM
      -> DRIVER_REQUEST_HANDLER

    DRIVER_REQUEST_HANDLER
      -> DEVICE_COMMAND

    DEVICE_COMMAND
      -> HARDWARE_OPERATION

    HARDWARE_COMPLETION
      -> INTERRUPT_OR_POLLING_COMPLETION

    COMPLETION
      -> DRIVER_COMPLETION_HANDLER
      -> REQUEST_RESULT
  }

  PROCESS INTERRUPT_REASONING {
    DEVICE_EVENT
      -> INTERRUPT_REQUEST

    INTERRUPT_REQUEST
      -> INTERRUPT_DISPATCH

    INTERRUPT_DISPATCH
      -> DRIVER_INTERRUPT_HANDLER

    DRIVER_INTERRUPT_HANDLER
      -> ACKNOWLEDGE_DEVICE
      -> CAPTURE_EVENT_STATE
      -> DEFERRED_PROCESSING_IF_REQUIRED

    DEFERRED_PROCESSING
      -> IO_COMPLETION_OR_STATE_UPDATE
  }

  PROCESS DMA_REASONING {
    IO_REQUEST
      -> DMA_REQUIREMENT_CHECK

    DMA_REQUIRED
      -> DMA_BUFFER_ALLOCATION_OR_MAPPING

    DMA_BUFFER
      -> DEVICE_DMA_CONFIGURATION

    DEVICE_DMA_OPERATION
      -> MEMORY_TRANSFER

    MEMORY_TRANSFER
      -> DMA_COMPLETION_EVENT
      -> BUFFER_UNMAP_OR_REUSE
  }

  PROCESS POWER_MANAGEMENT_REASONING {
    DEVICE_AND_DRIVER_STATE
      -> POWER_POLICY

    POWER_POLICY
      -> TARGET_POWER_STATE

    TARGET_POWER_STATE
      -> DRIVER_SUSPEND_OR_RESUME_ACTION

    DRIVER_ACTION
      -> DEVICE_POWER_TRANSITION
  }

  PROCESS ERROR_REASONING {
    IO_ERROR_OR_TIMEOUT_OR_DEVICE_FAULT
      -> DRIVER_ERROR_HANDLER

    DRIVER_ERROR_HANDLER
      -> RETRY_OR_RESET_OR_FAIL

    RESET
      -> DEVICE_REINITIALISATION

    UNRECOVERABLE_ERROR
      -> FAILURE_REPORT
      -> EVIDENCE_AND_PROVENANCE_RECORD
  }

  RULES {
    IF DRIVER_BINDS_TO_DEVICE
    THEN REQUIRE {
      DEVICE_IDENTITY
      DRIVER_IDENTITY
      MATCH_RULE
      OS_AND_KERNEL_CONTEXT
    }

    IF DEVICE_IS_DETECTED
    THEN DO_NOT_ASSERT_DRIVER_BINDING_WITHOUT_MATCH_AND_PROBE_CONTEXT

    IF DRIVER_IS_LOADED
    THEN DO_NOT_ASSERT_DEVICE_OPERATION_WITHOUT_SUCCESSFUL_BIND_AND_INITIALISATION

    IF IO_REQUEST_COMPLETES
    THEN LINK REQUEST_DEVICE_DRIVER_AND_COMPLETION_CONTEXT

    IF DMA_IS_USED
    THEN PRESERVE BUFFER_MAPPING_DIRECTION_AND_COMPLETION_CONTEXT

    IF INTERRUPT_IS_HANDLED
    THEN PRESERVE DEVICE_SOURCE_HANDLER_AND_EVENT_CONTEXT

    IF DRIVER_VERSION_DIFFERS
    THEN DO_NOT_ASSUME_IDENTICAL_DEVICE_BEHAVIOUR

    IF SEMANTIC_IDENTIFIERS_DIFFER
    AND DRIVER_REFERENT_IS_SAME
    THEN APPLY SEMANTIC_EQUIVALENCE
  }

  CONFIDENCE {
    CONFIDENCE_SCORE =
      WEIGHT(
        DRIVER_IDENTITY_CERTAINTY,
        DRIVER_VERSION_CERTAINTY,
        DEVICE_IDENTITY_CERTAINTY,
        MATCH_RULE_CERTAINTY,
        BIND_AND_INITIALISATION_TRACE_QUALITY,
        IO_TRACE_COMPLETENESS,
        ERROR_LOG_QUALITY,
        PROVENANCE_COMPLETENESS
      )

    LEVELS {
      HIGH
      MODERATE
      LOW
      INSUFFICIENT
    }

    IF DRIVER_OR_DEVICE_VERSION_CONTEXT_IS_UNKNOWN
    THEN REDUCE_COMPATIBILITY_CONFIDENCE

    IF PROBE_OR_BIND_TRACE_IS_INCOMPLETE
    THEN REDUCE_OPERATIONAL_STATE_CONFIDENCE

    IF REPRODUCIBLE_IO_TRACE_CONFIRMS_OPERATION
    THEN INCREASE CONFIDENCE_SCORE
  }

  SEMANTIC_EQUIVALENCE {
    EQUIVALENCE_KEY =
      NORMALISE(
        ENTITY_TYPE,
        DRIVER_IDENTIFIER,
        DRIVER_VERSION,
        DEVICE_CLASS,
        SUPPORTED_DEVICE_IDENTIFIER,
        OS_VERSION,
        KERNEL_VERSION
      )

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

    ELSE PRESERVE_DISTINCT_ENTITIES
  }

  REASONING_CONSTRAINTS {
    DEVICE_DRIVER != DEVICE
    DRIVER_LOAD != DEVICE_BIND
    DEVICE_DISCOVERY != DRIVER_MATCH
    DRIVER_MATCH != SUCCESSFUL_INITIALISATION
    DRIVER_BIND != GUARANTEED_CORRECT_OPERATION
    INTERRUPT != IO_COMPLETION_IN_ALL_CASES
    DMA != CPU_COPY
    DEVICE_RESET != SYSTEM_RESET
    DRIVER_VERSION != FIRMWARE_VERSION
    DEVICE_CLASS != SPECIFIC_DEVICE_IDENTITY
    SAME_DEVICE_ID != SAME_HARDWARE_REVISION_IN_ALL_CASES
    OS_KERNEL_DRIVER_FIRMWARE_AND_HARDWARE_CONTEXT_AFFECT_BEHAVIOUR
    ERROR_MESSAGE != ROOT_CAUSE
    PROVENANCE_MUST_BE_PRESERVED
    UNCERTAINTY_MUST_NOT_BE_DISCARDED
  }

  VALIDATION {
    CHECK_ENTITY_TYPES
    CHECK_RELATION_DOMAINS_AND_RANGES
    CHECK_DRIVER_IDENTIFIER
    CHECK_DRIVER_VERSION
    CHECK_DEVICE_IDENTIFIER
    CHECK_DEVICE_CLASS
    CHECK_MATCH_RULE
    CHECK_PROBE_AND_BIND_RELATIONS
    CHECK_RESOURCE_MAPPINGS
    CHECK_INTERRUPT_SETUP
    CHECK_DMA_RELATIONS
    CHECK_IO_RELATIONS
    CHECK_POWER_STATE_RELATIONS
    CHECK_FIRMWARE_VERSION
    CHECK_HARDWARE_REVISION
    CHECK_OS_AND_KERNEL_CONTEXT
    CHECK_ERROR_AND_FAILURE_RELATIONS
    CHECK_CONFIGURATION
    CHECK_PROVENANCE
    CHECK_CONFIDENCE
    CHECK_SEMANTIC_CONSISTENCY
  }

  OUTPUTS {
    NORMALISED_DEVICE_DRIVER_ENTITIES
    DRIVER_DEVICE_MATCH_RELATIONS
    PROBE_RELATIONS
    BIND_AND_UNBIND_RELATIONS
    INITIALISATION_RELATIONS
    RESOURCE_MAPPING_RELATIONS
    IO_REQUEST_RELATIONS
    INTERRUPT_RELATIONS
    DMA_RELATIONS
    POWER_MANAGEMENT_RELATIONS
    DRIVER_STATE_TRANSITIONS
    ERROR_AND_RECOVERY_RELATIONS
    FAILURE_HYPOTHESES
    CONFIDENCE_SCORES
    EVIDENCE_LINKS
    PROVENANCE_RECORDS
    EXPLANATION_PATHS
  }

  UPDATE_MODEL {
    ON DRIVER_DEVICE_OR_CONFIGURATION_CHANGE {
      NORMALISE
      ENTITY_RESOLUTION
      UPDATE_DRIVER_DEVICE_MATCHES
      UPDATE_BIND_STATE
      UPDATE_RESOURCE_MAPPINGS
      UPDATE_POWER_CONTEXT
      UPDATE_FIRMWARE_CONTEXT
      RECOMPUTE_AFFECTED_RELATIONS
      UPDATE_CONFIDENCE
      PRESERVE_VERSION_HISTORY
    }

    ON NEW_IO_INTERRUPT_OR_ERROR_DATA {
      LINK_EVIDENCE
      UPDATE_IO_TRACE
      UPDATE_DRIVER_AND_DEVICE_STATE
      UPDATE_INTERRUPT_AND_DMA_RELATIONS
      REASSESS_ERROR_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,
        RELATIONSHIPS,
        RULES,
        CONFIDENCE,
        SEMANTIC_EQUIVALENCE,
        REASONING_CONSTRAINTS,
        UPDATE_MODEL
      )

    FLOW_HASH = SHA256(HASH_INPUT)
  }

  AI_CONSUMPTION {
    INDEX {
      ONTOLOGY
      ENTITY_TYPES
      RELATIONSHIPS
      RULES
      OUTPUTS
    }

    RETRIEVE {
      BY_DRIVER
      BY_DRIVER_VERSION
      BY_DEVICE
      BY_DEVICE_CLASS
      BY_DEVICE_IDENTIFIER
      BY_BIND_STATE
      BY_IO_REQUEST
      BY_INTERRUPT
      BY_DMA
      BY_POWER_STATE
      BY_ERROR
      BY_FAILURE
      BY_CONFIDENCE
    }

    REASON {
      APPLY_RELATIONSHIPS
      APPLY_RULES
      TRACE_DRIVER_LIFECYCLE
      TRACE_DEVICE_MATCHING
      TRACE_INITIALISATION
      TRACE_IO_REQUESTS
      TRACE_INTERRUPTS
      TRACE_DMA
      ANALYSE_POWER_MANAGEMENT
      ANALYSE_ERRORS_AND_RECOVERY
      CHECK_SEMANTIC_EQUIVALENCE
      PRESERVE_UNCERTAINTY
      TRACE_EVIDENCE
      TRACE_PROVENANCE
      GENERATE_EXPLANATION_PATH
    }

    RESPONSE_POLICY {
      DISTINGUISH_DRIVER_FROM_DEVICE
      DISTINGUISH_LOAD_FROM_BIND_AND_INITIALISATION
      PRESERVE_DRIVER_FIRMWARE_HARDWARE_OS_AND_KERNEL_CONTEXT
      DISTINGUISH_INTERRUPT_FROM_IO_COMPLETION
      DISTINGUISH_ERROR_MESSAGE_FROM_ROOT_CAUSE
      RETURN_CONFIDENCE_WHEN_AVAILABLE
      RETURN_PROVENANCE_WHEN_AVAILABLE
      AVOID_UNSUPPORTED_DEVICE_DRIVER_INFERENCE
    }
  }

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

END FLOW