
This patch will make AdvFS fileset quota enforcement work 
properly on a cluster.

This patch corrects a "cfsdb_assert" panic which can occur following the
failure of a cluster node.

This patch corrects a problem which can cause cluster members to hang, 
waiting for the update daemon to flush /var/adm/pacct.

This patch prevents a potential hang that can occur on a CFS failover.

This patch allows POSIX semaphores/msg queues to operate properly on
a CFS client.

This patch addresses a potential file corruption problem, which could
cause erroneous data to the returned when reading a file at a CFS client
node.  There's also a small possibility that this problem could result 
in a CFS panic ("AssertFailed: bp->b_dev").

This patch addresseses 2 potential CFS panics that might occur for a DMAPI/HSM
managed filesystem. The first panic problem string is: 
" Assert Failed: ( t)->cntk_mode <= 2". The second 
panic problem string is: "Assert Failed: get_recursion_count(
current_threa&CFS_CMI_TO_REC_LOCK(mi)) == 1".

This patch addresses a possible panic which could occur if multiple
CFS client nodes leave the cluster while a CFS relocate or unmount
is occurring.

This patch addresses a possible KMF panic when executing the
command "cfsmgr -a DEVICES" on a filesystem with LSM volumes.

This patch corrects a CFS problem that could cause a panic with the panic
string of "CFS_INFS full".

This patch addresses a potential CFS panic that might occur when a
file being openned in Direct I/O mode, while at the same time as the
file is being truncated by a separate process.

Enabler support for Enterprise Volume Manager product

This patch fixes memory a leak in cfscall_ioctl().

This patch is needed for freezefs support.

This fix addresses a data inconsistency that can occur when a CFS
client reads a file that was recently written to and whose underlying
AdvFS extent map contains more than 100 extents.

This patch fixes a panic that would occur during the mount of a
clusterized file system on top of a non-clusterized file system.

This patch prevents a Kernel Memory Fault panic during unmount in a Cluster
or during a planned relocation.

This patch fixes support for mounting other filesets from the cluster_root
domain in a cluster.

This patch fixes the assertion failure ERROR != ECFS_TRYAGAIN.

This patch fixes a race condition during cluster mount which results in a
transient ENODEV seen by a name space lookup.

Fix possible panic on boot if mount request is received from another node too
early in the boot process.

This patch fixes a PANIC: CFS_ADD_MOUNT() - DATABASE ENTRY PRESENT panic when a
node re-joins the cluster.

This patch fixes two race conditions in Cluster Mount support.  One race
results in a transient mount failure, and the second race might result
in a kernel memory fault panic during mount.

This patch fixes a cluster problem with hung unmounts (possibly
seen as hung node shutdowns).

This patch addresses a potential UBC panic which could occur when
accessing CFS filesystems.

This patch fixes a possible Kernel Memory Fault panic on racing mount
update/unmount/remount operations for the same mount point. This patch
also fixes a possible race between node shutdown and unmount.

This patch fixes a possible Kernel Memory Fault panic on the mount update on
a Memory File System (MFS) and other possible panics when bad arguments are
passed to the mount library interface.

This patch is to prevent a panic:
Assert failed: vp->v_numoutput > 0
or a system hang when a filesystem becomes full and direct async I/O via
CFS is used.  A vnode will exist that has v_numoutput
with a greater than 0 value and the thread is hung in vflushbuf_aged().

Fix a possible Kernel Memory Fault in function ckidtokgs.

Fix potential CFS deadlock.

This patch is to correct a cfsmgr error "Not enough space"
when attempting to relocate a file system with a large amount of disks.

This patch addresses possible CFS client node file read failures which
could occur if on a previous failure to perform a failover mount on the
client node the domain storage devices were closed.

This patch fixes support for mounting other filesets from a cluster node's
boot partition domain.

This patch addresses a cluster problem that can arise in the case
where a cluster is serving as an NFS server.  The problem can result
in stale data being cached at the nodes which are servicing NFS
requests.

This patch addresses a CFS panic that might occur for a DMAPI/HSM mamanged fs:
	(panic): cfstok_hold_tok(): held token table overflow

Fix for panic "cmn_err: CE_PANIC: ics_unable_to_make_progress: netisrs stalled"
in clua.mod due to wait for malloc when memory is exhausted.

Fix for panic in clua_cnx_unregister where a tp structure could not be
allocated for a new TCP connection.

Fix for problems with cluster alias selection priority when adding a member
to an alias.

This patch fixes a problem when the cluster alias subsystem does not send a 
reply to a client that pings a cluster alias address with a packet size of 
less than 28 bytes.

This patch allows the command "cfsstat -i" to execute properly.

This patch address a potential Cluster File System deadlock which can
occur during CFS failover processing following the failure of a CFS
server node.

Prevent process hangs on clusters mounting NFS file systems and
accessing plock-ed files on the NFS server.

This patch fixes a possible timing window whereby a booting node may panic
due to memory corruption if another node dies.

This patch fixes a small window which can cause a clusterwide panic on node
reboot in a quorum loss situation.

This patch fixes a problem in which a cluster member may panic with the
panic string "kernel memory fault".

This patch fixes a possible boot hang which could occur if the cluster_root 
domain consists of LSM volumes whereby the underlying physcial storage is
non shared.

This patch prevents a memory leak from occurring when using
small, unaligned Directio I/O access (ie, not aligned on a 512
boundary, and doesn't cross a 512 byte boundary).

This patch prevents the cfsmgr command from displaying an erroneous server name
when a request is made for statistics for an unmounted file system.

This patch fixes support for Synchronized IO in clusters.

This patch will eliminate erroneous EIO errors which could occur
if a client node becomes a server during a rename/unlink/rmdir 
system call.

This patch addresses a CFS problem that could result in degraded
performance when reading at file offsets past 2GB.

This patch addresses a cluster file locking problem which can arise
when filesystems are exported from the cluster to NFS client nodes.

This patch addresses a CFS problem where file access rights may not
appear consistent cluster-wide.

This patch fixes a race between cluster mounts and file system lookups, and 
fixes a problem in which file system failover deadlocks.

This patch corrects a Cluster File System (CFS) performance
issue seen when multiple threads/processes simultaneously
access the same file on an SMP (>1 cpu) system.

This patch addresses a potential cluster-wide hang which can occur in
the Cluster File System.

When ACLs are enabled on the system and there is a default ACL on a
directory and a request is issued from a CFS client to create a 
file within that directory, the file permissions inherited 
from the default ACL may be different than expected.

This patch fixes a problem where cluster filesystem I/O and AdvFS domain access
causes processes to hang.

This patch prevents an infinite loop during node shutdown when using
server_only file systems.

This patch fixes a memory fault panic from clua_cnx_thread.

This patch addresses a cluster problem where an application which uses
file locking may experience degraded performance.

This patch is the I/O barrier code that prevents HSG80 controller
crashes (firmware issue).

This patch fixes a situation in which a rebooting cluster member
would panic shortly after rejoining the cluster if another cluster
mamber was doing remote disk IO to the rebooting member when it
was rebooted.

This patch allows high density tape drives to use the high density compression
setting in a cluster environment.

This patch fixes a kernel memory fault panic that can occur within a cluster
member during failover while using shared served devices.

This patch fixes the problem of cluster wide hang because of DRD node
failover is stuck and unable to bid a new server for served device.

Added drd Barrier reties to work around HSx firmware problems.

This patch fixes a problem that, CAA applications using tape/changers as
required resources will not come ONLINE (as seen by caa_stat)

This patch fixes a problem where the tape changer is only accessible
from member that's the drd server for the changer.

This patch fixes a problem where an open request to a disk in a cluster
fails with an illegal errno (>=1024)

This patch fixes a problem where an open to a tape drive in a cluster
would take 6 min (instead of 2) to fail if there were no tape in the drive.

This patch solves a problem in which a cluster would hang the next time a node
was rebooted after a tape device was deleted from the cluster.

This patch fixes a domain panic in a cluster when a file system is mounted
on a disk accessed remotely over the cluster interconnect.

This patch fixes the race condition problem when multiple unbarrierable
disks failed at the same time.

This patch fixes a kernel memory fault in drd_open

This fix prevents an infinite loop in drd_open()

This patch fixes serveral Device Request Dispatcher problems.

This patch is required to remove a rolling upgrade issue with CDROM and FLOPPY
device handling.

This fix addresses a problem in which a cluster or a device can get IO:s
stuck or that a cluster node may panic after a device has been deleted.

Fix for excessive FIDS_LOCK contention observed when large number of files are 
using system based file locking.

This patch immediately updates the attributes on a directory when files
are removed by a cluster node that is not the filesystem server.

This patch fixes a hang condition in Device Request Dispatcher (DRD) 
when accessing a failed disk.

This patch fixes a problem in the cluster kernel where a cluster member
panics when another member is rebooted.

This patch prevents a simple_lock: time limit exceeded panic or a
Assert Failed: brp->br_fs_svr_out panic that can be seen while executing
chfsets on a cluster.

This patch fixes a problem in the cluster kernel where a cluster member 
hangs during cluster shutdown or while booting.

This patch fixes a problem in the cluster kernel where a cluster member
panics when a tape device is accessed.

This patch fixes a token problem which could cause an unmount to hang.

Fixes "CNX MGR: Invalid configuration for cluster seq disk" panic during
simultaneous booting of cluster nodes.

This fix prevents an infinite loop in drd_open().

This fix addresses a problem in which two nodes leaving the cluster within a
short (but not too short) time period would cause IO:s on some devices to get
stuck.

This fix addresses a problem in which a new device would not be properly
configured in a cluster if the device was discovered during a boot.

The Device Request Dispatcher, DRD, should retry to get disk attributes when 
EINPROGRESS is returned from the disk driver.

This patch fixes an issue with ICS (Internode Communication Services) on a numa
based system in a cluster.

Fixes a possible race condition between a SCSI reservation conflict and an I/O
drain, which could result in a hang.

This fix adds the support of multiple opens to tape libraries/meda changers.

This patch alleviates a condition in which a cluster member takes an extremely 
long time to boot when using LSM.

This patch corrects reference counting errors that may lead to a panic
during cluster mount.

This patch relieves pressure on the CMS global DLM lock by allowing 
AutoFS auto-mounts to back off.

This patch addresses a potential panic in the Cluster File System
which can occur when using raw Asynchronous I/O.

This patch addresses a potential panic in the Cluster File System which
can occur when using file system quotas.

This patch fixes kernel memory faults associated with passing in invalid
parameters to the mount system call.

This patch fixes a hang that is possible when multiple nodes
are shutting down simultaneously, and server-only filesystems are mounted.

Fix for potential system crash which could occur when adding a cluster alias.

This patch improves the responsiveness of EINPROGRESS handling during the 
issuing of I/O barriers.  The fix removes a possible infinite loop scenario
which could occur due to the deletion of a storage device.

This patch relieves pressure on the CMS global DLM lock by allowing
AutoFS auto-UNmounts to back off.

This patch adds some data validation checking which pertains to cluster messages
involving tokens, to assist in problem isolation and diagnosis.

This patch corrects diagnostic code which might result in a panic during
kernel boot.

Bus reset causes loss of quorum, resulting in cluster hang.

This patch fixes a problem in the cluster kernel where a cluster member
panics while doing remote IO over the interconnect.

This patch fixes a performance problem where threads
could spend a long time in the check_busy() AdvFS routine.

This patch fixes a panic that may occur during an unmount.

This patch fixes a cross-node cluster deadlock that can occur when AdvFS
threads on two cluster nodes simultaneously call code that requires the
taking of already held AdvFS locks on the other node.

Mounting on a directory in a clone fileset fails with "Device Busy".

This patch provides cluster file system performance enhancement 
when using file locks to coordinate file access.

Prevents a Kernel Memory Fault Panic in some cases where advfs administration
commands are performed on a mounted fileset of an inaccessible advfs domain.

This patch fixes a problem in the Device Request Dispatcher.

This patch fixes a race condition in the Device Request Dispatcher.

When multiple rsh sessions target at the 
cluster alias address, there are chances that
clua.mod will give out a single port to be
used for multiple sessions and cause chaos.
This patch fixes that problem.

This patch fixes an internal problem in the kernel's
advfs, ufs and nfs filesystems where extended attributes
with extremely long names, greater than 247 characters,
could not be set on files.  The new limit is 254 + a Null
string terminator.

This patch fixes a panic that may occur when a node is halting.

This patch fixes a race condition in CFS readahead logic and a race condition 
in CFS token logic.

This patch addresses 3 problems:
- Improve the fragment gathering mechanism to boost performance.
- Fix panic problem when attempt to unload clua.mod.
- Fix panic boot up panic when ippport_userreserved is 1000 or less.

This fixes an problem where access to the quorum disk can be lost if the quorum
disk is on a parallel scsi bus and multiple bus resets are encountered.

Fixes a regression associated with non SCSI storage.

This patch fixes a timing window during asynchronous reads on a CFS client.

This patch fixes a cfsmgr core dump when passing the incorrect number of
arguments upon force unmounting a served filesystem.

This patch fixes a problem such that the CFS client for a file with a hole
preceeding a frag might drop that frag.

This patch eliminates a performance problem when a node, acting as CFS server
of an NFS client filesystem, is write-appending to an external NFS server.

This patch fixes a panic that may occur due to a race condition during the
mounting of a booting node's boot partition.

This patch fixes a race between nodes performing failover processing which
might lead to an incorrect change in the state of file locks.

Under some circumstances, a system may panic with a kernel memory fault when a
device that is being opened by one program is being deleted via the "hwmgr"
utility.

This patch fixes a KMF from mc_bcopy or _OtsMove.

This patch addresses a potential hang in the NFS server when filesystems are
being relocated in a cluster.

This fix helps to close a race where synchronous writes may obtain disk
allocations that were promised to cached client writes.

This patch preserves the error code from an asynchronous write error on a CFS
client and returns the error from the close(2) system call.

This patch fixes a potential data inconsistency caused by a bug in the CFS block
reservation code which calculates incorrectly the amount of space requested and 
used by direct I/O writes.

This patch fixes a potential data inconsistency that may occur when a domain is 
nearly full.  Client write requests shipped synchronously to the server will no
longer have subsets of pages written asynchronously due to a race with VM.

Fix reconnect problem when interface comes down and up again.

Fix a panic in clua.mod which is caused by receiving a
delete-cnx-request from a member and found that the current
state of the cnx is in UNREGISTER state.

This patch resolves kernel memory fault in m_copym.

This patch fixes a forced unmount of non failoverable file system (i.e. nfs and 
autofs) panic in the case that the initiator is down.

Fix the panic problem in clua.mod when max_aliasid is
increase and aliases are added.

This patch fixes a rare cluster hang caused by dead locks occurred
between the cfs client and server during multiple write operations.

This patch fixes an unaligned kernel access in the cluster I/O stack.

Fix the problem where clua.mod does not handle
TCP RST messages appropriately.

Fix the long delay NFS connection failover when servicing cluster member dies.

This patch addresses a panic (Assert Failed: (cp->c_flags & CDIRECTIO) == 0)
in the cluster filesystem.

Rewrites are now possible when the domain is close to out of space.

This srequest ensures correct processing in the close() system call.

This patch fixes a boot panic.

This patch fixes a cfs client panic during a file system read operation 
where the server goes down. Thus, the client itself becomes the server and 
attempts to release the directio token which had already been released.


