1 Introduction
2 Ground Rules
Building a File System
3 File Systems
4 File Content Data Structure
5 Allocation Cluster Manager
6 Exceptions and Emancipation
7 Base Classes, Testing, and More
8 File Meta Data
9 Native File Class
10 Our File System
11 Allocation Table
12 File System Support Code
13 Initializing the File System
14 Contiguous Files
15 Rebuilding the File System
16 Native File System Support Methods
17 Lookups, Wildcards, and Unicode, Oh My
18 Finishing the File System Class
The Init Program
19 Hardware Abstraction and UOS Architecture
20 Init Command Mode
21 Using Our File System
22 Hardware and Device Lists
23 Fun with Stores: Partitions
24 Fun with Stores: RAID
25 Fun with Stores: RAM Disks
26 Init wrap-up
The Executive
27 Overview of The Executive
28 Starting the Kernel
29 The Kernel
30 Making a Store Bootable
31 The MMC
32 The HMC
33 Loading the components
34 Using the File Processor
35 Symbols and the SSC
36 The File Processor and Device Management
37 The File Processor and File System Management
38 Finishing Executive Startup
Users and Security
39 Introduction to Users and Security
40 More Fun With Stores: File Heaps
41 File Heaps, part 2
42 SysUAF
43 TUser
44 SysUAF API
Terminal I/O
45 Shells and UCL
46 UOS API, the Application Side
47 UOS API, the Executive Side
48 I/O Devices
49 Streams
50 Terminal Output Filters
51 The TTerminal Class
52 Handles
53 Putting it All Together
54 Getting Terminal Input
55 QIO
56 Cooking Terminal Input
57 Putting it all together, part 2
58 Quotas and I/O
UCL
59 UCL Basics
60 Symbol Substitution
61 Command execution
62 Command execution, part 2
63 Command Abbreviation
64 ASTs
65 Expressions, Part 1
66 Expressions, Part 2: Support code
67 Expressions, part 3: Parsing
68 SYS_GETJPIW and SYS_TRNLNM
69 Expressions, part 4: Evaluation
UCL Lexical Functions
70 PROCESS_SCAN
71 PROCESS_SCAN, Part 2
72 TProcess updates
73 Unicode revisted
74 Lexical functions: F$CONTEXT
75 Lexical functions: F$PID
76 Lexical Functions: F$CUNITS
77 Lexical Functions: F$CVSI and F$CVUI
78 UOS Date and Time Formatting
79 Lexical Functions: F$CVTIME
80 LIB_CVTIME
81 Date/Time Contexts
82 SYS_GETTIM, LIB_Get_Timestamp, SYS_ASCTIM, and LIB_SYS_ASCTIM
83 Lexical Functions: F$DELTA_TIME
84 Lexical functions: F$DEVICE
85 SYS_DEVICE_SCAN
86 Lexical functions: F$DIRECTORY
87 Lexical functions: F$EDIT and F$ELEMENT
88 Lexical functions: F$ENVIRONMENT
89 SYS_GETUAI
90 Lexical functions: F$EXTRACT and F$IDENTIFIER
91 LIB_FAO and LIB_FAOL
92 LIB_FAO and LIB_FAOL, part 2
93 Lexical functions: F$FAO
94 File Processing Structures
95 Lexical functions: F$FILE_ATTRIBUTES
96 SYS_DISPLAY
97 Lexical functions: F$GETDVI
98 Parse_GetDVI
99 GetDVI
100 GetDVI, part 2
101 GetDVI, part 3
102 Lexical functions: F$GETJPI
103 GETJPI
104 Lexical functions: F$GETSYI
105 GETSYI
106 Lexical functions: F$INTEGER, F$LENGTH, F$LOCATE, and F$MATCH_WILD
107 Lexical function: F$PARSE
108 FILESCAN
109 SYS_PARSE
110 Lexical Functions: F$MODE, F$PRIVILEGE, and F$PROCESS
111 File Lookup Service
112 Lexical Functions: F$SEARCH
113 SYS_SEARCH
114 F$SETPRV and SYS_SETPRV
115 Lexical Functions: F$STRING, F$TIME, and F$TYPE
116 More on symbols
117 Lexical Functions: F$TRNLNM
118 SYS_TRNLNM, Part 2
119 Lexical functions: F$UNIQUE, F$USER, and F$VERIFY
120 Lexical functions: F$MESSAGE
121 TUOS_File_Wrapper
122 OPEN, CLOSE, and READ system services
UCL Commands
123 WRITE
124 Symbol assignment
125 The @ command
126 @ and EXIT
127 CRELNT system service
128 DELLNT system service
129 IF...THEN...ELSE
130 Comments, labels, and GOTO
131 GOSUB and RETURN
132 CALL, SUBROUTINE, and ENDSUBROUTINE
133 ON, SET {NO}ON, and error handling
134 INQUIRE
135 SYS_WRITE Service
136 OPEN
137 CLOSE
138 DELLNM system service
139 READ
140 Command Recall
141 RECALL
142 RUN
143 LIB_RUN
144 The Data Stream Interface
145 Preparing for execution
146 EOJ and LOGOUT
147 SYS_DELPROC and LIB_GET_FOREIGN
CUSPs and utilities
148 The I/O Queue
149 Timers
150 Logging in, part one
151 Logging in, part 2
152 System configuration
153 SET NODE utility
154 UUI
155 SETTERM utility
156 SETTERM utility, part 2
157 SETTERM utility, part 3
158 AUTHORIZE utility
159 AUTHORIZE utility, UI
160 AUTHORIZE utility, Access Restrictions
161 AUTHORIZE utility, Part 4
162 AUTHORIZE utility, Reporting
163 AUTHORIZE utility, Part 6
164 Authentication
165 Hashlib
166 Authenticate, Part 7
167 Logging in, part 3
168 DAY_OF_WEEK, CVT_FROM_INTERNAL_TIME, and SPAWN
169 DAY_OF_WEEK and CVT_FROM_INTERNAL_TIME
170 LIB_SPAWN
171 CREPRC
172 CREPRC, Part 2
173 COPY
174 COPY, part 2
175 COPY, part 3
176 COPY, part 4
177 LIB_Get_Default_File_Protection and LIB_Substitute_Wildcards
178 CREATESTREAM, STREAMNAME, and Set_Contiguous
179 Help Files
180 LBR Services
181 LBR Services, Part 2
182 LIBRARY utility
183 LIBRARY utility, Part 2
184 FS Services
185 FS Services, Part 2
186 Implementing Help
187 HELP
188 HELP, Part 2
189 DMG_Get_Key and LIB_Put_Formatted_Output
190 LIBRARY utility, Part 3
191 Shutting Down UOS
192 SHUTDOWN
193 WAIT
194 SETIMR
195 WAITFR and Scheduling
196 REPLY, OPCOM, and Mailboxes
197 REPLY utility
198 Mailboxes
199 BRKTHRU
200 OPCOM
201 Mailbox Services
202 Mailboxes, Part 2
203 DEFINE
204 CRELNM
205 DISABLE
206 STOP
207 OPCCRASH and SHUTDOWN
208 APPEND
Glossary/Index
Downloads
|
GetDVI
In the previous articles, we looked at the UCL F$GETDVI lexical function which is
a wrapper for the GETDVI system call. We covered this call briefly many articles
ago. Here we will flesh it out with all of the options it has. However, many of
these options are related to functionality we won't address until some time in the
future. For now, these cases will simply return a null string or a 0 integer, as
appropriate. To avoid this being the longest article thus far, we will break this
into two articles.
procedure TUOS_FiP.Get_Device_Info( Handle, Buffer, Length : int64 ; SRB : TSRB ) ;
var Buff : PAnsiChar ;
Descriptor : TDVI_Descriptor ;
Device : Devices.TDevice ;
Dev_Name : TUOS_String ;
Loop, Status : integer ;
Offset : int64 ;
PID : TPID ;
Res : int64 ;
Resource : TResource ;
Temp : Ansistring ;
Temp_Handle : boolean ;
Device_Flags, Device_Status : int64 ;
I : integer ;
This_Device_Name, S : string ;
The GETDVI system call is handled by the Get_Device_Info method of the
file processor, as you may recall. We have extended this function considerably.
begin
// Setup...
if( Length = 0 ) then
begin
exit ;
end ;
PID := Kernel.PID ;
Temp_Handle := False ;
if( Handle = 0 ) then
begin
Dev_Name := Get_User_String( Kernel, Kernel.PID, SRB, Status ) ;
Resource := Create_File_Handle( PID, PAnsiChar( Dev_Name.Contents ), 0 ) ;
Temp_Handle := True ;
if( Resource = nil ) then // Some sort of error
begin
Device := nil ;
Generate_Exception( 0 ) ; // Clear exception
end else
begin
Device := TDevice( Resource._Device ) ;
end ;
end else
begin
Handle := USC.Translate_Handle( PID, Handle ) ;
Resource := TResource( Handle ) ;
Device := TDevice( Resource._Device ) ;
end ;
If the descriptor list length is 0, we exit immediately, since there is nothing to
do. The function can take either a handle or a device name. If both are
provided, the handle takes precedence. We've discussed the handle option previously - the
only new item is the assignment of Device. What is really new is the
handling of the device name option (Handle is 0). In such case, we
obtain the device name from the user address space, and create a file handle for
that device. In this case we also set Temp_Handle to True so we know to
delete the handle when done (we don't want to delete a handle that is passed to us,
obviously). If the returned resource is nil, an error occurred (probably because
the device name isn't a valid device). Passing an invalid device is actually okay,
as we will see in a bit. So we need to clear any exception that might have been
generated when we tried to create a handle. If there was an error, Device
is set to nil. Otherwise, we get the device from the handle.
// Map item list and process descriptors...
Offset := MMC.Lock_Pages( PID, Buffer, Length * sizeof( Descriptor ) ) ;
try
Buff := PAnsiChar( MMC.Map_Pages( PID, 0, Buffer, Length * sizeof( Descriptor ),
MAM_Read or MAM_Lock ) ) ;
if( Buff = nil ) then
begin
if( MMC.Last_Error = nil ) then
begin
Generate_Exception( UOSErr_Memory_Address_Error ) ;
end ;
exit ;
end ;
Next we map the descriptor list into our address space, exiting on error.
try
for Loop := 0 to Length do
begin
move( Buff[ Offset ], Descriptor, sizeof( Descriptor ) ) ;
if(
( Descriptor.Buffer_Length = 0 )
or
( Descriptor.Buffer_Address = 0 )
or
( Descriptor.Return_Length_Address = 0 )
) then // End of list
begin
exit ;
end ;
if( Device = nil ) then // Invalid device
begin
if( Descriptor.Item_Code = DVI_EXISTS ) then
begin
if( Write_Integer( 0 ) = UE_Error ) then
begin
exit ;
end ;
continue ;
end else
begin
Generate_Exception( UOSErr_Device_Not_Found ) ;
exit ;
end ;
This_Device_Name := '' ;
end else
begin
This_Device_Name := '_' + Device_Name( Device ) + ':' ;
end ;
Now we loop through the descriptors, moving data from the current pointer into our
local descriptor variable. We check for a terminating descriptor and exit if found.
Next, we check for the case where Device is nil. If so, the only
valid item code is DVI_EXISTS. If that is the code of the current
descriptor, we return 0 to indicate that the specified device does not exist. We
also set This_Device_Name to null. For any other item code, if Device is
nil, we exit with an exception. Otherwise, we get the normalized
device name, prefix it with an underscore, and suffix it with a colon.
case Descriptor.Item_Code of
DVI_ACCESSTIME_RECORDED : begin
Res := 0 ;
if( Device.Mounted ) then // Device is mounted
begin
if( Device.FS <> nil ) then // File system on device
begin
if( Device.FS.Support_Access_Time ) then
begin
Res := 1 ;
end ;
end ;
end ;
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
At this point, we process whichever item code was specified by the current descriptor. In
the case of DVI_ACCESSTIME_RECORDED, we assume false by assigning 0 to
Res. If the device is mounted and has a file system, we then query the
file system to see if it supports access time. If so, we set Res to 1. Since this
is a feature of the file system on the device rather than the device itself, we must
ask the file system. Only stores can save access time, so if any other type of device was
passed and this item was requested, we return 0 (false). We then write the result
value back to the target address specified by the descriptor via the Write_Integer
local function which we will discuss below.
As mentioned earlier, many of these items are not currently supported, so let's briefly
cover those items that are not yet supported so we can get to the supported
items.
DVI_ACPPID : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_ACPTYPE : begin
Res := 0 ; // 0=Illegal // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
These items have to do with ACPs (Ancillary Control Processes), which we haven't
covered yet.
DVI_ALT_HOST_AVAIL : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_ALT_HOST_NAME : begin
if( Write_String( '' ) = UE_Error ) then // TODO
begin
exit ;
end ;
end ;
DVI_ALT_HOST_TYPE : begin
if( Write_String( '' ) = UE_Error ) then // TODO
begin
exit ;
end ;
end ;
DVI_AVAILABLE_PATH_COUNT : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_MULTIPATH : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_PATH_AVAILABLE : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_PATH_NOT_RESPONDING : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_PATH_POLL_ENABLED : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_PATH_SWITCH_FROM_TIME : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_PATH_SWITCH_TO_TIME : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_PATH_USER_DISABLED : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_TOTAL_PATH_COUNT : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_HOST_AVAIL : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_HOST_COUNT : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_HOST_NAME : begin
if( Write_String( '' ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_HOST_TYPE : begin
if( Write_String( '' ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_MPDEV_AUTO_PATH_SW_CNT : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_MPDEV_CURRENT_PATH : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_MPDEV_MAN_PATH_SW_CNT : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
These item codes all have to do with clusters, which we will cover in the future.
Of note, this above code for certain items returns a string with Write_String. This is done
via the Write_String routine, which we will cover in the next article.
DVI_CYLINDERS : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SECTORS : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_TRACKS : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
These item codes have to do with the physical characteristics of disk drives: number of
tracks, cylinders, and sectors. So far we've abstrated away from this level of detail - UOS
doesn't care about this. We may revisit it in the future, as it may be of interest to system
administrators to obtain this information, or we may simply ignore it as irrelevant for
UOS. I haven't decided yet.
DVI_FC_NODE_NAME : begin
if( Write_String( '' ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_FC_PORT_NAME : begin
if( Write_String( '' ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_MSCP_UNIT_NUMBER : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_DFS_ACCESS : begin
if( Write_Integer( 1 ) = UE_Error ) then // Not a DFS device
begin
exit ;
end ;
end ;
These item codes have to do with specific hardware. Again, UOS abstracts away from
this kind of thing, but we will review the FC (Fibre Channel) items in the future.
MSCP is a DEC (PDP-11/VAX/Alpha) specific hardware subsystem and protocol, as is DFS. Unless
UOS ever runs on those hardware platforms, there is probably no need to ever support
them.
DVI_LAN_ALL_MULTICAST_MODE : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_AUTONEG_ENABLED : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_DEFAULT_MAC_ADDRESS : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_FULL_DUPLEX : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_JUMBO_FRAMES_ENABLED : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_LINK_STATE_VALID : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_LINK_UP : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_MAC_ADDRESS : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_PROMISCUOUS_MODE : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_PROTOCOL_NAME : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_PROTOCOL_TYPE : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_LAN_SPEED : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
These item codes have to do with networks, which we will adsress in the future.
DVI_MAILBOX_BUFFER_QUOTA : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_MAILBOX_INITIAL_QUOTA : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
These item codes have to do with logical devices called mailboxes. We will cover
this topic in a future article.
DVI_MT3_DENSITY : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_MT3_SUPPORTED : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
These item codes have to do with magnetic tapes. We will cover this topic in future
articles.
DVI_NOHIGHWATER : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_ODS2_SUBSET0 : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_ODS5 : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
These item codes are specific to VMS file systems. It is unlikely that UOS will ever
need to access these so we will put this off to the future (and possibly forever).
DVI_MOUNTVER_ELIGIBLE : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_MVSUPMSG : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
These items have to do with mount verification. This is a subject we will cover in
the future.
DVI_PREFERRED_CPU : begin
if( Write_Integer( 1 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_PREFERRED_CPU_BITMAP : begin
if( Write_String( #1 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
These item codes have to do with multiprocessor systems. We will address this topic
in a future series of articles.
DVI_EXPSIZE : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_NEXTDEVNAM : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_ROOTDEVNAME : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_SERVED_DEVICE : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_CATCHUP_COPYING : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_COPIER_NODE : begin
if( Write_String( Device.Serial_Number ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_DEVICE_COUNT : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_GENERATION : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_MASTER : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_MASTER_MBR : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_MASTER_NAME : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_SHDW_MBR_COPY_DONE : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_MBR_COUNT : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_MBR_MERGE_DONE : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_MBR_READ_COST : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_MEMBER : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_MERGE_COPYING : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_MINIMERGE_ENABLE : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_NEXT_MBR_NAME : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_SHDW_READ_SOURCE : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_SHDW_SITE : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_SHDW_TIMEOUT : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLCHAR : begin
if( Write_String( #0#0#0#0#0#0#0#0#0#0#0#0#0#0#0#0 ) = UE_Error ) then
begin //TODO
exit ;
end ;
end ;
DVI_VOLCOUNT : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLNAM : begin
if( Write_String( '' ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_VOLNUMBER : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLSETMEM : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLSIZE : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLUME_EXTEND_QUANTITY : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLUME_MOUNT_GROUP : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLUME_MOUNT_SYS : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLUME_PENDING_WRITE_ERR : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLUME_RETAIN_MAX : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLUME_RETAIN_MIN : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLUME_SPOOLED_DEV_CBT : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_VOLUME_WINDOW : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
These item codes have to do with RAID sets. We discussed these many articles ago,
however we will not address these here because we've only dealt (so far) with RAID
sets set up by the Init bootstrap or hardware RAID sets. UOS will also allow RAID
sets to be constructed and modified on the fly. When we address that area of functionality
in a future article, we will also address these items.
DVI_ERRCNT : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_ERROR_RESET_TIME : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
These items have to do with device error handling and we'll cover that in the future.
DVI_NOCACHE_ON_VOLUME : begin
if( Write_Integer( 0 ) = UE_Error ) then //TODO
begin
exit ;
end ;
end ;
DVI_WRITETHRU_CACHE_ENABLED : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
These items have to do with caching, which is topic we will cover in a future article.
DVI_ALL : begin
Res := 0 ;
if( Device.Allocation <> 0 ) then
begin
Res := 1 ;
end ;
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
This returns True if the device is allocated (0=not allocated). We will discuss device
allocation in a future article.
DVI_ALLDEVNAM : begin
S := '' ;
I := 1 ;
if( Device.Allocation_Class > 0 ) then
begin
S := '$' + inttostr( Device.Allocation_Class - 1 ) + '$' ;
I := 2 ;
end ;
S := S + copy( This_Device_Name, I, 1024 ) ;
if( Write_String( S ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_ALLOCLASS : begin
if( Write_Integer( Device.Allocation_Class - 1 ) = UE_Error ) then
begin
exit ;
end ;
end ;
These items have to do with allocation classes, which are numeric values that the
system administrator can assign to disks. If the allocation class is 0, then it
has not been assigned. Otherwise, we construct a device name using the allocation
class, a dollar sign and the device name (skipping the underscore if there is an
allocation class). You may note that we subtract 1 from the allocation class. This
is because valid allocation classes can start at 0, but 0 represents no allocation
class. Thus, the allocation class for the device is 1 more than what the system administrator
assigned.
DVI_AVL : begin
Res := Device.Updated_Info.Flags and DS_Ready_Mask ;
if( Res <> 0 ) then
begin
Res := 1 ;
end ;
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
This item returns 1 if the device is available. There could be many reasons a device
is not ready - it could be offline, powered off, disabled, etc. DS_Ready_Mak
is a bitmask that matches all the status bits that could
indicate a not-ready situation. Thus, we bitwise and it with the device flags
and if the result is non-zero (meaning that one or more not-ready flags are set),
we return 0 to indicate that the device is not currently available.
DVI_CLUSTER : begin
Res := 0 ;
if( Device.FS <> nil ) then
begin
Res := Device.FS.Store.Min_Storage ;
end ;
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
This item returns the cluster size of the device. This only applies to file systems.
For all other devices, this returns 0.
DVI_CONCEALED : begin
Res := 0 ; // TODO
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
This item has to do with some features of logicals that we have not yet covered.
DVI_DEVBUFSIZ : begin
Res := Device.Buffer_Size ;
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
This item returns the device's buffer size.
DVI_DEVCHAR : begin
S := This_Device_Name ;
Device_Flags := Device.Updated_Info.Flags ;
Device_Status := Device.Updated_Info.Status ;
if( Descriptor.Buffer_Length > sizeof( Res ) ) then
begin
Descriptor.Buffer_Length := sizeof( Res ) ;
end ;
Res := 0 ;
if( Device.Allocation <> 0 ) then
begin
Res := DEV_V_ALL ; // Allocated
end ;
if( ( Device_Status and DS_Ready_Mask ) = 0 ) then
begin
Res := Res or DEV_V_AVL ; // Device is available for use.
end ;
if( TFiP_File( Resource._File ) is TFiP_Terminal_File ) then
begin
Res := Res or DEV_V_CCL ;
end ;
if( Device.FS <> nil ) then
begin
Res := Res or DEV_V_DIR ; // Device is directory structured
end ;
if( Device.Pending_Dismount ) then
begin
Res := Res or DEV_V_DMT ; // Device is marked for dismount
end ;
if( ( Device_Status and DS_DualAccess ) <> 0 ) then
begin
Res := Res or DEV_V_DUA ; // Device is dual ported.
end ;
//TODO: DEV_V_ELG // Device has error logging enabled.
if( Device.FS <> nil ) then
begin
Res := Res or DEV_V_FOD ; // Device is files oriented.
end ;
//TODO: DEV_V_FOR // Device is mounted foreign.
if( copy( S, 1, 5 ) = '_NULL' ) then
begin
Res := Res or DEV_V_GEN ; // Device is a generic device.
end ;
if( ( Device_Flags and DFM_Write_Only ) = 0 ) then
begin
Res := Res or DEV_V_IDV ; // Device can provide input.
end ;
//TODO: DEV_V_MBX // Device is a mailbox.
if( Device.Mounted ) then
begin
Res := Res or DEV_V_MNT ; // Device is mounted.
end ;
//TODO: DEV_V_NET // Device is a network device.
if( ( Device_Flags and DFM_Read_Only ) = 0 ) then
begin
Res := Res or DEV_V_ODV ; // Device can provide input.
end ;
//TODO: DEV_V_OPR // Device is an operator.
//TODO: DEV_V_RCK // Device has read-checking enabled.
//TODO: DEV_V_RCT // Disk contains Revector Cache Table (RCT).
if( ( Device_Flags and DF_Integral ) <> 0 ) then
begin
Res := Res or DEV_V_REC ; // Device is record oriented
if( ( Device_Flags and DF_Class_Mask ) = DFC_Stream ) then
begin
Res := Res or DEV_V_SQD ;
// Device is sequential and block oriented.
end ;
end ;
if( ( Device_Flags and DF_Class_Mask ) = DFC_Store ) then
begin
Res := Res or DEV_V_RND ; // Device allows random access.
end ;
//TODO: DEV_V_RTM // Device is a real-time device.
//TODO: DEV_V_SDI // Device is single-directory structured.
//TODO: DEV_V_SHR // Device is shareable.
//TODO: DEV_V_SPL // Device is being spooled.
if( Device.Write_Locked ) then
begin
Res := Res or DEV_V_SWL ; // Device is software write locked.
end ;
if( TFiP_File( Resource._File ) is TFiP_Terminal_File ) then
begin
Res := Res or DEV_V_TRM ;
end ;
//TODO: DEV_V_WCK // Device has write-checking enabled.
if( Write_Integer( Res ) = UE_Error ) then
begin
if( MMC.Last_Error = nil ) then
begin
Generate_Exception( UOSErr_Memory_Address_Error ) ;
end ;
exit ;
end ;
end ;
DVI_DEVCHAR2 : begin
Res := 0 ;
//TODO: DEV_V_CDP // Dual-pathed device with two UCBs.
//TODO: DEV_V_2P // Two paths are known to this device.
//TODO: DEV_V_MSCP // Device accessed using MSCP (disk or tape).
//TODO: DEV_V_SSM // Device is a shadow set member.
//TODO: DEV_V_SRV // Device is served by the MSCP server.
//TODO: DEV_V_RED // Device is redirected terminal.
//TODO: DEV_V_NNM // Device has node$ prefix.
//TODO: DEV_V_WBC // Device supports write-back caching.
//TODO: DEV_V_WTC // Device supports write-through caching.
//TODO: DEV_V_HOC // Device supports host caching.
//TODO: DEV_V_LOC // Accessible by local (non-emulated) controller.
//TODO: DEV_V_DFS // Device is DFS-served.
//TODO: DEV_V_DAP // Device is DAP accessed.
//TODO: DEV_V_NLT // Device is not-last-track - it has no bad block.
//TODO: DEV_V_SEX // Device supports serious exception handling.
//TODO: DEV_V_SHD // Device is a member of a host-based shadow set.
//TODO: DEV_V_VRT // Device is a shadow set virtual unit.
//TODO: DEV_V_LDR // Loader present (tapes).
//TODO: DEV_V_NOLB // Device ignores server load balancing requests.
//TODO: DEV_V_NOCLU // Device will never be available clusterwide.
//TODO: DEV_V_VMEM // Virtual member of a constituent set.
//TODO: DEV_V_SCSI // Device is a SCSI device.
//TODO: DEV_V_WLG // Device has write-logging capability.
//TODO: DEV_V_NOFE // Device does not support forced error.
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
These two items return device characteristics. Some of the characteristics are regarding
features we haven't covered yet, so those are marked with //TODO. For
the flags which we do support, we build up the results and return them.
DVI_DEVCLASS : begin
S := copy( This_Device_Name, 1, 5 ) ;
if( S = '_DISK' ) then
begin
Res := DC_DISK ; // Disk device
end else
if( S = '_TERM' ) then
begin
Res := DC_TERM ; // Terminal
end else
begin
Res := DC_MISC ; // Miscellaneous device
end ;
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
This item returns the device class. Because UOS devices are named based on class,
we can determine what to return based on the device name.
DVI_DEVDEPEND : begin
Res := 0 ;
if( Device.Terminal <> nil ) then
begin
Res := Device.Terminal.Terminal_Flags and $4FFFF ;
end ;
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
DVI_DEVDEPEND2 : begin
Res := 0 ;
if( Device.Terminal <> nil ) then
begin
Res := Device.Terminal.Terminal_Flags and not $4FFFF ;
end ;
if( Write_Integer( Res ) = UE_Error ) then
begin
exit ;
end ;
end ;
These items return device-dependent flags. For instance, a network device would
return a different set of flags than a terminal device. At this point, we've only
covered disks and terminals, so we return 0 for everything except terminals. In
the case of terminals, we return a different subset of the flags depending on whether
the code is DVI_DEVDEPEND or DVI_DEVDEPEND2. This is to
maintain compatibility with VMS.
DVI_DEVICE_MAX_IO_SIZE : begin
if( Write_Integer( Device.Max_IO_Size ) = UE_Error ) then
begin
exit ;
end ;
end ;
This item returns the device's maximum I/O size.
DVI_DEVICE_TYPE_NAME : begin
if( Write_String( Device.Description ) = UE_Error ) then
begin
exit ;
end ;
end ;
This item returns the device description for a device. On VMS, this returns the VAX/Alpha
hardware type. Because UOS aims at a broad range of hardware, which is always evolving,
it is impossible for this code to determine the return value. Nor does it make sense
to try to map onto the VMS device types for compatibility sake. So we leave it to the
device driver to supply this information.
In the next article, we will continue our look at this method.
Copyright © 2020 by Alan Conroy. This article may be copied
in whole or in part as long as this copyright is included.
|
