Guardian Programmer's Guide

ManualsBrandsHP ManualsServerHP NonStop G-Series

581

582

583

584

585

586

587

588

589

590

Table Of Contents

Guardian Programmer’s Guide
Contents
What’s New in This Manual
- Manual Information
- New and Changed Information
About This Manual
- Contents
- Related Reading
- Notation Conventions
Legal Notices
- HP Encourages Your Comments
1 Introduction to Guardian Programming
- Providing Fault Tolerance
- System Services
- The Requester/Server Application Model
- Accessing Guardian Procedures
- TNS/E Program Execution Modes
  - Similarities and Differences Between H-series RVUs on the TNS/E Platform and G-Series RVUs on the TNS/R Platform
- TNS/R Program Execution Modes
- Using Parameter Declarations Files
- Synchronizing Processes
2 Using the File System
- File Concepts
- File Names
- Location Independent Disk-File Names
- Passing File Names to Processes
  - Using CLASS MAP DEFINEs
  - Using the Startup Sequence
- Creating and Accessing Files
- Accessing Files: An Example
3 Coordinating Concurrent File Access
- Setting the Access Mode
- Setting the Exclusion Mode
- Locking a File
- Avoiding Deadlocks
  - Avoiding Multiple-Process Deadlocks
  - Avoiding Single-Process Deadlocks
4 Using Nowait Input/Output
- Overview of Nowait Input/Output
- Applying a Nowait Operation on a Single File
- Applying Multiple Nowait Operations on a Single File
- Applying Nowait Operations to Multiple Files
- Nowait I/O: An Example
- Using FILE_COMPLETE_ and its Companion Procedures
- Nowait-Depth
5 Communicating With Disk Files
- Types of Disk Files
- Using Unstructured Files
- Using Relative Files
- Using Entry-Sequenced Files
- Using Key-Sequenced Files
- Using Partitioned Files
  - Creating Partitioned Files
  - Accessing Partitioned Files
- Using Alternate Keys
6 Communicating With Processes
- Sending and Receiving Messages: An Introduction
- Sending Messages to Other Processes
  - Opening a Process
  - Writing Messages to Another Process
- Queuing Messages on $RECEIVE
- Receiving and Replying to Messages From Other Processes
- Receiving Messages From Other Processes: One-Way Communication
- Handling Multiple Messages Concurrently
- Checking for Canceled Messages
  - Checking for Cancellation Messages
  - Using the MESSAGESTATUS Procedure
- Receiving and Processing System Messages
- Handling Errors
- Communicating With Processes: Sample Programs
  - Programming the Requester
  - Programming the Server
7 Using DEFINEs
- Example Uses for DEFINEs
- DEFINE Names
- DEFINE Attributes
- Working With DEFINEs
  - Enabling DEFINEs
  - Referring to DEFINEs
- Adding DEFINEs
- Using DEFINEs: An Example
8 Communicating With a TACL Process
- Setting Up the Process Environment
- Obtaining Startup Information
  - Using INITIALIZER to Read the Startup Message
  - Processing the Startup Message
- Using ASSIGNs and PARAMs
- Setting a Timeout Value for INITIALIZER
- Reading the Startup Sequence Without INITIALIZER
- Waking the TACL Process
- Causing the TACL Process to Display Text
9 Communicating With Devices
- Overview of I/O Subsystem
- Addressing Devices
- Accessing Devices
- Controlling Devices
- Getting Device Information
  - Additional Device Information (G-series Only)
10 Communicating With Terminals
- Accessing a Terminal
- Communicating in Conversational Mode
- Communicating in Page Mode
- Managing the BREAK Key
- Recovering From Errors
11 Communicating With Printers
- Accessing a Printer
  - Procedures for Working With Printers
  - A Printer Program Outline
- Using the Printer Control Language
  - Controlling the Printer
  - Commonly Used PCL Escape Sequences
- Programming for Tandem Laser Printers
- Programming for Tandem Matrix Line Printers
- Recovering From Errors
  - Recovering From a “Device Not Ready” Error
  - Recovering From Path Errors
- Sample Program for Using a Printer
12 Communicating With Magnetic Tape
- Accessing Magnetic Tape: An Introduction
- Positioning the Tape
- Reading and Writing Tape Records
  - Reading Tape Records
  - Writing Tape Records
- Blocking Tape Records
- Working in Buffered Mode
- Working With Standard Labeled Tapes
- Accessing a Labeled Tape File: An Example
- Working With Unlabeled Tapes
- Terminating Tape Access
- Recovering From Errors
- Accessing an Unlabeled Tape File: An Example
13 Manipulating File Names
- Overview
  - Identifying Portions of File Names
  - Working With File-Name Patterns
- Scanning, Resolving, and Unresolving File Names
- Modifying Portions of a File Name
- Comparing File Names
- Searching For and Matching File-Name Patterns
- Manipulating File Names: An Example
14 Using the IOEdit Procedures
- When to Use and When Not to Use EDIT Files
- Overview of IOEdit
- Creating, Opening, and Initializing an IOEdit File
- Reading and Writing an IOEdit File
- Using Nowait I/O With IOEdit Files
- Compressing an IOEdit File
- Closing an IOEdit File
  - Closing a Single File
  - Closing All EDIT Files
15 Using the Sequential Input/Output Procedures
- An Introduction to the SIO Procedures
- Initializing SIO Files Using TAL or pTAL DEFINEs
- Opening and Creating SIO Files
- Getting Information About SIO Files
- Reading and Writing SIO Files
- Accessing EDIT Files
  - Opening an EDIT File
  - Setting the Read Position
- Handling Nowait I/O
  - Waiting for One File
  - Waiting for Any File
- Handling Interprocess Messages
- Handling System Messages
  - Selecting or Masking System Messages
  - Reading System Messages
- Handling BREAK Ownership
- Handling SIO Errors
- Closing SIO Files
- Initializing SIO Files Without TAL or pTAL DEFINEs
- Using the SIO Procedures: An Example
16 Creating and Managing Processes
- Process Management Overview
- Creating Processes
- Sending the Startup Sequence to a Process
  - Sending and Receiving the Startup Message
  - Sending and Receiving Assign and Param Messages
- Monitoring a Child Process
- Deleting Processes
- Suspending and Activating Processes
- Getting and Setting Process Information
  - Getting Process Information
  - Setting Process Information
- Manipulating Process Identifiers
17 Managing Memory
- An Introduction to Memory-Management Procedures
- Managing the User Data Areas
- Using (Extended) Data Segments
- Using Memory Pools
18 Managing Time
- How the System Keeps Time
- Using the Time Management Procedures
- Time and Date Manipulation
- Timing in Elapsed Time and Timing in Process Time
- Measuring Long Time Intervals
  - A Sample Long-Range Timer
- Managing System Time
19 Formatting and Manipulating Character Data
- Using the Formatter
  - Format-Directed Formatting
  - List-Directed Formatting
- Manipulating Character Strings
- Programming With Multibyte Character Sets
20 Interfacing With the ERROR Program
- Creating an ERROR Process
- Opening an ERROR Process
- Sending an ERROR Process a Startup Message
- Reading and Processing Error-Message Text
- Closing and Deleting an ERROR Process
- Using the ERROR Process: An Example
21 Writing a Requester Program
- Functions of a Requester
- File System I/O Synchronization
- Writing a Requester Program: An Example
22 Writing a Server Program
- Functions of a Server Process
- Maintaining an Opener Table
- Writing a Server Program: An Example
23 Writing a Command-Interpreter Monitor ($CMON)
- Communicating With TACL Processes
- Controlling the Configuration of a TACL Process
  - Retaining Default Values
  - Setting Configuration Parameters
- Controlling Logon and Logoff
- Controlling Passwords
  - When the User Requests to Change a Local Password
  - When the User Requests to Change a Remote Password
- Controlling Process Creation
  - Controlling the Priority of a New Process
  - Controlling the CPU of a New Process
- Controlling Change of Process Priority
- Controlling Adding and Deleting Users
  - Controlling Adding a User
  - Controlling Deleting a User
- Controlling $CMON While the System Is Running
- Writing a $CMON Program: An Example
  - Sample $CMON Program
  - Sample Command-Interface Program
- Debugging a TACL Monitor ($CMON)
  - A TACL Macro for Debugging and Testing a $CMON Program
  - Procedure for Debugging and Testing a TACL Monitor ($CMON)
24 Writing a Terminal Simulator
- Specifying Device Subtype 30
  - Why Device Subtype 30 Must Be Specified
  - How to Specify Device Subtype 30
- Assigning a Name to the Terminal-Simulation Process
- Accepting System Messages Through $RECEIVE
- Specifying How to Process System Messages
  - Allowing the Requester to Specify the last-params Parameter
  - Allowing the Requester to Call SETPARAM
- Processing I/O Requests
- Processing System Messages
- Managing the BREAK Key
25 Debugging, Trap Handling, and Signal Handling
- Invoking a Debugger
  - Getting a Process Into the Debug State
  - Specifying the Debugging Environment
- Handling Trap Conditions
- Handling Signals
26 Synchronizing Processes
- How Binary Semaphores Work
- Summary of Guardian Binary Semaphore Procedures
- Using the Binary Semaphore Procedure Calls
- Binary Semaphore Interface Declarations
- Binary Semaphore Example
- BINSEM_GETSTATS_ and BINSEM_STAT_VERSION_ Example
27 Fault-Tolerant Programming in C
- Overview of Active Backup Programming
- Summary of Active Backup Processing
- What the Programmer Must Do
  - Planning Tasks
  - Programming Tasks
- C Extensions That Support Active Backup Programming
- Organizing an Active Backup Program
  - Primary Process Organization
  - Backup Process Organization
- Updating State Information
- Providing Communication Between the Primary and Backup Processes
- Programming Considerations
  - Compile-Time and Linker Considerations
  - Run-Time Considerations
- Comparison of Active Backup and Passive Backup
- Active Backup Example 1
- Active Backup Example 2
28 Using Floating-Point Formats
- Differences Between Tandem and IEEE Floating-Point Formats
- Building and Running IEEE Floating-Point Programs
- Compiling and Linking Floating-Point Programs
- Link-Time Consistency Checking
- Run-Time Consistency Checking
- Run-Time Support
- Debugging Options
- Conversion Routines
- Floating-Point Operating Mode Routines
A Mixed Data Model Programming
- Using 64-bit Addressable Memory
Glossary
Index

Manipulating File Names

Guardian Programmer’s Guide — 421922-014

13 - 2

Identifying Portions of File Names

Many of the procedures described in this section need to identify portions of file names

or names of other entities such as nodes, volumes, and subvolumes. For example, if

you want to change a subvolume name in a permanent disk-file name, you need a way

of specifying to a procedure that the string you supply is to replace the subvolume

name.

To describe how you identify portions of entity names to the procedures described

here, the following paragraphs introduce some terminology.

Defining a File-Name “Part”

A file-name part represents a portion of a file name either between two periods,

before the first period, or after the last period. Node name, file ID, process name,

process qualifier, and device name are all examples of file-name parts.

To identify a part of a file name, many procedures take a level parameter. The level

identifies the position of the part in the file name. The level can have a value between

-1 and +2 as follows:

Some examples of file names are listed below. The examples indicate the level

number of each part of the file name:

-1 Identifies a node name.

0 Identifies that part of a file name that immediately follows the node name in a

fully qualified file name; for example, a device name, volume name, or

unqualified portion of a process name. This part often has a dollar sign ($) as

the first character.

1 Identifies the first qualifier. For a disk file, this is the subvolume name. For a

process, this is the first process qualifier.

2 Identifies the second qualifier. For a disk file, this is the file ID. For a process

file, this is the second process qualifier.

Fully qualified permanent disk-file name: \SYSA.$OURVOL.MYSUB.PROGA

Level: -1 0 2

Partially qualified disk file: PROGA

Level: 2

Named process file name: $SERV.#Q1

Level: 0 1

Unnamed process descriptor: \SYSA.$:15:132:3

Level: -1 0

Printer file: $LP1

Level: 0