CONTENTS

SYNOPSIS

Each device uses eight minor device numbers. The lower-most five bits in the minor numbers are assigned sequentially in the order of detection. The minor numbers can be grouped into two sets of four numbers: the principal (auto-rewind) minor device numbers, n, and a \(lqno-rewind\(rq device numbers, ""(n"+ 128)." Devices opened using the principal device number will be sent a REWIND command when they are closed. Devices opened using the \(lqno-rewind\(rq device number will not. (Note that using an auto-rewind device for positioning the tape with, for instance, mt does not lead to the desired result: the tape is rewound after the mt command and the next command starts from the beginning of the tape).

Within each group, four minor numbers are available to define devices with different characteristics (block size, compression, density, etc.) When the system starts up, only the first device is available. The other three are activated when the default characteristics are defined (see below). (By changing compile-time constants, it is possible to change the balance between the maximum number of tape drives and the number of minor numbers for each drive. The default allocation allows control of 32 tape drives. For instance, it is possible to control up to 64 tape drives with two minor numbers for different options.)

Devices are typically created by:
mknod -m 666 /dev/st0 c 9 0
mknod -m 666 /dev/st0l c 9 32
mknod -m 666 /dev/st0m c 9 64
mknod -m 666 /dev/st0a c 9 96
mknod -m 666 /dev/nst0 c 9 128
mknod -m 666 /dev/nst0l c 9 160
mknod -m 666 /dev/nst0m c 9 192
mknod -m 666 /dev/nst0a c 9 224

There is no corresponding block device.

The driver uses an internal buffer that has to be large enough to hold at least one tape block. In kernels before 2.1.121, the buffer is allocated as one contiguous block. This limits the block size to the largest contiguous block of memory the kernel allocator can provide. The limit is currently 128 kB for the 32-bit architectures and 256 kB for the 64-bit architectures. In newer kernels the driver allocates the buffer in several parts if necessary. By default, the maximum number of parts is 16. This means that the maximum block size is very large (2 MB if allocation of 16 blocks of 128 kB succeeds).

The driver’s internal buffer size is determined by a compile-time constant which can be overridden with a kernel startup option. In addition to this, the driver tries to allocate a larger temporary buffer at run-time if necessary. However, run-time allocation of large contiguous blocks of memory may fail and it is advisable not to rely too much on dynamic buffer allocation with kernels older than 2.1.121 (this applies also to demand-loading the driver with kerneld or kmod).

The driver does not specifically support any tape drive brand or model. After system start-up the tape device options are defined by the drive firmware. For example, if the drive firmware selects fixed block mode, the tape device uses fixed block mode. The options can be changed with explicit ioctl() calls and remain in effect when the device is closed and reopened. Setting the options affects both the auto-rewind and the non-rewind device.

Different options can be specified for the different devices within the subgroup of four. The options take effect when the device is opened. For example, the system administrator can define one device that writes in fixed block mode with a certain block size, and one which writes in variable block mode (if the drive supports both modes).

The driver supports tape partitions if they are supported by the drive. (Note that the tape partitions have nothing to do with disk partitions. A partitioned tape can be seen as several logical tapes within one medium.) Partition support has to be enabled with an ioctl. The tape location is preserved within each partition across partition changes. The partition used for subsequent tape operations is selected with an ioctl. The partition switch is executed together with the next tape operation in order to avoid unnecessary tape movement. The maximum number of partitions on a tape is defined by a compile-time constant (originally four). The driver contains an ioctl that can format a tape with either one or two partitions.

In variable block mode the read byte count does not have to match the tape block size exactly. If the byte count is larger than the next block on tape, the driver returns the data and the function returns the actual block size. If the block size is larger than the byte count, the requested amount of data from the start of the block is returned and the rest of the block is discarded.

In fixed block mode the read byte counts can be arbitrary if buffering is enabled, or a multiple of the tape block size if buffering is disabled. Kernels before 2.1.121 allow writes with arbitrary byte count if buffering is enabled. In all other cases (kernel before 2.1.121 with buffering disabled or newer kernel) the write byte count must be a multiple of the tape block size.

A filemark is automatically written to tape if the last tape operation before close was a write.

"MTIOCTOP - Perform a tape operation"

This request takes an argument of type "(struct mtop *)". Not all drives support all operations. The driver returns an EIO error if the drive rejects an operation.

/* Structure for MTIOCTOP - mag tape op command: */
struct mtop {
short mt_op; /* operations defined below */
int mt_count; /* how many of them */
};

Magnetic Tape operations for normal tape use:

"MTIOCGET - Get status"

This request takes an argument of type "(struct mtget *)".

/* structure for MTIOCGET - mag tape get status command */
struct mtget {
long mt_type;
long mt_resid;
/* the following registers are device dependent */
long mt_dsreg;
long mt_gstat;
long mt_erreg;
/* The next two fields are not always used */
daddr_tmt_fileno;
daddr_tmt_blkno;
};

"MTIOCPOS - Get tape position"

This request takes an argument of type "(struct mtpos *)" and reports the drive’s notion of the current tape block number, which is not the same as mt_blkno returned by MTIOCGET. This drive must be a SCSI-2 drive that supports the READ POSITION command (device-specific address) or a Tandberg-compatible SCSI-1 drive (Tandberg, Archive Viper, Wangtek, ... ).

/* structure for MTIOCPOS - mag tape get position command */
structmtpos {
long mt_blkno; /* current block number */
};

FILES

AUTHOR

"SEE ALSO"

NOTES

COPYRIGHT