Compressed CKD Dasd Emulation

Contents

• Introduction
• Shadow Files
• File Structure
• Methodology
• Quick Start
• Using Shadow Files
• Options
• Utilities
• FAQ
• Changes
• Bugs
• cckddump os/390 hlasm program

Introduction

A cckd file contains track images, which may be compressed or uncompressed, and overhead blocks which are headers, lookup tables, and free space. Compressed track images may be compressed by zlib or bzip2.

Track images are addressed by track number using a two table lookup method: track number divided by 256 (trk >> 8) indexes into the primary lookup table, which contains the file offset to the secondary lookup table; the remainder of track number divided by 256 (trk & 0xff) indexes into the corresponding secondary lookup table, which contains the offset and length of the track image.

There is a single primary lookup table and a variable number of secondary lookup tables. The maximum number of secondary lookup tables is the number of tracks for the device type divided by 256, rounded up. For example, a 3390-3 contains 50085 tracks and would require at most 196 secondary lookup tables.

A regular CKD file contains a 512 byte header followed by track images, each taking the same amount of space: the maximum track size. The offset of a track image can be readily calculated by the track number:

A cckd file can take significantly less file space than a regular CKD file because

• A track image only occupies its length in the file and not the maximum track size
• A track image may be compressed, reducing its length
• Unused or null tracks do not occupy any space at all

Shadow Files

Shadow files are implemented using the same file structure as base cckd files. By default, there can be up to 8 shadow files in use at any time for an emulated CKD device. The base file is designated file [0] and the shadow files are files [1] up to file [8]. The highest numbered file in use at a given time is the current file, where all writes will occur. Track reads start at the current file and proceed down until a file is found that actually contains the track image.

A shadow file, then, contains all the changes made to the emulated CKD dasd since its creation, until the creation of the next shadow file. The moment of the shadow file's creation can be thought of as taking a snapshot of the current emulated CKD dasd at that time, because if the shadow file is later removed, then the emulated CKD dasd will revert to the state it was at when the snapshot was taken.

Using shadow files, you can keep the base CKD file on a read-only device such as cdrom, or change the base CKD file attributes to read-only, ensuring that this file can never be corrupted.

Hercules console commands are provided to add a new shadow file, remove the current shadow file (with or without backward merge), and display the shadow file status and statistics.

CCKD File Structure

• CKD_P370    Regular CKD file
• CKD_C370    Compressed CKD file
• CKD_S370    Shadow CKD file

Following the L1TAB, in no particular order, are L2TABs, compressed track images, and free spaces.

L2TABs contain 256 8-byte entries,and each are, consequently, 2048 bytes in length. Each entry contains the offset and length of a track image. If the offset is 0x00000000 then the track image is null; if the offset is 0xffffffff then the previous file should be searched instead.

A compressed track image contains the following two fields:

• A track header, also called a home address or a track index. The track header is never compressed.
• The track image, beginning with the R0 count and ending with the end-of-track marker, which is a count field containing all hex 0xff's. The track image may or may not be compressed.

The HA contains 0CCHH, that is, a byte of zeroes, 2 bytes indicating the cylinder of the track, and 2 bytes indicating the head of the track on the cylinder. Both CC and HH are stored in big-endian byte order. The track is computed by

Free space contains a 4-byte offset to the next free space, a 4-byte length of the free space, and zero or more bytes of residual data.

The minimum length of a free space is 8 bytes. Since free space is ordered by file offset and no two free spaces are adjacent, offset in the free space entry is always greater than the current free space offset + the current free space length, unless the offset is zero, which indicates the free space chain is terminated.
The free space chain is read when the file is opened for read-write and written when the file is closed; while the file is opened, the free space chain is maintained in storage.

Methodology

Initialization

When a CKD dasd emulation file is initialized, function ckddasd_init_handler in ckddasd.c is called. After ckddasd_init_handler has completed its initialization, if the file is a cckd file, or if shadowing was specified, function cckddasd_init_handler in cckddasd.c is called.

cckddasd_init_handler obtains a cckd extension and stores its address in field cckd_ext in the DEVBLK (the control block that represents the device).

The compressed device header (CCKDDASD_DEVHDR) and L1TAB for the file is read; however, if the file is a regular file, a dummy CCKD_DEVHDR is built (all zeroes) and a dummy L1TAB is built (all 0xff's).

If shadow files exist, they are opened and their CCKD_DEVHDRs and L1TABs are read. If the last file opened could only be opened read-only, then a new shadow file is created.

The basic point is that the CCKD_DEVHDR and the L1TAB for the base file and each shadow file is read and stored in an array in the cckd extension, and each file is opened read-only, except the current file, which is opened read-write.

File I/O

In the course of executing a channel program, routines in ckddasd.c normally call the lseek, read, and write c library routines. These routines (as we all know;-) perform the following functions:

lseek	Sets the current file offset to the specified value
read	Reads the specified number of bytes from the current file offset to a buffer and increments the current file offset accordingly
write	Writes the specified number of bytes from a buffer to the current file offset and increments the current file offset accordingly

If the cckd extension is present, however, routines cckd_lseek, cckd_read and cckd_write in cckddasd.c are called instead.

Routines cckd_read and cckd_write are not very interesting, they merely copy data to/from the caller's buffer from/to the active uncompressed track image buffer. cckd_write, it should be noted, sets a bit indicating that the active track image has been updated. All the interesting work results from cckd_lseek being called...

Track Switching

From the offset passed to cckd_lseek by ckddasd.c, using the formula described above, the requested track can be calculated using:

cckd_read_trk

Function cckd_read_trk scans the track cache array to see if the new track image is cached. (By default, a cylinder's worth of track images are cached). If the new track is found to be cached, then the timestamp in the cache entry is updated, and the track image pointed to by the cache entry is made active (this is known as a cache hit). Otherwise, the cache entry with the oldest timestamp (called the least recently used or lru entry) is stolen.

If the stolen cache entry has had it's track image buffer updated (by cckd_write), then high-level routine cckd_write_trk is called to place the buffer on the deferred write queue and a new buffer is obtained.

If writes have previously occurred for the file, then the deferred write queue is scanned to see if the new track image has been queued to be written. If the new track image is in the deferred write queue then the current lru buffer is discarded and replaced with buffer scheduled to be written and cckd_read_trk returns, counting the encounter as a cache hit since no physical i/o to be performed. (Also, a cache bit, called the writing bit is turned on, indicating that if this cache entry is later stolen, then a new buffer must be obtained).

Otherwise, low-level routine cckd_read_trkimg is called to physically read the track image; the image is uncompressed (if necessary), and the cache entry timestamp is updated.

If cckd_read_trk was called by the i/o thread (ie by cckd_lseek), and the new track number is one more than the current track number, function cckd_readahead is called to asynchronously read 1 or more following track images, if those track images are not already in the track cache and readahead is enabled. cckd_readahead signals 1 or more readahead threads, implemented in function cckd_ra. cckd_ra, when signalled, calls cckd_read_trk to read the requested track. Note readahead is currently disabled for windows32 due to some, as yet unknown, problem in the pthreads implementation.

If the stolen cache entry had had its track image buffer updated (and cckd_write_trk was called), then the deferred-write-thread is signalled to actually begin the process of writing the old updated track image. We see that the updated track image is not sheduled to be written until after the new track image has been read and the readahead threads have been signalled. Further, we see that an updated track image is not scheduled to be written until its cache entry has been stolen; hence the moniker very-lazy-write.

After all this, cckd_read_trk returns, and the new track image buffer is made active and the new track number is made current.

cckd_write_trk

Function cckd_write_trk is called by cckd_read_trk whenever a stolen cache entry's track image buffer has been updated. The function obtains a deferred-write entry and places the entry at the head of the deferred-write queue. If this is the first time that cckd_write_trk has been called for the device (ie the first write), then a bit is set on in the CCKDDASD_DEVHDR indicating that writes have occurred for the file, and the deferred-write threads and the garbage collection thread are created. It is the responsibility of the caller of cckd_write_trk to actually signal the deferred-write thread (cckd_dfw) to initiate the write process.

cckd_dfw

Function cckd_dfw is a high-level routine that actually causes a track image to be written. It pops an entry off the deferred-write queue, compresses the track image, calls the low-level routine cckd_write_trkimg to perform the physical i/o, and releases the track image buffer (unless the track is still in the track cache, then the updated bit is turned off).

cckd_dfw will also throttle the deferred-write queue if it becomes too large; this causes the callers of cckd_write_trk (eg cckd_read_trk) to be suspended until the queue drops below its threshold.

More than one deferred-write thread can be created, by specifying a parameter on the device statement. The benefits, if any, of multiple threads has not yet been shown.

High level vs Low level routines

It has been casually mentioned above that cckd_read_trk, cckd_write_trk and cckd_dfw are high-level routines and cckd_read_trkimg and cckd_write_trkimg are low-level routines. In this context, high-level routines have no dependcy on the underlying file structure while the low-level routines do. The high-level routines are thread-aware while the low-level routines are not.

The Low level routines

There are low level routines to read and write each of the components of the cckd file structure (headers, l1tabs, l2tabs, track images, and free spaces); each are cognizant of the base file and shadow files, if any. These routines consist of the following functions

	cckd_read_chdr	read the compressed header
	cckd_write_chdr	write the compressed header
	cckd_read_l1	read the primary lookup table
	cckd_write_l1	write the primary lookup table
	cckd_write_l1ent	write a primary lookup table entry
	cckd_read_fsp	read the free space chain
	cckd_write_fsp	write the free space chain
	cckd_read_l2	read a secondary lookup table
	cckd_write_l2	write a secondary lookup table
	cckd_read_l2ent	read a secondary lookup table entry
	cckd_write_l2ent	write a secondary lookup table entry
	cckd_read_trkimg	read a track image
	cckd_write_trkimg	write a track image

All writes occur to the current file. The compressed header and the primary lookup table are kept in storage, so they are read once. Free space is read when the first write occurs for the file and is written when the file is closed. Secondary lookup tables are cached, so cckd_read_l2 doesn't necessarily perform physical file i/o. The base file can be a regular CKD file.

Shadow file routines

The routines that manipulate the shadow files are

	cckd_sf_name	generates a file name for a given shadow or base file
	cckd_sf_init	performs shadow file initialization
	cckd_sf_new	creates a new shadow file
	cckd_sf_add	adds a shadow file (sf+ panel command)
	cckd_sf_remove	removes a shadow file, with or without backwards merge (sf- panel command)
	cckd_sf_newname	sets a new shadow file name if shadowing is not currently active (sf= panel command)
	cckd_sf_stats	display base and shadow file statistics (sfd panel command)

The garbage collector

The garbage collection thread is created when the first write occurs to the file. The garbage collection thread is only active for the current file. When a new track image is written, the space it previously occupied in the file is freed, and new space is acquired. The garbage collector moves track images and secondary lookup tables to combine free spaces and tends to move free space towards the end of the file so it can drop off. The garbage collector also schedules track images to be written if they haven't been referenced in some amount of time.

Byte order

As described above, a number of fields in the various blocks that comprise the spaces in a compressed CKD Dasd emulation file contain offsets and lengths that are more than 1 byte in length. Values in multiple bytes may be stored in either little-endian or big-endian byte order. For example, Intel architecture stores values in little-endian byte order and S390 architecture stores values in big-endian byte order. Consider the value 0x00010203; stored in little-endian byte order, we would see "03020100"; stored in big-endian byte order, we would see "00010203". The values in the compressed CKD Dasd emulation file are stored in byte order of the host machine; a bit in the CCKDDASD_DEVHDR indicates which order its values are stored. If a file is opened with the wrong byte order, then the initialization routine will automatically reverse all the values before continuing.

If a base file or shadow is read-only and contains the wrong byte order, then the fields are automatically converted when the blocks are read.

Quick Start

Using Shadow Files

Shadow files are automatically enabled for cckd files; you must explicitly enable them for regular CKD files. To enable shadowing for a CKD device, specify