Guardian Programmer's Guide
Table Of Contents
- Guardian Programmer’s Guide
- Contents
- What’s New in This Manual
- About This Manual
- Legal Notices
- 1 Introduction to Guardian Programming
- 2 Using the File System
- 3 Coordinating Concurrent File Access
- 4 Using Nowait Input/Output
- 5 Communicating With Disk Files
- Types of Disk Files
- Using Unstructured Files
- Creating Unstructured Files
- Opening Unstructured Files
- Positioning, Reading, and Writing With Unstructured Files
- Locking With Unstructured Files
- Renaming Unstructured Files
- Avoiding Unnecessary Cache Flushes to Unstructured Files
- Closing Unstructured Files
- Purging Unstructured Files
- Altering Unstructured-File Attributes
- Using Relative Files
- Using Entry-Sequenced Files
- Using Key-Sequenced Files
- Creating Key-Sequenced Files
- Opening Key-Sequenced Files
- Positioning, Reading, and Writing With Key-Sequenced Files
- Locking, Renaming, Caching, Closing, Purging, and Altering Key-Sequenced Files
- Key-Sequenced File Programming Example
- Using Alternate Keys With an Entry-Sequenced File
- Using Alternate Keys With a Key-Sequenced File
- Using Partitioned Files
- Using Alternate Keys
- 6 Communicating With Processes
- Sending and Receiving Messages: An Introduction
- Sending Messages to Other Processes
- 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
- Receiving and Processing System Messages
- Handling Errors
- Communicating With Processes: Sample Programs
- 7 Using DEFINEs
- 8 Communicating With a TACL Process
- 9 Communicating With Devices
- 10 Communicating With Terminals
- 11 Communicating With Printers
- 12 Communicating With Magnetic Tape
- Accessing Magnetic Tape: An Introduction
- Positioning the Tape
- Reading and Writing Tape Records
- Blocking Tape Records
- Working in Buffered Mode
- Working With Standard Labeled Tapes
- Enabling Labeled Tape Processing
- Creating Labeled Tapes
- Checking for Labeled Tape Support
- Accessing Labeled Tapes
- Writing to the Only File on a Labeled Tape Volume
- Writing to a File on a Multiple-File Labeled Tape Volume
- Writing to a File on Multiple Labeled Tape Volumes
- Reading From the Only File on a Labeled Tape Volume
- Reading From a File on a Multiple-File Labeled Tape Volume
- Reading From a File on Multiple Labeled Tape Volumes
- 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
- 14 Using the IOEdit Procedures
- 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
- Handling Nowait I/O
- Handling Interprocess Messages
- Handling 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
- 17 Managing Memory
- An Introduction to Memory-Management Procedures
- Managing the User Data Areas
- Using (Extended) Data Segments
- Overview of Selectable Segments
- Overview of Flat Segments
- Which Type of Segment Should You Use?
- Using Selectable Segments in TNS Processes
- Accessing Data in Extended Data Segments
- Attributes of Extended Data Segments
- Allocating Extended Data Segments
- Checking Whether an Extended Data Segment Is Selectable or Flat
- Making a Selectable Segment Current
- Referencing Data in an Extended Data Segment
- Checking the Size of an Extended Data Segment
- Changing the Size of an Extended Data Segment
- Transferring Data Between an Extended Data Segment and a File
- Moving Data Between Extended Data Segments
- Checking Address Limits of an Extended Data Segment
- Sharing an Extended Data Segment
- Determining the Starting Address of a Flat Segment
- Deallocating an Extended Data Segment
- Using Memory Pools
- 18 Managing Time
- 19 Formatting and Manipulating Character Data
- Using the Formatter
- Manipulating Character Strings
- Programming With Multibyte Character Sets
- Checking for Multibyte Character-Set Support
- Determining the Default Character Set
- Analyzing a Multibyte Character String
- Dealing With Fragments of Multibyte Characters
- Handling Multibyte Blank Characters
- Determining the Character Size of a Multibyte Character Set
- Case Shifting With Multibyte Characters
- Testing for Special Symbols
- Sample Program
- 20 Interfacing With the ERROR Program
- 21 Writing a Requester Program
- 22 Writing a Server Program
- 23 Writing a Command-Interpreter Monitor ($CMON)
- Communicating With TACL Processes
- Controlling the Configuration of a TACL Process
- Controlling Logon and Logoff
- Controlling Passwords
- Controlling Process Creation
- Controlling Change of Process Priority
- Controlling Adding and Deleting Users
- Controlling $CMON While the System Is Running
- Writing a $CMON Program: An Example
- Debugging a TACL Monitor ($CMON)
- 24 Writing a Terminal Simulator
- 25 Debugging, Trap Handling, and Signal Handling
- 26 Synchronizing Processes
- 27 Fault-Tolerant Programming in C
- Overview of Active Backup Programming
- Summary of Active Backup Processing
- What the Programmer Must Do
- C Extensions That Support Active Backup Programming
- Starting the Backup Process
- Opening a File With a Specified Sync Depth
- Retrieving File Open State Information in the Primary Process
- Opening Files in the Backup Process
- Retrieving File State Information in the Primary Process
- Updating File State Information in the Backup Process
- Terminating the Primary and Backup Processes
- Organizing an Active Backup Program
- Updating State Information
- Providing Communication Between the Primary and Backup Processes
- Programming 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
- Glossary
- Index
Communicating With Devices
Guardian Programmer’s Guide — 421922-014
9 - 10
Additional Device Information (G-series Only)
To support the interface for CONFIG_GETINFO_BYNAME2_ procedure or
CONFIG_GETINFO_BYLDEV2_ procedure, a device must be coded to handle a new
system message from $RECEIVE (-147: ZSYS_VAL_SMSG_CONFIGINFO). The
format of this system message is defined in zsysc by the
zsys_ddl_smsg_configinfo2_def type. The reply from a device that supports these
procedures is expected to have a zsys_ddl_smsg_confinf_reply_def format.
The following code fragment demonstrates how a subsystem might be enhanced to
support the CONFIG_GETINFO calls in its $RECEIVE message-handling code.
Effectively, the code simply receives a message from $RECEIVE, and branches to the
code to handle specific types of system messages. To handle the
ZSYS_VAL_SMSG_CONFIGINFO request, the fields of a
zsys_ddl_smsg_confinf_reply_def are filled with appropriate values for the device, and
REPLYX is called to reply to the request. For more information on processing system
messages, see Processing System Messages and Section 9, Communicating With
Devices.
{
short replyerr;
zsys_ddl_smsg_configinfo2_def *ci2req;
zsys_ddl_smsg_confinf_reply_def cireply;
_cc_status cc;
/* ... code to receive system messages */
cc = READUPDATEX( recv_fnum, (char *)message, (short)sizeof(message),&len);
/* ... */
switch(message[0]) {
case ZSYS_VAL . . . :
/* ... other system message types */
case ZSYS_VAL . . . :
/* ... other system message types */
case ZSYS_VAL_SMSG_CONFIGINFO: /* CONFIG_GETINFO_ request */
ci2req = (zsys_ddl_smsg_configinfo2_def *)message;
if(ci2req->z_msgversion != ZSYS_VAL_SMSG_CONFIGINFO_VERS2){
cc = REPLYX(,,,,FEBADOP);
/* . . . */
}
else {
cireply.z_msgnumber = ci2req->z_msgnumber;
cireply.z_msgversion = ci2req->z_msgversion;
cireply.z_device_type = /* --<-- */ ;
cireply.z_device_subtype = /* --<-- */ ;
cireply.z_device_record_size = /* --<-- */ ;
cireply.z_logical_status = 0 /* --<-- */ ;
strcpy(cireply.z_config_name, "CONFIG_EXAMPLE_PROC");
cireply.z_config_name_len = strlen(cireply.z_config_name);
strcpy(cireply.z_subsys_manager = "$MANAGR";
cireply.z_subsys_manager_len = strlen(cireply.z_subsys_manager);
PROCESSHANDLE_GETMINE_((short *)&cireply.z_primary_phandle);
PROCESSHANDLE_NULLIT_((short *)&cireply.z_backup_phandle);
cireply.z_specific_info_len = 0;
cc = REPLYX( (char *)&cireply /* buffer */
, sizeof(cireply) /* write_count */
, /* count_written */
, /* message tag */
, FEOK