
       => For the latest changes in FAT32.IFS please look <=
       => at the bottom of this file.                     <=



                        === DISCLAIMER ===


I allow you to use all software in this package freely under the condition
that I am in no way responsible for any damage or loss you may suffer.

        >> You should be aware of the fact that FAT32.IFS might <<
        >> damage the data stored on your hard disks.           <<

If you cannot agree to these conditions, you should NOT use FAT32.IFS !



I CANNOT guarantee that FAT32.IFS will work for you. However I've done
my best to test the program and I can only say that It works for me.


Henk Kelder
hkelder@capgemini.nl 
Certified daddy (by my kids)

My homepage for the latest version: 

  http://www.os2ss.com/information/kelder/index.html


FILES IN THIS VERSION
=====================

FAT32.TXT               This file.
PARTFILT.TXT            A textfile about PARTFILT.FLT and DISKINFO.EXE

FAT32.IFS               The actual IFS.
CACHEF32.EXE            The cache helper program.
UFAT32.DLL              The module needed to run CHKDSK on FAT32 partition.
F32STAT.EXE             A program to change the DIRTY flag of FAT32 partitions.
MONITOR.EXE             A program to monitor what FAT32.IFS is doing.

PARTFILT.FLT            A general partition filter device that allows FAT32
                        partitions to be recoqnized by OS/2. 

OS2DASD.F32             A modified version of OS2DASD.DMD that is an
                        alternative for using PARTFILT.FLT. This modified
                        driver also allows FAT32 partitions to be recoqnized 
                        by OS/2. If you want to try this please rename it to
                        OS2DASD.DMD and place it in your OS2\BOOT directory.
                        Remember to make a backup copy of the orginal!

                        PLEASE NOTE: that this driver is NOT at the latest 
                        level and will probably NOT support the latest 
                        features like removable disks etc.

DISKINFO.EXE            A diagnose program that will scan for and show
                        all partitions. 

LIMITATIONS
===========

This version of FAT32.IFS 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 similiar to Win95 (OSR2).

- Long filenames are not by default supported in DOS and Win-OS/2 sessions, 
  they use only the shortnames. 
  Please see 'LONG FILENAMES IN OS/2 AND DOS SESSIONS' later is this file.

- You'd better NOT change codepages on the fly IF you have open files with
  filenames that contain extended ASCII characters.

- If you are using PARTFILT.FLT then FDISK, Partition Magic or any partition
  maintenance tools will show non-existing drives and other nonsense.

- This version needs the native NLS support from OS/2. 
  This means Warp 3 fixpack 26 or higher or Warp 4.
  (You must have the LANGUAGE directory)

QUICK INSTALL:
==============
(x: should be replaced by your boot drive.)

Copy the following files to your \OS2 directory:
FAT32.IFS
CACHEF32.EXE
F32STAT.EXE 
MONITOR.EXE

Copy the following file to your \OS2\DLL directory:
UFAT32.DLL

(Skip the next lines if you are using Warp Server for eBusiness)
Copy the following file to your \OS2\BOOT directory:
PARTFILT.FLT 

=>Do NOT REPLACE your current OS2DASD.DMD with the version in the archive,<=
=>before you have read the remarks below about OS/2 and FAT32 and know you<= 
=>MUST use this DMD. You probably do NOT NEED IT!                         <=

Make the following changes to the CONFIG.SYS:

IFS=x:\OS2\FAT32.IFS [options, see below]  
(Install this one AFTER IFS=HPFS.IFS)

CALL=x:\OS2\CACHEF32.EXE [options, see below]
^^^^-> Make sure this is a CALL and NOT a RUN.

(Skip the next lines if you are using Warp Server for eBusiness)
BASEDEV=PARTFILT.FLT /P 0B [/W] 
(The /W should not be specified if you do not want write access)
(The best location seems to differ depening on your configuration. Some
state FAT32.IFS will only work is PARTFILT is the first basedev, other 
claim it only works if PARTFILT is the last one.)

=>This Quick Install will add FAT32 partition after all existing drives!  <=

=>PARTFILT.FLT might need other options IF you have converted an existing <=
=>FAT16 partition to FAT32 or if you want to influence the drive order!   <=


FAT32.IFS
=========

FAT32.IFS is the actual Installable File Systems driver.
The following options are supported:

/Q           Quiet, not messages.

/CACHE:nnnn  specifies the cache size in kilobytes. If omitted the default
             cache size is 1024KB. Maximum cache size is 2048KB.
                                     *NOTE*
             Cache memory is allocated as FIXED memory, so if you have less
             than 16MB I suggest you set this option to 512KB or less.

/MONITOR     Set monitor ON by default. If omitted monitor is OFF. See 
             MONITOR.EXE for more information.

/RASECTORS:n Read Ahead Sectors.
             Specifies the minimum number of sectors to be read per read
             action and placed in the cache.
             If omitted the default differs per volume and equals the 
             number of sectors per cluster times 2. 
             The maximum treshold value used is the number of sectors per 
             cluster times 4.

             You should note that the actual sector IO per read action is
             NOT determined by an application, but by the IFS. For FAT access
             single sector reads are done. For Directory and Files IO reads
             are done on a cluster base. By setting the RASECTORS you can 
             define the minimum number of sectors the IFS will read from disk
             and place in the cache.

/EAS         Make FAT32.IFS support EXTENDED ATTRIBUTES.


CACHEF32.EXE
============

CACHEF32.EXE is a helper program with the following functions:
- Check DISK state on boot, run CHKDSK if needed.
- Start the LAZY WRITE daemon.
- Set CACHE and READ-AHEAD parameters.
- Set Longname behaviour.
- Load a CP to UNICODE translate table for longnames and the default 
  codepage.

When run in the foreground and CACHF32 is already running, it displays
the CACHE parameters and allows you to modify the values. If no other
copy of CACHEF32 is running, it detaches a background copy.

When run in the background (detached), CACHEF32 will act as lazywrite daemon.

CACHEF32.EXE supports the following options:

/?    Shows help.

/Q    Terminates CACHEF32. CacheF32 will be unloaded from memory, lazy
      writing will stop. (Performance will degrade).

/N    Runs CACHEF32 without starting the deamon in the background.

/D:nn Sets the DISKIDLE value. See OS/2 online help on CACHE.

/B:nn Sets the BUFFERIDLE value. See OS/2 online help on CACHE.

/M:nn Sets the MAXAGE value. See OS/2 online help on CACHE.

/R:d:,n Set RASECTORS for drive d: to n.

/L:ON|OFF Set lazy writing ON or OFF, default is ON

/FS   Use short names internally.
/FL   Use long names internally (default).
(see LONG FILENAMES IN OS/2 AND DOS SESSIONS below)

/P:1|2|3|4 Set priority for lazy writer. 1 is lowest, 4 is highest. 
      Default 1 (= idle-time). This might be handy if the lazy-writter 
      doesn't seem to get any CPU due to heavy system load.

Note 1: the /T option has been removed in version 0.83.

Note 2: if you notice that the /P options has any effect on your 
        situation please let me know.

CHKDSK & UFAT32.DLL
===================

The UFAT32.DLL is called by CHKDSK whenever the CHKDSK command is issued
for a FAT32 drive. UFAT32.DLL currently only supports CHKDSK.

For CHKDSK the following options are implemented:
/F   Fixes problems (Currently UFAT32.DLL only fixes lost clusters,
     and an incorrect free space count.)
/C   Causes lost clusters to be automatically converted to files if the
     drive was in an inconsistent state at boot (No questions asked).
/V:1 Causes CHKDSK to show fragmented files.
/V[:2] Causes CHKDSK to show details on all files checked.(default)

The CHKDSK process does the following checks:
- Compares all copies of the FATs;
- Checks for each file the file allocation;
- Checks per file or directory the VFAT long filename;
- Checks for, and if /F is specified, repairs lost clusters.
- Checks for, and if /F is specified, repairs cross-linked files.
- Checks free space, and if /F is specified, corrects an incorrect setting.
- Checks for lost extended attributes.


F32STAT.EXE
===========

F32STAT can be used to query the clean shutdown state of a FAT32 drive. 
It also allows you to alter the clean shutdown state. You could use this
feature if FAT32.IFS blocks access to the disk because it is dirty on boot,
and CHKDSK could not solve the problem.

The syntax is:

   F32STAT drive: [options]

The following options exist:

/CLEAN  - Inform FAT32.IFS that the disk was clean on boot and may be used. 
          The disk itself will be marked as clean on a succesfull shutdown. 
          (The internal dirty flag FAT32.IFS uses will be cleared.)

/FCLEAN - Inform FAT32.IFS that the disk was clean on boot and may be used.
          The disk itself will also be marked as clean at that moment. 
          (The internal dirty flag FAT32.IFS uses will be cleared, but the
          marking on disk will also be set ok.)
          
/DIRTY  - Inform FAT32.IFS to set its internal dirty flag, and mark the drive
          dirty on disk. On shutdown the drive will be left dirty, so when
          booting Windows 95 (OSR2) SCANDISK will be fired.


MONITOR.EXE
===========

Monitor will show (most) FAT32 actions on screen. This program is intended
for troubleshooting. Using MONITOR will degrade performance since FAT32 must
send monitoring information to an internal buffer. This internal buffer is 
only 4096 bytes large, so if monitoring is on, but MONITOR does not run,
logging information is lost. This will however only occur if /MONITOR is
specified after the IFS= line for FAT32.IFS.

If the /MONITOR command is not specified in the config.sys after the IFS=
statement monitoring is OFF by default, but starting MONITOR once will 
activate monitoring.

When MONITOR runs, information is shown on the screen, but also written to
FAT32.LOG in the current directory.

When MONITOR terminates the internal montoring is switched off.

the syntax for monitor is:

MONITOR [tracemask] [/S]

If tracemask is omitted it is set to 1. 

The tracemask exists of a specific bit to show certain types of information.
This way, you can MONITOR selectively.

The following values for tracemask exist:

 1 - Shows all calls to FS_xxxxx entry points and the returnvalues
 2 - Shows additional (internal) function calls
 4 - Shows cache related (lazy writing) function calls
 8 - Shows internal memory handling (malloc & free) memory calls
16 - Shows FS_FINDFIRST/FS_FINDNEXT calls
32 - Shows some other calls
64 - Shows extended attribute handling

You should add values to see multiple groups:

e.g.
You want to see both FS_xxxx calls and cache related information. As 
tracemask you should use 1 + 4 = 5.


/S   - Runs without output to the screen, but only to FAT32.LOG. This is
       usefull if MONITOR sends so much messages to the screen that the 
       program can't keep up with the IFS. Using /S only sends the output
       to FAT32.LOG so no time is lost in screen handling.




GENERAL NOTES
=============

MAKING OS/2 RECOQNIZE FAT32 PARTITIONS.
---------------------------------------
OS/2 by itself does not recoqnize FAT32 partitions. This means that 
installing the IFS is useless if we can't make OS/2 recoqnize them.

Currently, if you are using WARP 3 or 4 there are two ways to achieve that.
- Use PARTFILT.FLT to fake FAT32 partition; (this is advised)
- Use the modified version of OS2DASD.DMD. (Rename OS2DASD.F32 to OS2DASD.DMD)

If you are using Warp Server for e-Business (AURORA) you must use the LVM to
create a Compatible volume. Do not try to use PARTFILT or the modified 
OS2DASD.DMD with this version of OS/2.


OS2DASD.DMD
-----------

The version of OS2DASD.DMD (called OS2DASD.F32) supplied in this package is 
a modified version of this driver and is NOT at the latest level. 
This means that it is possible that some of the latest features in the 
IBM supplied driver may not be supported. Also, when installing new 
fixpacks, you should make sure that this version of OS2DASD.DMD is 
not replaced.

Also, when using this driver, FAT32 partitions COULD end up having a drive
letter assign before the OS/2 partition, shifting the assigned drive letters
for all next partitions up and thus making OS/2 unbootable.

This version of OS2DASD.DMD has extra support for partition type 11 (hex B).
Partition type 12 (hex C), FAT32 through INT13 is NOT supported by this 
driver.

Generally, it is not advised to use this version of OS2DASD.DMD, but to 
use the PARTFILT.FLT.


LONG FILENAMES IN OS/2 AND DOS SESSIONS
---------------------------------------
In the initial release long file names where only shown in OS/2 sessions, but
in DOS sessions, the short filename equivalent was shown.

This could however lead to big problems. An example:

In in an OS/2 session directory \DevStudio was current, from a DOS session
the directory \DEVSTU~1 could be removed since OS/2 didn't know that 
DevStudio and DEVSTU~1 were infact the same directories.
 
The same problem could occur when opening files in both OS/2 and DOS. 
No proper multiuser handle would take place since OS/2 doesn't know that
files with different names are the same.

To solve this problem I've done the following:

Via a setting FAT32.IFS can be told to:
- Translate all long filenames internally to their short equivalences OR
- Use the long names internally, but hide all files or dirs with long names
  from DOS sessions.
This setting can be changed (on the fly) with CACHEF32.EXE.

When using short names internally the following drawbacks occur:
- Current directory is shown as a short name (command line only)
- When deleting (long) files from the command line, the WPS doesn't 
  pickup the deletions.

When using long names internally the following drawbacks occur:
- Files and directories with long names are not visible in DOS sessions.
  This is however the same as with HPFS.


WINDOWS & OS/2 CHARACTER SETS
-----------------------------
OS/2 uses standard character sets. Such a character set is called a CODEPAGE.

By default Windows long file names (VFAT) are stored in UNICODE.

Since Warp 3 (fixpack 26?) OS/2 contains NLS support. 
CACHEF32.EXE now calls this NLS support to create a CP to UNICODE translate 
table during startup of your system.

Keep in mind that a table for only ONE codepage is loaded. Should you change
codepages (using CHCP) you must rerun CACHEF32 to load a new table, but keep
in mind OS/2 keeps different codepages per session so if you use CHCP to 
change the CP that CP is only only valid for that session.


CLEAN SHUTDOWN & CHKDSK
-----------------------
If Windows 95 (OSR2) shuts down properly, the clean shutdown status of the
disk is physically written on the disk. On next boot this state is checked,
and if the disk is not shutdown properly, SCANDISK is run.

FAT32.IFS also supports this feature. When CACHEF32 is called from the 
config.sys, it checks, via a call to the IFS the state of each FAT32 drive.
For each drive that is not shutdown properly, CHKDSK is fired. If no errors 
are found, or if only lost clusters where found and repaired, the drive is 
marked ok. 

If CHKDSK cannot solve the problem, the drive state is left dirty, and
NO FILES CAN BE OPENED AND NO DIRECTORIES CAN BE ADDED OR REMOVED. 
Shutting down the disk, leaves the disk marked as not properly shutdown.
You should boot Windows 95 and run SCANDISK on the drive to fix the 
remaining problems.

F32STAT however, allows you for set the drive status, bypassing the normal
handling of FAT32.IFS. See the description of F32STAT for more information.


FREE SPACE
----------
On most FAT32 drives the amount of free space is stored. FAT32.IFS will only
redetermine the amount of free space if:
- The disk was marked dirty on boot;
- The free space is set to -1 on the disk;
- The free space is not available on the disk.

FAT32.IFS will internally keep track of the free space and update it on disk 
on shutdown.


PERFORMANCE
-----------

All of the code is in plain 16 bits C (All of OS/2's IFS's are 16 bits!). 
No assembly language code is used.

The MONITOR function takes a lot of time. Be sure to switch if off if you don't 
need it.

You should probably experiment with the CACHEF32 options to get the best 
performance for your situation. 

The default for the LAZY WRITER is idle-time priority (/P:1). 
You'd might like to experiment with the /P option as well, especially if you
have performance problems with FAT32.IFS.

For best performance it is advised to keep the disk as defragmented as 
possible. Use Windows 95 defrag to defrag the disk.


COMPATIBILITY WITH WINDOWS95
-----------------------------

As far as I can tell, FAT32.IFS is fully compatible with the FAT32 support
in Windows 95. VFAT longnames can be used and on my PC, Windows95 doesn't
compain (anymore!) about long filenames I have created with FAT32.IFS.
The numeric tailed short names also seem to work ok. (The numeric tail option
cannot be switch off!)

File names are, as in Windows95, case preserving (in OS/2 sessions).
Creating a name in lower case will result in the file having a VFAT longname,
even if the name conforms to 8.3. The case will be preserved.

Last access dates are maintained by FAT32.IFS. 
(but not the last access time since Win95 doesn't support it)
You can see these when using the detailed view of the drive object.


EXTENDED ATTRIBUTES
-------------------

General
-------

Since version 0.70 FAT32.IFS supports EXTENDED ATTRIBUTES.

For FAT32.IFS to support Extended Attributes /EAS MUST be specified after
the IFS=....\FAT32.IFS line in the config.sys.

Extended Attributes are implemented in the following manner:

For each file or directory that has extended attributes a file is created 
with a name that consists of the file or directory name the EAs belongs to 
followed by ' EA. SF'. So if a file called 'FILE' has extended attributes 
these attributes are stored in a file called 'FILE EA. SF'. 
These EA files are given the hidden, read-only and system attributes.

FAT32.IFS will not show these files in a directory listing, but Windows 95 
can show them.

The mark byte
-------------

Also, to speed things up a bit, each file having extended attributes is 
marked by FAT32.IFS. For this mark an appearant unused byte in the directory 
entry is used. The value for this byte is set to 0xEA for files having 
normal EAs, to 0xEC for files having critical EAs, and to 0x00 for files 
not having EAs at all.

(Please note that files with critical EAs can not be opened by programs
no able to handle EAs, like DOS programs.)

This byte (directly following the files attribute) is not modified while
running Windows 95 and neighter by SCANDISK or DEFRAG, but theoretically, 
other programs running under Windows 95 could modify it.

If another program sets the value to 0x00 for a file that has EAs these EAs
will no longer be found using DosFindFirst/Next calls only. The other OS2 
calls for retrieving EAs (DosQueryPathInfo, DosQueryFileInfo and 
DosEnumAttribute) do not rely on this byte.

Also the opposite could, again theoretically, occur. Files not having EAs 
could be marked as having EAS. In this situation only the performance of
directory scans will be decreased.

Both situations however are checked and if necessary corrected by CHKDSK.


The drawbacks 
-------------

Currently, the drawback of using Extended Attributes is that directory 
scan performance has slightly decreased. 

The overhead on opening or accessing individual files is hardly noticable.

If you do not really need extended attribute support then simply do not
specify /EAS after the IFS line in the config.sys.

The advantages
--------------

The advantages of FAT32.IFS supporting extended attributes are:
- The WPS heavily uses EAS to store folder and file settings. Without EAS
  the WPS will not remember settings across boots.
- REXX .CMD files must be tokenized on each run, thereby reducing performance.
  With EAS the tokenized version of the .CMD will be stored in EAs.


If you can live with the small loss in performance while doing directory 
scans it is advised you specify /EAS after the IFS line in the CONFIG.SYS.

If you do not really need extended attribute support and you cannot accept
the decrease in directory scan performance then simply do not specify /EAS 
after the IFS line in the config.sys.


IOCTL SUPPORT
-------------
IOCTL calls (category 8) are now passed through to OS2DASD. All calls
supported by OS2DASD.DMD are now also supported by the IFS.


TROUBLESHOOTING
===============

Should FAT32.IFS fail to work, please check the following:

- Is a new drive letter assigned ? (If not OS2DASD.DMD failed)
  If not, tell me.
- If you are not sure, try the /MONITOR parameter after FAT32.IFS,
  and after reboot look with monitor for FS_MOUNT calls. Send me 
  the results.
- If a new drive letter is assigned, but FAT32.IFS fails,
  please run DISKINFO and send me the output.
- If you have a TRAP, please send me the CS:IP value of the trap.

If you have a program that doesn't work or returns errors, please run 
monitor.exe while you execute the program. After the error has occured, 
terminate monitor and send me a message describing what the problem is, as 
detailed as possible and include the FAT32.LOG that was created by monitor.


SUPPORTED IFS FUNCTIONS
=======================
FS_ALLOCATEPAGESPACE    : No
FS_ATTACH               : No
FS_CANCELLOCKREQUEST    : No, function is implemented in the KERNEL
FS_CHDIR                : Yes
FS_CHGFILEPTR           : Yes
FS_CLOSE                : Yes
FS_COMMIT               : Yes
FS_COPY                 : Partly, unsupported actions are simulated by command shell
FS_DELETE               : Yes
FS_DOPAGEIO             : No
FS_EXIT                 : Yes
FS_FILEATTRIBUTE        : Yes
FS_FILEINFO             : Yes
FS_FILEIO               : No
FS_FILELOCKS            : No, function is implemented in the KERNEL
FS_FINDCLOSE            : Yes
FS_FINDFIRST            : Yes
FS_FINDFROMNAME         : Yes
FS_FINDNEXT             : Yes
FS_FINDNOTIFYCLOSE      : Obsolete in OS/2 WARP
FS_FINDNOTIFYFIRST      : Obsolete in OS/2 WARP
FS_FINDNOTIFYNEXT       : Obsolete in OS/2 WARP
FS_FLUSHBUF             : Yes
FS_FSCTL                : Yes
FS_FSINFO               : Yes
FS_INIT                 : Yes
FS_IOCTL                : Yes - LOCK & UNLOCK, others are passed to OS2DASD.
FS_MKDIR                : Yes
FS_MOUNT                : Yes
FS_MOVE                 : Yes
FS_NEWSIZE              : Yes
FS_NMPIPE               : No
FS_OPENCREATE           : Yes
FS_OPENPAGEFILE         : No
FS_PATHINFO             : Yes
FS_PROCESSNAME          : Yes
FS_READ                 : Yes
FS_RMDIR                : Yes
FS_SETSWAP              : No
FS_SHUTDOWN             : Yes
FS_VERIFYUNCNAME        : No
FS_WRITE                : Yes


HISTORY
=======

Version 0.10  - Initial Version

Version 0.20 
- Cache routines have been improved for performance. Removing 'old' sectors
  from the cache is no longer needed. /T option for CACHEF32 has been 
  removed.

- CHKDSK: Is now able to fix incorrect free space count.
- CHKDSK: Lost cluster fix algoritm has been improved for performance.
- CHKDSK: Didn't recoqnize bad-sectors, has been fixed.
- CHKDSK: Had problems with recoqnition of some type of free clusters,
          has been fixed.
- OS2DASD.DMD: Is now based on the latest version. (December '97)

Version 0.30

- Added PARTFILT.FLT to the archive.
- Added support for ReadOnly partitions. This is needed for PARTFILT.
- IOCTL Calls (category 8) are now passed throught to OS2DASD.


Version 0.40
- The volume label was retrieved from the boot sector. However Win95
  actually stores the Volume label in the root directory. The Volume label
  now is taken from the root directory.
  Also, the label can be set now. (The boot sector is however still updated)

- /Q switch of PARTFILT didn't work. Now it does.

- A problem was in CHGFILEPOINTER that could (theoretically) lead to an
  trap (FAT32: FS_WRITE: No next cluster available").

- Corrected a logical error where renaming a file or directory to an existing
  directory caused the file or directory to be moved into the target 
  directory. Now FAT32.IFS returns an error.

- Changed CHKDSK so that if an error is found in on of the FATs CHKDSK 
  continues, but ignores the /F switch. Previously, CHKDSK would not do any
  additional checks.

- Renaming a file or directory from the workplace shell didn't work because 
  of two problems: 
    - the WPS uses a strange algoritm to determine if the IFS supported
      long file names which appearantly failed with FAT32. 
      This has been corrected.
    - FAT32.IFS does not support EA's (yet), the WPS renames a file, tries
      to write EAs and since that fails renames the file back again.
      Now FAT32 returns NO_ERROR on the call used to write EAs.

- CHKDSK now is able to fix cross-linked clusters on the disk.
      
Version 0.41

- Fixed a problem with numeric tails shortnames. Files alway got ~1 instead
  if an incrementing number. Has been fixed.

Version 0.50

- Fixed a problem where files with longnames could sometimes not be found
  which lead to duplicate filenames.
- Fixed a problem where scandisk would claim that a directory created by
  FAT32.IFS contained invalid blocks.
- Fixed a (BIG) problem with files or directories with long names where
  if such a file was opened in a DOS session and in an OS/2 session 
  simultaniously OS/2 was unable to see that the same file was opened.
- Fixed a problem where read-only executables could not be run.  
- Fixed a problem where the algoritm used to determine the highest available
  cluster number was incorrect.
- Fixed a problem were CHKDSK was unable to fix cross-linked files.
- Since some people complained that FAT32 would sometimes hang, 
  I have modified the internal semaphore mechanism so an error message will
  appear if a semaphore remains blocked for more than a minute.

Version 0.51
- Did a lot of work on Lazy write performance. Cache access is no longer
  protected with a semaphore but with a per sector inuse flag.
- Fixed a problem that caused INSTALL and MINSTALL to abort when FAT32.IFS
  was loaded. The problem had to do with argument checking with FS_IOCTL 
  calls.
- Fixed a problem that BRIEF, a populair editor under OS/2, trapped or hung
  itself. The problem had to do with returning improperly formatted 
  information when querying EAs (FAT32.IFS does not support EAs!)
- Corrected a serious problem when a single file was opened more than once 
  and the file was modified using one of the instances. The other instance(s)
  didn't pick up the changes and FAT32.IFS might trap. 

Version 0.52
- Didn't handle closes from child processes that inherited open files 
  properly so the final close would fail.

Version 0.60:
- Changed the algoritm to detect EOF in the FATs since MS appearantly uses
  other values than 0x0FFFFFF8 as EOF token.
- Changed the flush dirty buffer mechanism to use strategy2 device calls.
  This has resulted in an increase of performance during write to disk.
- Changed CHKDSK to accept an /V:1 argument to only show fragmented files,
  while /V[:2] also lists all files.
- Made it possible that renaming a file to a new name where only the 
  case was changed worked.

Version 0.61:
- Changed some logic in the dirty buffer flush mechanism.
- Changed some logic in the FS_WRITE and FS_NEWSIZE functions.

Version 0.62:
- Corrected a bug that lead to a disk full message when a file was rewritten
  (for instance with E.EXE) and the new size was just a couple of bytes more
  then to old size. Problem was result of the logic change in FS_NEWSIZE.
- Oops: Forgot to update the version number in version 0.61.

Version 0.63:
- Finally understood why CHKDSK failed on very large disks. UFAT32.DLL 
  accesses the disk using DosOpen with OPEN_FLAGS_DASD. In that mode default
  behaviour is that the disk is accessed using physical byte offsets from the
  beginning of the (logical) disk. Now since the maximum value in a 32 bit 
  integer is 2^32 this value divided by 512 was the maximum sector that could
  be read (= sector 8388608 = 4Gb disk size maximum).
  Now UFAT32 uses the same trick as HPFS uses, via a call to DosFSCtl disk 
  access is switched to sector mode so 2^32 sectors can be accessed. 
  This means CHKDSK can (theoretically) check disks upto 2048 gigabytes.

Version 0.64:
- Again a problem with CHKDSK, this time the file allocation check failed if
  there were more than 65535 clusters assigned to a file. 
- FAT32.IFS now reports fake cluster sizes and total and free cluster counts
  whenever a DOS session queries free space. The maximum cluster size 
  returned has been set to 32 Kb and the maximum for total and free clusters 
  is 65526 clusters so the maximum disk size in dos is reported as almost 2Gb.
- Encountered (and fixed) a trap that occured whenever a volume was flushed 
  via a explicit call and there were still dirty sectors in call. 
  It occured in code I changed in version 0.60 and this was the first time I 
  trapped on it, so the combination of factors appears unlikely.
- Modified FS_CHGFILEPTR so negative seeks will be handled properly and
  build in logic to not allow files to grow bigger then 2Gb.
- Uptil now I ignored the MUST_HAVE_XXX settings for directory scans since I
  assumed they were not used. Some users reported files beeing show twice in
  some application so: I stand corrected and so is FAT32.IFS.
- Corrected a potential problem where (theoretically) files could be given 
  a directory attribute.
- Changed the algoritme used when no large enough contiguous fat chain is 
  available and the fat chain has to be constructed from various chains.
  Before the change an algoritme searching for individual free clusters was
  used. Now FAT32.IFS searches the largest free chain assigns it and then 
  searches for the next largest free chain until a chain long enough is 
  created. This is still not very fast, but will only really occur of the 
  disk is rather full and very fragmented.

Version 0.65:
- Files with valid 8.3 lowercase filenames where returned by findfirst/next
  in DOS sessions in lowercase as well. Some programs don't like that. 
  Now findfirst/next in DOS sessions always returns an uppercase name.
  (This problem only occured when LFN's were hidden to DOS.)
- Corrected a problem where while filling the buffer for FindFirst/Next too
  much data was initialized (due to using strncpy) and data was overwritten.
  This was most appearant with OS/2 Commander that trapped on a FAT32 
  directory with many files.

Version 0.66:
- DosSetFileInfo returned an error (ERROR_INVALID_LEVEL) when trying to write
  Extended attributes. Now FAT32.IFS reports NO_ERROR (But still doesn't 
  write the EA!). This makes f.i. that the installation of the OS/2
  Netscape pluginpack now works properly.
- Corrected a problem with FindFirst/Next where the check on required buffer
  space was incorrect. Some programs (Slick Edit) failed doing a directory
  scan. This has been fixed.
- Modified the behaviour of DosSetFileInfo so that it will only set date/time
  values in the directory. Before DosSetFileInfo also set the attribute, but 
  I found that this also doesn't work on HPFS, so I modified the behaviour.
- Modified the default MONITOR logging so that (almost) all FS_XXXX calls are
  shown with the return values given. 

Version 0.70:
- Most significant change is the implementation of EXTENDED ATTRIBUTES.
  Currently they will only be supported if /EAS is specified after FAT32.IFS 
  in the config.sys. Please read the chapter about extended attributes.

- Corrected a small problem where a whenever a short name had to be created
  for a longer name containing any embedded blanks in the name FAT32.IFS left
  the blanks in, while Win95 skips them while creating the shortname.
  This lead to SCANDISK reporting incorrect long file names. (When correcting
  this problem the short name was modified by SCANDISK.)
  Now FAT32.IFS does the same as Windows 95.

- Received a report that FAT32.IFS failed allocating the cache space. Modified
  FAT32.IFS so it will no longer trap on such a situation, but will continue
  to run (without a cache - slow!)

- Received a report about a possible memory leakage problem in FAT32.IFS. 
  Changed CACHEF32.EXE so when run, it will show the number of GDT selectors
  currently allocated for FAT32.IFS.

Version 0.71:
- EA's were not found from DOS sessions. Now this is hardly a problem since
  DOS programs never access EA's, but EAUTIL can be used in DOS sessions, and
  didn't work. Now it does.
- There was another problems with finding EAs when FAT32.IFS was set to the 
  mode in which internally short names were used (CACHEF32 /FS). Now this
  seems to work properly.

Version 0.72:
- Forgot build in the EA logic for creating and removing directories. Has 
  been added.

Version 0.73:
- Using DosSetPathInfo, it was possible to create an EA file for a non 
  existing file. This lead f.i. to a ' EA. SF' file in the root directory.
  This problem has been corrected.
- Changed a bit in the algoritm for making a short name for a file with a 
  longname.

Version 0.74:
- Corrected a problem with DosFindFirst/next when the buffer wasn't large 
  enough for the extended attributes and FAT32.IFS returned 
  ERROR_EAS_DIDNT_FIT when more than one entry was placed in the resultbuffer.
  Now FAT32.IFS returns this error only if the EA's of the first 
  matching entry don't fit in the buffer.
  (This error lead to the WPS giving an error that no matching entries were 
  found on opening of a directory)

Version 0.75:
- Added a check for valid EA names.
- Added a translation mechanism for long filenames between the Windows 
  Character set and OS/2 character set.
  See: WINDOWS & OS/2 CHARACTER SETS for more information.

Version 0.76:
- Corrected a NASTY BUG that lead to loss of data when multiple files were
  opened.

Version 0.77:
- Corrected a problem when more then 512 lost chains were found. (CHKDSK can
  only recover 512 lost chains at one run)
- Corrected a problem in OS/2 sessions (introduced in version 0.75) where 
  valid 8.3 filenames in lowercase where always stored in uppercase.

Version 0.78:
- Corrected a TRAP that could occur when the cache is full with dirty 
  sectors and the oldest dirty single sector was flushed using a single flush
  routine. The trap message was 'WriteCacheSector: VOLINFO not found!'.
  This problem only occured when more than 1 FAT32 partition is present.
- Corrected a problem with UFAT32.DLL when checking directories containing
  more than 2048 files. (CHKDSK reported lost clusters, but was wrong)
- Corrected another problem with UFAT32.DLL that occured when there is not
  enough memory available to check large directories. UFAT32 would abend with
  an access violation.
- Corrected a problem with DosOpen when on Opening an existing file with only
  the FILE_CREATE (OPEN_ACTION_CREATE_IF_NEW) bit set (and not the FILE_OPEN 
  flag) the file was created while the open should fail. 
- Corrected a problem that the characterset translate tables would be 
  overwritten internally leading to all kinds of funny results. (Duplicate
  directories etc)
- Modified the default behaviour of FAT32.IFS and for the /T option for
  cachef32: No character translation takes place. This works for situations
  where Windows and OS/2 use the same codepage.

Version 0.79:
- Rewrote the emergency flush routine so it will handle multiple FAT32 
  partitions better. 
- Made some minor modifications in UFAT32.DLL (For CHKDSK).
  - A trap was solved when an EA file could not be repaired
  - An error in the longname retrieval routine was fixed
  - Output is matched more closely to HPFS and plain FAT.

Version 0.80:
- Rewrote the strategy2 routines so more than one request list can be fired
  per volume. Hopes this improves performance.
- Corrected a problem with FS_COPY that failed if the target file was zero
  bytes large.
- Corrected a problem with DosOpen with the Truncate flag set and when the
  target file already existed and had EAs. The open failed, but the file was 
  truncated and a lost cluster was created.
- Created PARTFILT.TXT file about PARTFILT and DISKINFO.
- Implemented an version check between the IFS and UFAT32.DLL (for CHKDSK) 
  and CACHEF32.EXE.

Version 0.81:
- Noticed that when FS_FILEINFO was used to set the date/time on a file as
  only action the date/time was not updated. Corrected.
- In version 0.66 I removed the setting of the attribute using DosSetFileInfo.
  As I found out, I was wrong. Now DosSetFileInfo from 32 bits programs sets
  the attribute. From 16 bits programs however, this doesn't seem to work on
  FAT, HPFS and FAT32. Don't know why.
  
Version 0.82:
- Changed a bit in the algoritm for making a short name for a file with a 
  longname (again). Now filenames starting with a dot are handled better.
- Changed the (internal) memory handling routines to use more then one 
  selector so I could use this for FindFirst/Next handling instead of 
  allocation one selector per FindFirst/Next call.
  This was neccessary because a DOS session can fire a lot of FindFirst calls
  only for checking existence of files. Before the modification FAT32.IFS
  could run out of memory after say a couple of hundred FindFirst calls.
  (I found that OS/2 itself doesn't allow a DOS session to fire more then 
   round 500 FindFirsts. After that OS/2 starts reusing find handles.)
  I encountered this problem when trying to unarj the Novell Netware client
  2.12 on my FAT32 disk.

Version 0:83:
- Replaced the translate mechanisme that was introduced in version 0.75 by
  a mechanisme where CACHEF32.EXE on first load calls the native OS/2 NLS
  support to create a default translate table between the current codepage
  and unicode. This should work better for some NLS versions of OS/2.
- Added a switch to CACHEF32 to dynamically change the priority of the lazy
  write thread. The default priority is still idle-time, but this can be 
  changed to a higher priority.
- Did experiment a bit with lazy writing in general. In my own system it
  improved performance somewhat.  
- Corrected a problem in PARTFILT where whenever a HIDDEN partition type 
  was specified after /P this didn't always work properly. Now when a hidden
  partition type is specified, the unhidden type is also handled by PARTFILT.

Version 0.84:
- Got a message from someone complaining that the change in PARTFILT made him
  loose the ability to mount hidden 'normal' partitions since PARTFILT 
  presented all partition types as IFS. Now PARTFILT show normal partitions
  by their actual types and only not-by-OS/2 supported types as IFS partitions.
- Increased performance for accessing large files by keeping track of first 
  and last cluster for each open file, and even the current cluster for each 
  open instance.
- Removed the limit for the maximum number of open files.
- Fixed a problem in my internal memory (sub)allocation routines that lead to
  various problems. This became more clear since FS_OPEN now also uses malloc
  to allocated memory per open file.
  Problems I encountered were trap D's and internal fatal messages.
- Changed the way monitor works. Introduced a 'trace mask'. See MONITOR 
  above.

Version 0.85:
- A user pointed me at the problem that ReadOnly files cannot be renamed.
  This problem has been corrected.
- Corrected a problem whenever a non-existing file was openen. If later the 
  file was created this could lead to a trap (at least in theory: I haven't 
  seen it nor heard it actually occured).
- Changed PARTFILT again. Whenever a hidden partition type was specified
  partfilt also virtualized the unhidden type. So if /P 16 was specified, 
  both types 16 and 6 were virtualized. This could lead to unwanted results.  

  So I modified the mechanism again.
  Now - if /A is not used - only the types specified after /P are virtualized.
  (The /A switch controls whether or not to virtualize all partitions.)

  PARTFILT always unhides the partitions it virtualizes.

  For the partition types PARTFILT virtualizes the following rules apply:

  Normal partition types (types 1, 4, 6, 7, but also 11, 14, 16 and 17) 
  are reported to OS/2 with their actual -unhidden- partition type. 

  Any other partition types specified after /P are reported as un-hidden IFS
  partitions. 
  Any other partition types NOT specified after /P are reported as their 
  actual -unhidden- type.

  Keep in mind that if you specify /A you must also use the /M argument to
  tell PARTFILT which partitions you want to mount.

- Also, whenever /A is specified with PARTFILT /W is automatically set.
  Otherwise, OS/2 will not boot at all.

- CACHEF32.EXE did not properly handle the /P:x argument when specified in 
  CONFIG.SYS. The argument was lost. This has been fixed.

Version 0.86:
- Always thought that it was not allowed to the directory bit set in 
  DosSetPathInfo and therefor I rejected calls with this bit set. I was wrong.
  Now DosSetPathInfo accepts the directory bit set (for directories only).

- Modified partfilt so it will also scan partitions inside a extended type F 
  partition (partfilt is now on version 1.08). Modified DISKINFO.EXE to do the 
  same.

- Noticed some problems when a file was opened multiple times. The directory
  information was not always updated properly. Also, the attribute of a open
  file was kept per instance instead of only one time for all open instances
  of a file. So using DosSetFileInfo on one instance was not noticed by other
  instances of a file.

Version 0.87:
- Modified the internal memory usage somewhat. Some allocated segments are
  marked unswappable now.
- Modified FS_DELETE to return ERROR_ACCESS_DENIED whenever this call was
  used for a directory. Previously, FAT32.IFS return ERROR_FILE_NOT_FOUND.
- Modified CACHEF32.EXE so it will also run if UCONV.DLL cannot be loaded.
  If that is the case, no UNICODE translate table will be loaded.
- Solved a problem when a file was rename when on the case mapping was 
  changed. If the file had extended attributes the rename failed and the EA
  was lost.

Version 0.88:
- DISKINFO still didn't show partitions inside an extended partition type F.
- Fixed a potential problem in the lazy write routines. This could lead to 
  sectors not being written when they should have. (have never seen it though)
- Made it work with Fixpack 10. (FP10 made FAT32.IFS trap)

Version 0.89:
- FS_SHUTDOWN is called twice by the kernel. The first one is to signal begin
  of shutdown and the second to signal the end. FAT32.IFS flushed its internal
  buffers on the 2nd call. This has been modified so FAT32.IFS now flushes
  on the first call.
- I've had a report from someone with a problem where the drives where mounted
  after CACHEF32 had queried CACHE settings. Since the cache is allocated on
  first mount this didn't work. I have added a call to force the drives 
  to be mounted before CACHEF32 queries the cache settings.
- Fixed a small division by zero in CACHEF32 when the cache was zero sectors
  large.
- Fixed the 'cannot find message file' problem in CACHEF32.EXE.
- Some users keep having troubles with 'error cannot find SH". Just for myself 
  I added the filename there.
- Replaced an internal call (FSH_PROBEBUF) by a DevHelp call.
- Fixed a trap I got due to a reentrancy problem in my memory allocation 
  routines.
- Changed the way data is kept per open file instance because I have received
  some reports from users that they got a 'ERROR: Cannot find the IO!" 
  message.
- FAT32.IFS had its code segments marked as EXECUTEONLY. Now AURORA doesn't
  seem to like that and traps. The code segments are no longer marked this 
  way but as EXECUTEREAD.

Version 0.90:
- Found some problems with FS_COPY. If FS_COPY was copying a file the target
  file was not protected from being deleted or renamed in another session.
- Noticed that I had the default cache size incorrectly set to 128 Kb. 
  Modified it to 1024 kb and added a warning message if no /CACHE argument
  is present.
- FS_COPY didn't check if source and target where on the same partition. (I 
  incorrectly assumed OS/2 did this check.). Now FS_COPY doesn't try to handle
  the copy when source and target are on different drives. This way the copy 
  is done by OS/2 itself.
- Modified the way data is written from the cache to disk. Instead of 
  instructing the Device Driver to write data directly from cache to disk,
  the data is now first copied to another memory area thereby releasing the
  data in the cache a lot sooner. This way the IFS does not have to wait 
  for the device driver to finish before a specific sector in cache is 
  available again.
  The drawback is that this makes FAT32.IFS to use more (physical) memory.
  With a cache size of 2048 Kb, an additional 480 Kb is allocated. 
  With smaller cache sizes the additional data reduces relatively. (a cache 
  size of 1024 Kb leads to an additional memory allocation of 240 Kb)
- Never had any error handling (message) in the routine that is called by the
  device driver to notify completion of the strategy2 request list. This 
  version has it. This is mainly to get more light on FAT32.IFS and aurora.

Notes on version 0.91:
- Got a report that FAT32.IFS ignored the fourth character of the extention.
  Looking for the cause I found that FAT32.IFS created incorrect short name
  equivalents for files with a four character long extention. 
  In that specific case the fourth character was ignored when creating
  the shortname. The effect was that e.g. a file called file.1234 and 
  file.1235 ended up having the same shortname. FAT32.IFS now
  no longer exhibits this behaviour, but you still might have double 
  shortnames in the same directory on your disk. I don't think SCANDISK 
  detects this problem. Please note this could only have happened with
  files having an extention of four chars for which all chars except the 
  fourth extention char were equal.
  
  To check this, set FAT32.IFS to use short names internally (CACHEF32 /FS), 
  and in a DOS session do a DIR command. If you detect any duplicate names,
  switch back to an OS/2 session and rename one of these files to another
  name and then rename it back to the original name. 

- Modified the calling of the strategy2 calls. Now FAT32.IFS no longer 
  request confirmation per individual sector. This fixes the problems
  with AURORA. 

  The problem with AURORA (Warp Server for eBusiness) FAT32.IFS was 
  experiencing was caused by a bug in the Logical Volume Manager that did
  not properly confirm individual requests. Since FAT32.IFS now no longer 
  depends on this individual confirmation the bug is no longer relevant.
  IBM did confirm this bug to me (October 1999) and promissed it would be
  solved in the next fixpack.

- Introduced a separate thread (from CACHEF32.EXE) that runs at time critical
  priority. The thread is awakened whenever the cache runs full with dirty 
  sectors and takes care of flushing these dirty sectors.

- Corrected a problem with Extended Attributes when a file had very large 
  extended attributes (almost 65536 bytes) the system would trap.

- Corrected a problem when a sector towards the end of the disk was read.
  Due to the read-ahead function 1 sector too far was read and the read 
  failed. 

- Noticed that the diskspace under DOS was not correctly returned. The faked
  clustersize was too small to actually report the correct disksize for disks
  smaller then 2.1 Gb.

- Until this version, the strategy2 routines did not set the flag to request
  the disk controller to cache the request on the outboard controller. I 
  did not set this flag since it didn't seem to matter on my own machine.
  However, this version has the flag set since some of you might profit from
  this setting and experience better performance.

- Enlarged maximum amount of data that is flushed (when lazy writing is used)
  to 64 Kb. Hopefully, this will increase performance for those 
  disk controllers that do not have the on-board cache enabled.

- Did an effort to solve the problem when a cluster chain becomes improperly
  terminated. FAT32.IFS simply ignores the problem now and assumes end of file.
  CHKDSK (UFAT32.DLL) detects and corrects this problem.

Version 0.92:

- When a FAT32 volume was not shut down properly the IFS did not allow files
  to be opened. This caused device drivers etc during shutdown not being 
  loaded from a FAT32 volume. Now FAT32.IFS allows files to be read from a 
  dirty volume.

- When a directory was moved the .. entry in that directory was not updated 
  to point to the proper parent directory. This has been corrected.

- CHKDSK checked for extended attributes even when /EAS was not specified
  after the IFS line in the config.sys.

- CHKDSK contained an error that when checking subdirectories sometimes (rare)
  the incorrect name (the longname of the previous directory entry) was used.
  This lead to claimed missing extended attributes for non-existing files.

- Modified the output of CHKDSK somewhat. Also, when the output is redirected
  to a file, the progress percentages are suppressed.
