OS/2 eZine - http://www.os2ezine.com
April 16, 2002
Douglas Clark is a program management consultant who first started using OS/2 version 1.3. He's married, with 2 girls, and is old enough to remember when 4 color mainframe terminals were a big thing.

If you have a comment about the content of this article, please feel free to vent in the OS/2 eZine discussion forums.

There is also a Printer Friendly version of this page.

Previous Article
Next Article

Do you have an OS/2 product or service you'd like to advertise?

Installable File Systems

An Installable File System (IFS) is a software device that handles the interface between the operating system and a storage device; the IFS handles logical requests from the kernel for read, write, seek, close, etc. and translates those requests into whatever form is needed by the device it is handling. Normally we think of storage devices as hard drives, floppy drives and the like, but we will see below that the "device" concept has been expanded to include all sorts of other things. The installable part means that the file system is loaded up by the operating system during boot up when it reads the CONFIG.SYS file, rather then being built into the operating system kernel.

Removing file systems from the kernel into loadable modules means that OS/2 can be extended by anyone who wants to build a new installable file system. This article is a brief overview of some of the different types of file systems available for OS/2, and some components that are not technically IFSes but fit into that general category.


OS/2 handles storage devices through the mechanism of "drive letters", which means that any device or other thing handled by an IFS ultimately appears to OS/2 at some point as a drive letter (except for Netdrive.) The beauty of IFSes is that once the drive letter is assigned, that device can be used and manipulated with normal OS/2 facilities and applications, just like a regular hard drive or floppy. This leverages the functions provided by the IFS to a much higher level by enabling OS/2 facilities like Workplace Shell Drive Objects, the Shredder and the Print Object, along with applications, to take advantage of the IFS features. Take FTP for example: later versions of OS/2 come with a PM based FTP application. This application works fine - you can use it to send and to get files to and from a FTP host machine. But you are limited to the functions provided by that FTP application. Compare that to using an FTP installable file system. Once the remote FTP host is assigned a drive letter you treat files on the remote host just as if they were local files: you can use a Drive Object from the Workplace Shell to copy, move and delete files, you can edit the file from an editor without having to first transfer the file to your local machine, you can print the file by dragging it to a Printer Object (assuming Print Object recognizes the contents of the file). Packaging the same FTP functions provided by the FTP application into an IFS greatly enhances the usefulness of the functions.

I have chosen to group the IFSes into some broad categories of my own arbitrary choosing in hopes that it will help us to understand what is available for OS/2.

Standard - Included with OS/2

IBM built and supplies a number of files systems for OS/2. Most of these are included in the base operating system, but a few are extra cost add-ons that come with special versions of OS/2. Major portions of this section are quoted from the Redbook Inside OS/2 Warp Server for e-business and from Microsoft System Journal V4 n5 dated Sept 1989 .


Technically FAT, which stands for File Allocation Table, is not an installable file system because FAT support is built into the OS/2 kernel. It is the original file system used in OS/2 and in DOS. FAT was first developed by Microsoft in 1977 for their stand-alone version of BASIC, and was modified to incorporate features from CP/M when it made its appearance in DOS in 1981.

FAT was optimized for performance by reading the file allocation table content into memory and keeping it there, i.e. making the FAT resident. With the advent of large hard drives FAT has become slow since it is so large that it cannot be held resident in memory anymore which results in paging as a program reads through a file. In addition since the free space information is dispersed across many sectors of FAT, it is impractical to allocate file space contiguously and file fragmentation is inevitable, further degrading system performance.

With the size of today's hard drives the main use of FAT is for compatibility between OS/2 and Windows, plus FAT remains the file system used in OS/2 for floppy disks.


High Performance File System was designed by Microsoft to replace FAT as the file system of choice for hard drives. HPFS introduced a number of functional enhancements like long file names and extended attributes (while extended attributes are also handled in FAT systems, HPFS stores the extended attributes in the file structure(s) itself, i.e. it is "built in".) But the main objectives for HPFS were performance. Quoting from MSJ,

HPFS attacks potential bottlenecks in disk throughput at multiple levels. It uses advanced data structures, contiguous sector allocation, intelligent caching, read-ahead, and deferred writes in order to boost performance.

First, the HPFS matches its data structures to the task at hand: sophisticated data structures (B Trees and B+ Trees) for fast random access to filenames, directory names, and lists of sectors allocated to files or directories, and simple compact data structures (bitmaps) for locating chunks of free space of the appropriate size. The routines that manipulate these data structures are written in assembly language and have been painstakingly tuned, with special focus on the routines that search the freespace bitmaps for patterns of set bits - unused sectors.

Next, the HPFS's main goal is to assign consecutive sectors to files whenever possible. The time required to move the disk's read/write head from one track to another far outweighs the other possible delays, so the HPFS works hard to avoid or minimize such head movements by allocating files space contiguously and by keeping control structures such near the things they control. Highly contiguous files also help the file system make fewer requests of the disk driver for more sectors at a time, allowing the disk driver to exploit the multisector transfer capabilities of the disk controller, and reducing the number of disk completion interrupts that must be serviced.

Of course, trying to keep files from becoming fragmented is no easy chore. One strategy the HPFS uses is to scatter newly created files across the disk - in separate bands if possible - so that the sectors allocated to the files as they are extended will not be interleaved. Another strategy is to preallocate approximately 4Kb of contiguous space to the file each time it must be extended and give back any excess when the file is closed. If an application knows the ultimate size of the new file in advance, it can assist the file system by specifying an initial file allocation when it creates a file; HPFS will then search the all the free space to find a run of consecutive sectors large enough to hold the file.

HPFS relies on several different types of caching to minimize the number of physical disk transfers it must request. It adjusts sector caching on a per-handle basis according to manner in which the file is used. It also prereads data it believes the program is going to need; this prereading is adjusted according to the type of file being opened and the past uses of that file. [note: there is some disagreement on whether this has actually been implemented.]

More information about HPFS can be found at: nondot.org/sabre/os/files/FileSystems/HPFS/index.html


HPFS386 is a variant of HPFS designed to provide extremely fast access to large disk volumes and optimized performance in server environments. It was designed for server environments and has a number of performance enhancements and functional enhancements specifically geared to servers.

Performance-wise HPFS386 is ideal as a file and print server because it is tightly integrated with the server code at ring 0 allowing data to be transferred directly from the HPFS386 cache to the network adapter driver without going through ring transitions. In addition HPFS386 has a greatly increased cache size, up from a maximum size of 2MB for "normal" HPFS to size limited only by system memory.

Functional enhancements for the server role include local file security built into extended attributes rather than stored in NET.ACC as it is with HPFS, software fault tolerance support for RAID-1 (disk mirroring and duplexing), and administrator specified directory/user based disk space limitations.

HPFS386 has been available over time as part of various LAN Server packages and as an additional cost license to server packages such as WSeB. Generally speaking HPFS386 cannot be installed on client machines, however the hpfs386.zip package supposedly allows an earlier version to be installed on client machines and www.os2docs.org/as/hpfs386/HPFS386.html is a description of how to install HPFS386.


Journaled File System, JFS, was intended by IBM to replace HPFS (but not HPFS386); whether that now happens with the reduced attention IBM is devoting to OS/2 is a question yet to be resolved. JFS was developed in IBM's AIX operating system and made the official transition to OS/2 in WSeB. JFS has a number of design benefits over HPFS: faster recovery time from a system crash, better scalability in SMP environments, enhancements for TCP/IP access, the ability to create a single logical volume (driver letter) that spans multiple hard drives or partitions, and the ability to "grow" that volume without destroying the data contained in it.

JFS however has a number of limitations: it is not bootable, it does not provide local file security like HPFS386, and it does not provide software fault tolerance (RAID).

JFS was designed with performance in mind. Like HPFS, JFS strives to allocate new files as contiguous areas of the drive thereby minimizing disk head movement due to fragmentation. JFS also places file structures close to the data like HPFS. Unlike HPFS, JFS is a 32 bit file system. A number of enhancements have been made in various existing parts of OS/2 to provide JFS with a full 32 bit path; for example OS2DASD.DMD has some added 32 bit entry points that are used by JFS along with a new 32bit kernel execution environment that is used by JFS and the 32bit version of TCP/IP introduced with WSeB.

Comparing the actual performance in a server environment between JFS and HPFS386 is difficult to do. JFS has additional APIs that TCP/IP applications take advantage of for better performance, plus the way JFS is implemented makes TCP/IP performance better with JFS than with HPFS386. However HPFS386 is faster for file and print serving than JFS: in a single processor environment JFS is 40% slower than HPFS386, and it isn't until you reach a 4 processor SMP server that JFS catches HPFS386 in file serving performance. For client environments it is unlikely that the average user will notice any performance difference between HPFS and JFS, although JFS should perform slightly better. The current limitation of not being able to boot off of a JFS means that HPFS will be around for some time to come.


CD File System is the file system used to read CD-ROMs. It is included as standard with OS/2.


UDF is the file system used to read and write DVDs. While it can be used to read and write data to DVDs there is no provision currently in OS/2 for playing DVD movies. UDF is bundled with WSeB and eComStation.

So far things have look boringly normal: all the file systems thus far have been for reading and writing to fairly normal storage devices for OS/2. From here on out however things get more interesting.

Other Operating Systems

There are a number of installable file systems, and plain old utilities, designed to help OS/2 co-exist with other operating systems.

Windows VFAT

VFAT is Microsoft extension to FAT that allows long file names. Since FAT can only handle file names of 8 characters with an optional extension of 3 characters, alternate methods must be used to handle long file names on FAT drives. The OS/2 Workplace Shell handles this by copying the long file name into an extended attribute when it copies a file onto a FAT drive. VFAT is Microsoft's method of handling the long file names and it also stores long file names in some special area.

There are two IFSes available to allow OS/2 to work with VFAT partitions: VFAT-IFS and the Netdrive VFAT plug-in.

VFAT-IFS is an installable file system that allows OS/2 to work with VFAT drives. With VFAT-IFS you can read and write to a VFAT drive or partition. VFAT-IFS is beta code and has been for a number of years. It is unlikely that it will ever become finalized. Because installable file systems run at a priviledge level of the operating system it would probably be safer, but less convenient, to use a utility like VFAT2EA.

VFAT2EA is a utility that converts the long file names on a VFAT partition to the LONGNAME extended attribute used by the Workplace Shell; it creates extended attributes for all the files on the VFAT drive or partition and copies the long file name into the LONGNAME attribute. Since VFAT is just an extended version of FAT OS/2 can read and write to VFAT drives already - using VFAT2EA makes the long names of the files on a VFAT drive visible to the Workplace Shell and any other utility that recognizes the LONGNAME attribute. VFAT2EA also has a EA2VFAT mode, which transfers the name on the LONGNAME attribute to the structure used by VFAT. This is for files that OS/2 creates on the VFAT drive.

Windows NT

NTFS is the primary file system for Windows NT. For installations that boot to both NT and OS/2 there are four ways of sharing files between OS2 and NT:
  1. Use the utilities from the NTFS_003 package to access NTFS files from OS/2. The utilities - ntdir, ntcat and ntcp - allow you to perform a directory listing, list a file, and copy a file from NTFS partition to an OS/2 drive from an OS/2 session.
  2. Place files that need to be shared on a FAT partition. Both NT and OS/2 can access FAT partitions.
  3. Use the HPFSNT package to install HPFS support to NT. I have also read in a couple of places that even though Microsoft stopped supporting HPFS for NT with version 3.51 it is still possible to hack NT4 (and possibly later versions) to access HPFS partitions with some 4 or 5 line changes to the registry, although I have not seen what the actual hacks are.
  4. Use the VFAT-OS2 installable file system to get read-only access to NTFS partitions from OS/2. You have to specify the -NTFS parameter on the VFAT-OS2 IFS line on the CONFIG.SYS to enable NTFS support.

Windows FAT32

FAT32 is an enhancement to FAT that first appeared in Windows 95 OEM Service Release 2 packages (OSR2).

OS2FAT32 is an installable file system that handles FAT32 partitions in OS/2. It works with Warp v 3, 4 and WSeB/eComStation. OS2FAT32 also handles extended attributes for files created on FAT32 partitions. OS2FAT32 has the following limitations:

  • It only supports non-removable harddisks.
  • It only supports disks with a sector size of 512 bytes. (Are there others?)
  • You cannot BOOT from a FAT32 partition.
  • You cannot place the SWAPPER.DAT on a FAT32 partition.
  • CHKDSK can diagnose a disk, but will only FIX lost clusters and an incorrect free space count. For all other errors, you'll need to run Windows95 and start scandisk to fix the problem. Note: CHKDSK will always convert lost clusters to files and NEVER to directories. if you want that, use SCANDISK.
  • The FORMAT, RECOVER and SYS commands are not supported.
  • Only last access date (and not last access time) is maintained by FAT32.IFS. This is similar to Win95 (OSR2).
  • Long filenames are not by default supported in DOS and Win-OS/2 sessions, they use only the short names although this can be changed by a parameter, with some side effects.

Linux Ext2

Ext2 is Linux's native file system. EXT2-OS2, written by Matthieu Willm, is an installable file system that allows OS/2 to access Linux Ext2 partitions. It is a very complete and full featured file system with the main features being:
  • full 32-bit ring 0 implementation
  • allows read-write access to Linux ext2 partitions
  • allows OS/2 to swap on Linux ext2 partitions
  • allows OS/2 to boot from a Linux ext2 partition
  • supports huge cache sizes
  • contains a port of most of the Linux ext2 file system utilities from the e2fsprogs-1.10 package:
    - mke2fs, to format drives as Linux ext2
    - e2fsck, to check and repair Linux ext2 file systems
    - tune2fs, to change Linux ext2 file systems parameters
    - debugfs, an interactive Linux ext2 file system debugger
    - lsattr and chattr, to see or change attributes of files on Linux ext2 file systems
  • can reorder all hard disk drive letters, to avoid partition headaches
  • hard links are supported under OS/2 and can also be created from OS/2

The Linux/Unix file system has a number of features that are not duplicated in OS/2 (except through the Toronto IFS): symbolic links, permissions and user access control, plus file names are case sensitive in Linux where they are not in OS/2. Also the Linux Ext2 file system does not support extended attributes, which OS/2 makes extensive use of, especially in the Workplace Shell. Ext2-OS2 makes the best try possible to smooth over those differences but there will always be some potential problems when trying to marry different file systems.

Apple HFS

Hierarchical File System is used by Apple. There are two ways of access HFS files:
  1. HFS/2, which is an HFS installable file system allows OS/2 machines to read, write and format Apple diskettes, as well as read HFS CD-ROMS.
  2. HFSUTIL, which is a set of utilities for working with HFS diskettes. The utilities include hformat, hmount, hdir, hcopy, etc.

Both of those packages are older and have not been updated in a while.

Remote File Systems

Remote file systems is the category I have created for software that makes disk storage on other machine available to use on your machine. This includes local area networking, which I am not covering, even though it is implemented with an installable file system.

Network File System

NFS is a protocol developed by Sun Microsystems that provides transparent remote access to shared files across networks - in other words a Unix version of a LAN. The HFS protocol is designed to be portable across different machines, operating systems, network architectures and transport protocols. NFS is built on a client-server model. The server is the machine holding the actual file and the client is the machine accessing the file.

OS/2 can act as both a client and a server for NFS. When acting as a client the remote NFS shares are "mounted" as a drive letter on the OS/2 machine. Once mounted a NFS share is treated just like any other drive in OS/2 and can even be shared on the LAN for use by other machines - which could present interesting security implications.

The NFS package for OS/2 is bundled in TCP/IP. It was available in OS/2 Warp Connect and in various TCP/IP stand-alone packages sold by IBM. It is now included in WSeB and eComStation. There is also plug-in for Netdrive will also act as an NFS client.

Andrew File System

The Andrew File System also is a distributed remote file system for sharing files across a network of computers. It was developed at Carnegie Mellon University to be the Arnold Schwarzenegger of distributed file systems. AFS is built around the concept of cells, a cell being a collection of servers grouped together administratively and presenting a single, cohesive filesystem - similar to the concept of a domain in a LAN.

AFS incorporates a local cache (either disk or RAM) to speed up file access, better security than NFS, and distributed read-only files that speed up access and provide fault-tolerance when one server goes down. The protocol used by AFS is designed for wide area networks (retransmits only bad packets, allows more unacknowledged packets.)

OS/2 can act as an AFS client with the AFSOS2 package. AFS has been moved into the Open Source world just like JFS and the main web site is oss.software.ibm.com/developerworks/opensource/afs.


Samba really isn't an OS/2 feature or product, but it is worth mentioning here in the section on Remote File Systems. SAMBA is a application on Unix machines that allows OS/2 and Windows machines to access files from the machine using normal LAN type facilities. SAMBA recognizes the protocol used by LAN Server and LAN Manager products which allows OS/2 and Windows machines to connect to a SAMBA server much like they do to a LAN server. Since Unix machines don't use the NETBIOS protocol the client machines have to use NETBIOS over TCP/IP protocol in order to communicate with a SAMBA server.

Samba Installation, Configuration and Sizing Guide
Implementing Linux on Your Network using SAMBA


There are two packages that provide an installable file system FTP function:
  1. FTPIFS by Vit Timchshin
  2. The FTP plug-in that is included as part ofNetdrive

I own the FTPIFS package so that is the one I will describe here. The FTPIFS package consists of a IFS driver and a couple of other programs the work with the IFS. The user interface is provided by the FTPFS.EXE program. You use that to map a FTP host as a drive letter, much like the NET USE command. For example

ftpfs use X: ftp//dgclark:mypassword@

would map the host as my X drive, using dgclark as the user ID and mypassword as the password. You can specify a default user ID and password in the CONFIG.SYS.

Since drive letters can become a scarce commodity FTPIFS has something called a meta drive, which basically assigns the drive letter to FTPIFS and uses directories of that drive to represent each FTP host. This allows you to connect to multiple FTP hosts simultaneously without consuming multiple drive letters. (This is the exact same concept that Netdrive uses.)

FTPIFS works through proxies, both FTP and HTTP proxies.

If you work a lot with FTP this can be a life saver. I have used FTPIFS when developing a web site on a Linux machine. FTPIFS allowed me to use EPM to edit HTML files that resided on the Linux server.


SRVIFS is a small IFS used for communicating between machines.The most interesting use I have seen of this IFS is someone who used this to install Warp 4 on a laptop via the parallel port. Some laptops, especially older ones, cannot have the floppy drive and CD-ROM drive installed at the same time. This fellow used SRVIFS to access the Warp 4 installation CD from his laptop using a Laplink cable through the parallel port. This allowed him to keep the floppy drive in the laptop so that he could use that to boot the installation disks. This procedure is described in members.iquest.net/~jlrowe/parinst.htm. Note - the thing that is not clear from this description is that the parallel port driver is included in MPTS that comes with OS/2.

RAM Based

This is the category for RAM drives, a virtual drive stored entirely - more or less - in RAM.


VDISK is not really an IFS but rather a device driver. It is included as part of OS/2. VDISK simulates a hard drive in memory. It has a maximum drive size of 32MB, and the size of the drive you create is allocated from RAM the entire time the machine is booted. The file system used on VDISKs is FAT.


RAMFS and RAMFS64 is a virtual disk that operates somewhat differently than VDISK. Where VDISK allocates the entire drive amount from RAM, RAMFS and RAMFS64 only allocate the space needed to hold the files stored on the virtual drive. The memory is allocated from normal OS/2 memory, meaning that it is swapped; the memory used by VDISK is never swapped out.

I have never used either product and as far as I can tell the only difference between RAMFS and RAMFS64 is the amount of free space reported for the drive; RAMFS64 reports 64MB and RAMFS reports 2 MB. Since there is no limit on the size of virtual disk created by either package the free space reported is just an arbitrary number.


VFDISK is a package that creates a virtual floppy drive in RAM. This is useful for those occasional older applications that insist on being installed from a floppy drive (like Lotus Improv) and for older fix packs that needed to be run from a floppy drive. It is IBM employee written software and is available at vfdisk20.zip


SVDisk is a shareware product that combines the features of VDISK, RAMFS and VFDisk, i.e. it is a virtual disk that allocates and frees memory as files are added and deleted from the "drive" just like RAMFS, and it also can emulate a floppy drive, like VFDisk. The memory used by SVDISK can optionally be pegged so that it does not get swapped out, like VDISK.


There are three products in this category that use the concept of a drive letter for encrypting files. All work the same way. An IFS is used to create a drive letter that represents encrypted data. The drive letter is mapped to a real drive and directory on the system. If you copy files to the IFS drive letter the files are automatically encrypted, and if you access files on that drive letter the files are automatically decrypted. This is shown in more detail in the AEFSOS2 section below.


To create an AEFS volume using the default block cipher algorithm (Rijndael, with a 128-bit key size), type

mkaefs <path>

which will create a volume in path (that is, the ciphertext will be stored in path). It will ask you to (twice) enter the encryption key to be used for this volume. Don't forget the key! The key should be sufficiently hard to guess and may be of any length. (The key you enter is not actually the encryption key: it is hashed using SHA-1 into a key with the length expected by the block cipher).

For example,

mkaefs c:\crypto

will make a volume in c:\crypto.

To access the volume, you must attach ('mount') it to a drive letter. This can be done by typing

mntaefs <drive-letter>: <path>

The program will then ask you to enter the encryption key.

For example,

mntaefs x: c:\crypto

will attach the volume created in the previous example to the drive letter X. You can now access the encrypted data in c:\crypto trough drive X. Any data you write to or read from drive X will be encrypted and decrypted transparently by AEFS.

When you are done using the encrypted volume, you can type

umntaefs <drive-letter>:

to detach it.

AEFOS2 is available at aefos2.zip.


Carbon Based Software also make a very similar commercial product called CryptStream. It is a companion product to their ZipStream. For more info see www.zgc.com/carbon/csinfo.htm

Cipher Plug-in for Netdrive

Netdrive is described below in the Misc section. The Cipher plug-in encrypts and decrypts files stored in the Netdrive file system.


Audio/Video Data

Tonigy is an Audio/Video CD IFS for OS/2 that maps tracks of Audio CD's into WAV or RAW files and tracks of video CD's into MPG files. Use it for accessing audio and video tracks like ordinary files. Its main features are:
  • IFS for OS/2
  • represents audio tracks as WAV or RAW files
  • represents video tracks as MPG files
  • easy control and setup by PM GUI panel
  • English/German interface and documentation
  • supports extended attributes (reading/writing)
  • supports adaptive Anti-Jittering for reading audio sectors
  • "Highest Priority" option for slow CD-ROM drives and PCs

CD Juke-Boxes

CDFILE/2 is an installable file system that handles CD juke boxes. It assigns a single drive letter to the juke box and creates subdirectories for each CD in the juke box.

RSJ CD-Writer

RSJ CD-Writer is an excellent commercial product for CDRW drives. It consists of an IFS and a number of other programs that turn the CDRW into a drive in OS/2. Once the CDRW is "attached" it becomes a drive letter just like any other, and you can use all the normal OS/2 facilities for copying files to and from the CDRW. The unique feature of the RSJ product is that you can copy files onto a CDRW, and use that CDRW in a normal CD-ROM drive just like a regular CD - most applications that write to CDRW do not format the CDRW so that it can be read by regular CD-ROMs.

Removable Optical Drives

IBM's High Performance Optical File System (HPOFS) is an installable file system for removable optical drives. Those drives have been made obsolete by CDR, CDRW and DVDs. It is available at hpofs20.zip


This category has all the stuff that I could not fit into the other categories.

Toronto Virtual File System

The Toronto Virtual File System (TVFS) is an OS/2 Installable File System that combines VM and Unix file system concepts. The specific VM file system concept employed is the "CMS search path". The specific Unix file system concepts employed are the "symbolic link" and file/directory permissions for read and write (remember that HPFS386 also implements file and directory permissions.)

Under VM a user may mount (access) a minidisk. Each minidisk may contain a set of files in a flat (non-hierarchical) name space. A number of minidisks may be mounted in a specific order. The order of the minidisks determines the CMS search path. For example, if the user wants to find the file foo.c, the minidisks will be searched according to the CMS search path. The user will be given the first instance of foo.c found.

On Unix, symbolic links are conceptually similar to shadows of objects on the OS/2 desktop. A symbolic link is a file object, or a directory that doesn't really exist but rather points to another file somewhere on the system. When you access the symbolically linked file you are really accessing the file that is pointed to - the linked file.

TVFS is a freely available IBM employee written software package. There are a couple of complementary packages that go help TVFS: TVFSCC10 is a PM based manager package for configuring and administering a TVFS_RM is a package that allows TVFS to handle removable media and remote drives.

Digital Cameras

For the Hewlett-Packard PhotoSmart C200 digital camera there is an IFS that is implemented as a Netdrive plug-in, which means that you can transfer and manipulate photos on the camera by using the Drive Object in the Workplace Shell - or Command Window commands.

While this is not an installable file system, there is also an application called DCITU which communicates with a number of digital cameras.

Finally there is gPhoto2, a Unix port that requires Xfree86, see http://www.gphoto.org for information.


The Psion is a PDA. There are two ways of interacting with the Psion
  1. Psion utilities which a method for working with files on Psion series 3/3a/3c/5 and Siena machines from OS/2
  2. a IFS for the Psion - implemented as a plug-in to Netdrive.

The Psion utilities include:

  • PATTRIB.EXE - Utility to set/list attributes of files on the Psion
  • COPYFR.EXE - Utility to copy files from the Psion to your PC
  • PCOPYON.EXE - Utility to copy files within your Psion
  • PCOPYTO.EXE - Utility to copy files from your PC to the Psion
  • PDEL.EXE - Utility to delete files on your Psion
  • PDIR.EXE - Utility to list files on a drive on the Psion
  • PMD.EXE - Utility to create directories on your Psion
  • PRD.EXE - Utility to remove directories from your Psion
  • PREN.EXE - Utility to rename files on your Psion
  • PTYPE.CMD - Utility to type files from your Psion to the display
  • PWAIT.EXE - Utility to synchronize processes

The Psion IFS is a Netdrive plug-in and makes the Psion appear as a drive on OS/2.


ZipStream is a commercial installable file system which creates a compressed drive in OS/2. Everything copied into the drive is automatically compressed, and everything moved or copied out of the drive is automatically decompressed. See www.zgc.com/carbon/zsinfo.htm for more information.

Hardware RAID

Although this is not exactly an installable file system it seems appropriate to mention RAID here, especially with the RAID-1 function built into HPFS386. Perceptive Solutions makes a SCSI controller that handles RAID-1, 5, & 10 in hardware with drivers for OS/2.


Netdrive is an unusual animal. It is a cross between a IFS manager and an API that is used by others to write what would normally be installable file systems. This API is used by developers to write plug-ins for Netdrive. Each plug-in is what would normally be its own installable file system. Netdrive loads and unloads the plug-ins which allows the plug-ins to be dynamically loaded without rebooting the machine.

Currently there are plug-in for: FTP, NFS, VFAT, Psion, HP digital cameras, an encrypted drive, and ISO-9660 CD images. Some of the plug-ins are free and some are shareware.

There is a brief review of Netdrive and the Psion plug-in OS/2 eZine, and the Netdrive web site. While the documentation for Netdrive is very skimpy, it is a very exciting product and has spawned a number of new plug-in/IFSes in a relatively short period of time.


The concept of installable file systems allows OS/2 to keep abreast with the latest changing storage and communication needs without rewrites of the operating system or new releases of OS/2. There are a multitude of third party IFSes and other related utilities for OS/2, most of which are free, that greatly expand the utility and scope of OS/2. With these you can modify the OS/2 file system to add Unix like capabilities, incorporate shares from other machines on the WAN using a number of protocols, attach your PDA or digital camera as a drive, or encrypt sensitive information. While you can't play DVD movies on OS/2 yet, in just about every other aspect OS/2 is fully the equal of the Windows steamroller. And in some ways, e.g. JFS, it is superior. IFSes help OS/2 stay abreast of the latest storage developments.

Previous Article
Next Article

Copyright (C) 2002. All Rights Reserved.