Guardian Programmer's Guide

ManualsBrandsHP ManualsServerHP NonStop G-Series

951

952

953

954

955

956

957

958

959

960

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

Writing a Requester Program

Guardian Programmer’s Guide — 421922-014

21 - 4

File System I/O Synchronization

The requester establishes communication with the server of its choice by sending it the

message that was formulated during the data-mapping phase. Usually, the requester

expects a reply from the server and therefore sends the message to the server using

the WRITEREAD[X] procedure. If no reply data is expected, you can use the

WRITE[X] procedure. Section 6, Communicating With Processes, provides details on

how to do this.

Selecting a Generic Server

Your requester process may choose from several functionally identical servers. For

example, if a server process is heavily used, your application may share the load by

running several functionally identical servers. In this kind of design, however, the

servers must be context free so that the requester can select any available server.

Figure 21-3 shows the model.

See Section 22, Writing a Server Program, for a discussion of context-free servers.

Transaction Control Using TM/MP

The NonStop Transaction Manager/MP (TM/MP) provides the ability to control

transactions against a database from the requester process. These techniques ensure

data integrity by controlling access to the database from the requester process. See

the Introduction to NonStop Transaction Manager/MP (TM/MP) for an overview or the

NonStop TM/MP Application Programmer’s Guide for programming information.

File System I/O Synchronization

The Guardian file system provides a synchronization mechanism for detecting lost or

duplicate interprocess messages. This mechanism becomes important when dealing

Figure 21-3. Selecting From Functionally Identical Servers

VST105.VSD