The current maintenance kit is Caché 2008.1.5. This document is only part of the available maintenance kit documentation. The full set of documents is available in the \Docs subdirectory of your Caché installation as follows:

• Late-breaking information about the release: \relnotes\cache\readme.1st
• Release notes for Caché 2008.1.5: \relnotes\cache\relnotes.htm
• Release notes for the previous maintenance kits since 2008.1: \relnotes\cache\prenotes.htm (this document)

This document is a historical archive of changes in Caché since the original 2008.1 release, but prior to the current maintenance kit. Changes unique to the current maintenance kit are described in relnotes.htm.

This document includes the following sections:

• General Announcements
• InterSystems News, Alerts, and Advisories
• Online Documentation
• Change Reports for Previous Maintenance Kits

InterSystems advises all users to recompile their Application classes as part of the upgrade process so as to take advantage of all the performance improvements as well as other changes that may affect them in this release.

Anyone upgrading from a Caché release at or before 5.0 will need a new license key.

From time to time, InterSystems publishes items of immediate importance to users of our software. These include alerts, mission critical issues, important updates, fixes, and release announcements.

The most current list can be obtained from the InterSystems Website.

Users should check this list periodically to obtain the latest information on issues that may have an effect on the operation of their site.

As a convenience to our users, InterSystems provides online access to documentation for recent product versions at the InterSystems Website. From the home page choose Support and Education, then Caché Support and then Caché Documentation. Then select the specific version and type of documentation you are interested in.

This document includes the change reports from:

• Caché 2008.1.4
• Caché 2008.1.3
• Caché 2008.1.2
• Caché 2008.1.1

This change addresses a problem in the code responsible for replacing 'old with new' session IDs in previously cached pages.

When the CSP Gateway caches a page returned from Caché, it is usually the case that the page is cached with the session ID (either as a CSPSESSIONID cookie or CSPCHD form variable) of the user that first requested the page. On subsequent retrievals of this page from the cache for other users, Cach´ must replace all instances of the old session ID with the ID of the current user accessing the page.

This change resolves a race condition caused by multiple frames accessing the CSP Gateway data block responsible for registering state-transitions (preserve mode changes) against incoming sessions IDs. Previously, when multiple frames attempted to set the state, the results were unpredictable.

With this change, a silent upgrade of an instance which does not have the "Caché Engine" feature installed will no longer result in "dialogs out of order" error.

This change corrects a problem in which, when the Light C++ Binding (LCB) stored an index entry for an index on a property of type %Timestamp, the month was 1 less than it should be. For example, it stored 0 instead of 1 for January. Timestamp values were (and continue to be) stored correctly in the data, it was only the index entries that were stored incorrectly.

Use of XDEV in CacheSAX or CacheXSLT requires a callout to return a string representation of a pointer value. This change corrects an error where the callout would truncate a pointer on a 64-bit system.

Prior to this change, the ODBC function, SQLError, would get an error when attempting to access an environment header (<ACCVIO>), if the connection has not be established. This has been fixed.

This change corrects an error in processing the OR/AND IDKEY optimization for queries of the style normally generated by MS/Access. In this case, the conditions were stated in the query in an order other than the IDKEY field order; this previously caused incorrect code-generation. For example, with an IDKEY <p1,p2,p3>, the following condition would cause incorrect results:

    ... OR (p1=? AND p3=? AND p2=?) OR ...

Now, regardless of the order of conditions in the WHERE clause, the result is always correct.

This corrects a problem where loading a routine larger than 65311 bytes could lead to Caché overwriting other structures in memory. This, in turn, could lead to unexplained memory exceptions and process dumps. The error occurred on any system where a process loads a routine larger than 65311 bytes more than 255 times.

This corrects previous changes that made the length of the viewbuffer too small causing corruption the message queue pointers. The symptom was that users might see an <ACCVIO> during view operations.

A minor issue where the control process might have suspended the write daemon for 1 second after Backup.General.ExternalThaw() is executed has been resolved.

This situation could have occurred any time ExternalFreeze() was in force for more than 10 minutes. In this case, when ExternalThaw() is called there was a window while the write daemon was waking up where the control process does not see the extended time window set as part of ExternalFreeze() and tries to suspend the system. The write daemon starts running and the control process unfreezes the system one second later.

While this could have been seen on Windows or VMS systems, it was most likely to occur on a Unix system.

This corrects an error in a previous change that attempted to correct a security hole for $INCR(). The prior attempt did not account for a locked global buffer that had been transferred before Caché sent network request to the master. The result was a locked blobal buffer could never be released.

This corrects an error that caused Caché to conclude the routine index global was missing and to rebuild it incorrectly.

This fix corrects an error in processing the default answer in %ER. The <ENTER> representing the acceptance of the default was being incorrectly analyzed.

There were some unusual cases where it was possible for the CSP Gateway and the Caché server to disagree on whether the Preserve setting was 0 or 1. The failure to keep these values in sync would result in either of two conditions:

• a server process only serving requests from one session when this was a Preserve=0 session and so causing this server process to serve many more requests, or
• more seriously, a server process in Preserve=1 mode getting a request for another sessionId.

This change now checks for any potential inconsistency in the Preserve state of the session and makes sure the gateway is updated with the correct state and the cookie is reset to the correct value.

This change allows CSP Gateway to properly handle modifications to "Preserve" mode. Such changes can be made anywhere in the code responsible for delivering the session response. Changing a session from state-less (preserve mode 0) to state-aware (preserve mode 1) and vice versa results in changes to the data held in the session cookie/token. The Gateway needs to be made aware of these changes so that it can manage its connection pool appropriately.

This change eliminates a problem where an argumentless ZLOAD with an immediate end of file left the partition empty, and a subsequent DO command could cause an access violation.

When ECP daemon is started by the job server, ECP will now job a non job-server daemon, and abandon the original.

ECP may accept connection(s) for recovery during system startup. This change modifies the ECP server to wait for logins to be enabled before the ECP requests are processed.

This change modifies the ECP server shutdown to cleanup any queued pending pre-fetch requests. If these are not cleared properly, in very rare conditions the ECP server may receive a message while the write daemon of that same session is shutting down. This event leaves the background pre-fetcher in an undefined state.

To provide its guarantees, the ECP server depends on the durability of its activities. Durability tracking was previously dependent on the journal file number, which is not updated and tracked in parallel with the journal offset.

This change modifies the durability logic not to depend on the journal file number.

Caché connections were failing in random ways due to a Microsoft bug that corrupts memory when GetUserName() is called inside the initialiuzation code of a dll. The details of the bug are described at http://support.microsoft.com/kb/942234.

This change alters CacheODBC.dll so it no longer calls GetUserName() during initialization.

These methods were projected by the prior CacheObject bindings. The classes modified are:

• %Boolean
• %Char
• %Collate
• %Currency
• %Date
• %Decimal
• %Double
• %EnumString
• %FilemanDate
• %FilemanTimeStamp
• %Float
• %Integer
• %Name
• %Numeric
• %String
• %StringTimeStamp
• %Time
• %TimeStamp
• %MV.Date

Independent of the SoapBindingStyle for a web client or web service, the WS-Security and WS-Addressing headers should always be in literal format (that is, not SOAP encoded).

Because of the use of SOAP encoding, the WS-Security header for SoapBindingStyle=encoded web client had the wrong header element name. This change fixes that problem.

The XMLFORMAT parameter (value of literal or encoded) in a %SOAP.Header subclass determines if the header should always be in the specified format. If XMLFORMAT is "" or not specified, then the header is output in the same format as the Body which is specified by SoapBindingStyle.

This change fixes a rare problem on Itanium Unicode platforms that could cause a <STRINGSTACK> error if a variable was assigned a small literal string repeatedly without any other command following, for example:

For i=1:1:25000000 Set x="12345"

This change corrects a condition where, in certain rare conditions, database corruption could occur on an ECP Client if the write daemon is in the process of writing a bottom pointer block for the ECP Client cache to disk while a user job is deleting a node from the block because the user job found a data block which is marked as "purged from the local cache".

The symptom of this degradation is that the indication of the space in use in the bottom pointer block will be larger than the size of the block itself.

The 'margin' parameter of the terminal USE command (for example, USE 0:(270) ) was handling values >255 differently on OpenVMS Alpha and OpenVMS Itanium.

The documentation says, "Values from 1 to 255 set the right margin for output; any other value disables the right margin", but on OpenVMS Alpha, Caché properly handled values only up to 511. On OpenVMS Itanium, Caché internally truncated the value to one byte, essentially acting as a #256 on values between 255 and 512.

This change corrects a situation that can result in an installation failure for DECUNIX cluster platforms.

This change fixes a potential database security hole where a user who had no access to a global could still use $ORDER in the reverse directtion on its subscripts.

Caché had been previously modified so it was careful to not use any more space on the frame stack than necessary if it was processing a <FRAMESTACK> error.

This change modifies that logic so it does not do this processing until after if checks that a <FRAMESTACK> error has occurred.

If a CSP page disabled journalling with a call to DISABLE^%SYS.NOJRN, then the CSP server was not resetting this; hence, the next CSP page served by this same process would be running with journalling disabled. Now, the journal state is noted and restored after each CSP page.

When you call ..Link(url) from a CSP application, it rewrites the url to add things such as the sessionId, if it is required. The code also checks for 'javascript:' at the start of the link and skips rewriting these because they are not real links but commands to execute some javascript code. The code to avoid doing this was erroneously removed by preceding development activity and this change restores it.

Windows installation on Vista and above will read and execute cbootuser.rsa the same way it does on XP. This allows for an uninterrupted installation process.

Implied grefs (global references) across ECP, or mapped globals across ECP, or the first reference to any global across ECP did not translate the gref to the remote collation consistently. This has been corrected.

In very rare conditions, ECP recovery may hang if there is an ECP server or network outage during a long string (i.e. > 32K characters) SET.

This corrects a rare situation where an ECP reply buffer may reference a a null pidtab entry.

This change adjusts the ECP application server heartbeat interval to detect an idle system network outage more accurately. A large number of async packets originated by the database server may prevent it from sending heartbeats. Decreased the app-server heartbeat interval to keep the db-server pending heartbeat count more accurate.

When the request number counter overflowed, the ECP client wrapped the request numbers to one but the server wrapped it to zero. Unexpected wrapping could cause a console log entry, drop the connection, and reconnect and recover immediately. It is an issue at sites where ECP recovery is disabled and has been fixed to be consistent in client and server.

In a very rare condition during the ECP server recovery window, if the database server failed and if the remote databases were not mounted in the same order as at startup, then ECP synchronous requests (that is, $DATA, $GET, $INCREMENT) that were being formulated at the time of the database server failure might have referred to the incorrect database number. This has been corrected.

Consequences of an incorrect database number vary (in part depending on the Caché release): the ECP daemon may crash or the request may not be directed to the correct database. In the latter case, unexpected application errors may result or (in rarer cases) incorrect data may be fetched.

Prior to this fix, if a string in excess of approximately 64KB were modified by the application server while the block which will contain the string was being sent to the same client as a consequence of an earlier request, the app server and database server would end up with different versions of that block.

%occConvert could get an UNDEFINED error when upgrading a class dictionary version in a database. This has been corrected.

A problem in the macro preprocessor has been corrected where the compiler would go into an infinite loop if expansion of a macro reference was a recursive loop. The following are examples of such recursion:

#define ABC $$$ABC
$$$ABC

or

#define ABC $$$DEF
#define DEF $$$ABC
set j=$$$ABC

If you attempt to compile such code, you will now get an error such as:

ERROR: MyRoutine.MAC(14) : MPP5649 : Too many (65535) macros referenced on this line.
This might indicate recursion in the macro definitions.

Fix incorrect string length calculation in %XML.SAX.Utils.Sequencer.

This changes corrects a problem that prevented Caché Unicode system from accepting a Kerberos connection on OpenVMS platforms.

This change closes a security hole in the $INCREMENT() and $BIT() functions. When a clustered database is configured to be read-only for a user, it gets <PROTECT> error when a SET or KILL is attempted on the database. However, $INCREMENT did not trigger the error, though it should have, and the increment occurred in the database. This only happened on the cluster slave node side.

$SYSTEM.Security.AddRoles has been updated so that

• if you have a routine which calls $SYSTEM.Security.AddRoles(), and
• you encounter an unhandled COS error in this routine while in programmer mode, and
• the routine breaks at the debug prompt,

you can no longer Call $SYSTEM.Security.AddRoles() from the debug prompt and escalate your roles outside of the scope of the application.

It is recommended that any routine or class use error handling in the procedures which call $system.Security.AddRoles().

This change also allows $SYSTEM.Security.AddRoles() to be called from user defined "Z" functions. These functions are user defined extensions to the COS language which allow commands, functions, and special variables starting with "Z" to be added to the language.

Trying to run the DisableJournaling method of the SYS.Database class would result in an <UNDEFINED> error. This has been corrected.

This change corrects an issue where a function such as $SYSTEM.Encryption.Base64Decode, when it returned a long string, could cause a memory access violation.

When the output of Base64Decode was longer than 32K characters, the length of an internal buffer was sometimes erroneously calculated leading to a potential buffer overrun.

In some situations when running an error trap after a <STORE> error, the trap routine was not loaded correctly, resulting in a memory access violation. This has been corrected.

When there is a small amount of memory available in the partition, and an exclusive NEW command is issued, there is a possibility for the memory queue to become corrupt. This resulted in a cpu loop or an access violation at some later point. This vulnerability has been corrected.

This change corrects a source of occasional crashes by Caché by fixing deviations from the stack discipline.

A problem has been resolved on 64-bit Windows machines where loading a large number of XML files sometimes caused an exception resulting in the closure of the terminal window.

In certain situations QUIT, ZQUIT and HALT commands could get exceptions triggered when Caché attempted to clean up objects which go out of scope as part of "popping" the internal execution stack. This is now fixed.

On OpenVMS, this change fixes a looping conditionthat could occur when a job was terminated abnormally while writing to principal device.

Under some rare circumstances, license server could create a circular linked list of licenses. When this happened, the license server would loop attempting to process the list, or it would attempt to write an infinitely large license report file.

This change mitigates these problems from occurring by counting the elements processed and causing the license server to exit if the number exceeds the maximum possible number of structures. The license server will be restarted automatically if this should occur. User login and logout proceed without interruption during this period.

The license server restart will rebuild the list properly.

When NWDS is configured, the configuration re-activation could take a long time at master node and caused the SMP to timed out. This has been addressed.

Previously, the ZN command executed an excessive number of ObjectScript lines while switching namespaces. This could cause a severe performance penalty to applications which used the ZN command to switch namespaces within the application. This has been fixed.

If there was an attempt to import a user into a new instance of Caché from another using ^SECURITY, and the user existed on both instances, and had a different password on each instance, then the password on the new instance would fail validation. Now, the user is deleted from the new system before the record is imported. This has the added effect of removing all the SQL table privileges for the new user (previously the user on the new instance inherited the table privileges from the user on the other instance).

There have also been performance enhancements.

Previously, if a process executed a $ZU(5,namespace) command to an implied namespace, the routine to test for the protect error was unavailable, so ZN could not be used to get back — though $ZU(5,namespace) could be used. The fix is to explicitly call the check routine with a namespace reference so it can be executed.

This build fixes an occasional memory leak in the Apache modules: CSPa[n][Sys].so/dll. The leak would occur in cases where the Gateway modules chose to forward a request on to the next module in the list (for example, requests for static files).

This build corrects a fault that could lead to CGI environment variables not being removed from the cache when no longer defined. The fault corrected with this change could occasionally result in environment variables left over from previous requests.

This change corrects a situation in the backwards-compatibility code designed to serve Caché v4.1 (and earlier) systems that could result in the premature termination of form request data exceeding 8K in size (as is often the case with forms containing TEXTAREA elements).

The original implementation of ParseString() has been restored to %XML.SAX.Parser to unforseen problems on the OpenVMS platform.

Windows installation will detect when it is running on a Windows 2008 or above cluster and install and register cluster resources.

When stepping through a routine with multi-line comments, the debugger would display the wrong line as the current line.

The arguments in the job command include the specification of an operating system directory to which a child job should switch as part of its startup. However, this is not necessarily the directory the child job will use; it may be overridden by the default directory associated with the namespace for the child job.

Furthermore, errors switching to the directory in the child job were not treated consistently across platforms. On Windows and OpenVMS, errors were ignored. On UNIX systems, the behavior varied depending on the platform and Caché version.

With this change, all platforms have now been changed to return a <DIRECTORY> error to the original job command if the child fails to switch to the specified directory.

This change assumes that references to $SYSTEM classes are correct and do not need to be syntactically checked. All $SYSTEM calls (except for ones of the form $SYSTEM.XXX(...)) are colored as OK.

Studio Assist for $SYSTEM calls works as before.

This change corrects a problem where the mapping of sub-packages used uppercase for the names rather than preserving the case of the actual name.

Under rare circumstances, ECP server initialization can fail while partway through leaving a state that may prevent later ECP recovery or clean up. When this happens, a Caché restart is required to recover.

This change prevents the initialization failure from occurring.

In very rare conditions, when the ECP Server fails unexpectedly, and an ECP client connects after dead job cleanup, a race condition can cause confusion about the job identifiers and prevent successful recovery. This correction eliminates that race condition.

When an ECP application server is shutting down, the ECP read daemon may not detect and cleanup the dead process daemon, and may end up waiting for it go away forever. This is now fixed.

This change fixes an error when using the expression $DATA(global, target) over ECP, and the data in the global has Unicode characters in it. Without this fix, the value of <target> could be set to an invalid string.

This change provides a workaround for an issue in the Xerces XML parser that incorrectly reports namespace prefixes. Details of the issue can be found at the Apache website.

In practice, this is most visible in the %XML.TextReader class where the end element node types have the wrong name. This workaround addresses the issue by internally fixing up the name when the node is accessed.

This change

• fixes %IO.FileStream.Clear() by implementing the methods TruncateAt() and ExternalByteTruncateAt()

• implements OutputToDevice() and fixes CopyFrom() to do more accurate global timeout handling when copying from a sluggish stream

• fixes missing error status arguments in some error messages, and some other error reporting issues

This change adds the aliases 'binary' and 'bin' in addition to 'rawbytes' for the RAW translation table.

It also adds 'default' in addition to 'native' as an alias for the natively active NLS translation table for the current device (as determined currently by

This fix corrects a concurrency error caused by multiple Java threads attempting to validate the cached data for a class while fetching the class definition metadata.

This change implements uptodate class checking in Java Metadata. Java projection and EJB operations now conform to how the class compiler interprets uptodate.

This corrects a problem where the Light C++ Binding incorrectly stored 0 rather than null for null properties of types %Double, %Float, and %Currency.

This change allows a %IO.DeviceStream to properly initialize its LineTerminators shadow variable using $System.Device.GetReadTerminators() rather than just using defaults as it formerly did.

Add OnPreSOAP and OnPostSOAP callbacks to %SOAP.WebService for use by Ensemble. These callbacks are internal and thus do not need to have customer documentation.

More detail may be found in the class documentation.

Change %SOAP.WebService to output %SOAP.Fault properties whose value is $c(0) as an empty string.

Any output written by a web service WebMethod will currently end up between the HTTP headers and the SOAP envelope resulting in a badly formed SOAP message. This change corrects the problem by redirecting any output from the WebMethod to the null device.

A defect has been fixed that caused locks on existing rows to be taken out when enforcing foreign key constraints when the constraint properties have not been modified. Locks are now only taken out if any of the constraint properties is modified.

With this change, after cleanup XMLNew is now supported for customer override.

• The first argument is changed from tree which is the index of the DOM in the global to document which is a %XML.Document instance. The tree may be obtained by
     set tree=document.DocumentId.

• The second argument is renamed from node to nodeId for clarity.

• This change also adds an optional third argument (containerOref) to XMLNew which is the oref of the already instantiated containing object. This allows seeing the object context when overriding XMLNew. The containerOref argument is passed by XMLImport when importing referenced objects as the containing object. The containerOref argument is "" when passed by %XML.Reader for Correlate'd objects as there is no instantiated containing object in this case.

• internal cleanup is done to use %XML.Document instead of %XML.ImportHandler so that a document may always be passed to XMLNew

A %XML.Node instance for navigating the DOM may be obtained by calling the new method of %XML.Document
   set node=document.GetNode(nodeId)

For further information, see documentation included in the method definition in %XML.Adaptor.

During an upgrade, Caché erroneously enabled some services which would have been disabled during the initial install. This has been fixed. Caché only updates the capability properties of these services (That is, types of authentications allowed for the service.)

A permission issue prevented a Caché Terminal console login from writing messages to cconsole.log on Windows Server 2008. The problem was caused by a change in the default ACL on the \intersystems\cachesys\mgr\cconsole.log file on Windows Server 2008. This is now fixed.

This change prevents a user from entering a "" (null) username and password when logging into a Visual Basic Cache Direct application, thereby authenticating as the UnknownUser when Unauthenticated access is not enabled for Cache Direct applications.

This change corrects a defect that incorrectly converted the socket number for a TCP connection when interacting with the OpenVMS socket library. The incorrect conversion resulted adding a delay of 4 seconds to each connection attempt. Attempts to use SSL for the connection would fail.

A change has been made to the SQL filer to help reduce the number of locks acquired for large updates on a table with foreign key constraints.

When a table is updated, a lock is acquired on the referenced table row for every foreign key. In the event the update is rolled back this insures old referenced rows are still valid. This logic used to lock all the rows referenced by foreign keys kicked in even if the foreign key field values did not change.

Now the system will only lock referenced rows where the fkey field(s) have actually changed. This will reduce the number of locks required for this situation in large transactions involving updates where not all fields are updated with new values.

When an outer join is removed, a parse-time structure that refers to it was not cleaned up. This caused an <UNDEFINED> reference when an outer join was removed. It has been corrected.

Uppercase accented characters of the Portuguese language were added to the character set of the %Text.Portuguese class, enabling Portuguese text containing uppercase accented characters to match with unaccented variations of the same word. The characters are: "ÀÁÂÃÇÉÊÍÓÕÔÚÜ".

During the processing of an outer join, new query blocks may be created. While most internal structures are maintained, a few that are initialized earlier by the DISTINCT optimization were not maintained. A code reorganization caused an internal structure to be uninitialized, resulting in an <UNDEFINED> error.

This is now fixed.

A query optimization that flattens a correlated SQL subquery into the containing query block produced incorrect results when the body of the subquery had unique rows, and when the correlated join condition was on a non-unique column.

This is now fixed.

This change corrects a defect where a query sent through the SQL Gateway might not return to the Caché application all the results sets selected by the query.

This corrects a problem where a Macintosh ODBC application that called SQLDriverConnect without using a DSN experienced random core dumps when connecting.

The problem was caused by accessing the ODBC.INI file via SQLGetPrivateProfileString which does not need to be used when not using a DSN to connect to the database.

When calling SQLDriverConnect without specifying a DSN, users were unable to set UNICODE SQLTYPES, STATIC CURSORS, or QUERY TIMEOUT values using the connection string key/value pairs. These values could still be specified via a DSN and its settings.

This is now fixed.

This change corrects an issue with multibyte character streams when characters containing more than one byte occur exactly at the end of an internal buffer byte location that splits the character. This caused a conversion error on character sets like those used in Japan, China, Korea.

In Japanese version (only), when a class is compiled, the output window goes into a recursive loop resizing slightly, which causes continuous repaints. This has been corrected.

When closing multiple objects (for example, via $SYSTEM.OBJ.CloseObjects), under some circumstances the system could get an access violation error.

This has been fixed.

This change corrects a situation where Studio failed while editing DTL (Data Transformation Language) documents.

This change corrects a problem where a MERGE of array nodes into a local variable, V, followed by KILL of all the array nodes, would result in $DATA(V) having a value of 10 or 11 when it should have been 0 or 1.

If a routine is running with breakpoints set, available process memory was gradually lost until unrecoverable <STORE> errors occurred. This change corrects the memory leak.

When changing namespaces, the routine target cache is cleaned up, since it is namespace-specific. This modifies the order of the target cleanup to avoid process routines encountering cache corruption and/or access violations.

If a routine switches its namespace and invokes some other routine(s) and a later invocation finds the original routine in the cache, the references to the routine source may fail (i.e. errors, debugger, or $text). This change preserves the invoking namespace when the routine is invoked from the routine cache.

This change corrects a problem in the algorithm that counts the number of CPUs and cores on Solaris. In particular, when running on some Sun Fire T1000 and T2000 configurations, counting an incorrect number of cores could result in license restrictions.

This change fixes a problem in the UnicodeLittle and UnicodeBig NLS translations that, when used with fixed length READs in TCP devices, could lead to some bytes being dropped in the connection if the translation type were changed on the fly between records.

A problem has been resolved where killing a global inside a transaction could result in a <TOO MANY LONG STRINGS> error even on systems which do not have long strings enabled.

The problem occurs on Unicode installations where the global tree being killed has more than 512 big string data values that consume more than 32767 bytes when stored in the database. Generally in order to consume more than 32767 bytes a data value needs to be fairly long to start with and it needs to contain a mix of characters from different 16-bit character sets. Users can check whether strings take up this much space by examining the # of data blocks used to store the big string values as reported by ^REPAIR. If ^REPAIR reports a length larger than 32767, then this would count as one of the 512 strings that would cause a problem.

A problem was resolved on UNIX systems where CACHETEMP fills the disk and subsequently space is made available so that the delayed writes can complete.

If Caché became idle for 5 minute the control process might incorrectly decide that the write daemon was stuck because the internal counts of how many blocks needed to be written had gotten out of sync with the number of blocks which actually needed to be written.

A longstanding defect affecting AlphaVMS and Alpha/Tru64 platforms has been resolved. It bug involved an internal stack discipline problem which rarely caused problems.

The symptoms of this defect that have been see range from spurious <STRINGSTACK> errors in extrinsic function calls to seemingly-random access violations. The issue was that a post conditional expression which was evaluated as a boolean not would leave an extra argument on the operand stack in the case where it executed the "skip" case.

The WMI server code in Caché was not recognizing SNMP Trap IDs for LicenseExceeded or DCP errors, which could possibly cause events to get stuck in the system queue.

This has been corrected.

cstat has been enhanced to allow it to perform self-diagnostics for many types of system hangs.

When the -S option is selected, cstat first attempts to determine if the system is hung in a way that can be self-diagnosed. If it is hung in that way, then it examines the system state in effort to identify the cause of the hang.

Informational messages are output reporting the progress of the self-diagnosis and any relevant recommendations to the user. Finally, a list of processes is reported which are suspected of causing the hang at that Caché system level. Each process reported may be in one of several possible states. The states reported and their meanings are as follows:

• SUSPECT
  Processes in this state are suspected of causing the hang. These processes should be investigated with debugging tools native to the operating system or dumped with user-mode process dumping tools in order to determine their state.

• EXONERATED
  Processes in this state were suspected of causing the hang, but were determined to be waiting for another process, thus are not likely to be the cause of the hang. Processes in this state typically do not need to be investigated further.

• DEAD
  Processes in this state are suspected of causing the hang and additionally are believed to have exited at the operating system level. Typically no further investigation of these processes can be done.

• LOSTWAKE
  Processes in this state are suspected of causing the hang. Additionally, they are believed to be hibernating and have failed to be awoken by another process. These processes should be investigated with native operating system debugging tools like jobs in the SUSPECT state. It may be possible to resume the system by sending a wakeup to these processes using cstat -P<job#>

As an example a hang with IJULOCK set and an updater waiting for a global buffer would produce self diagnostic output like this:

Beginning hang self-diagnosis
Updates are blocked because ijulock is set
System is waiting for the WD (job 2)
  WD (job 2) has set ijulock and is waiting for updaters to finish
    Updater job 27:
     Job 27 is waiting for bdb #9411
     bdb #9411 is in use by job 13
     Job 13 is suspect
     Job 27 is exonerated
     Job 2 is exonerated

Summary of Job States: {state: [job#:pid[|tid] [...]]}
SUSPECT: 13:5353
EXONERATED: 2:5298 27:5357
DEAD:
LOSTWAKE:

Note that not all types of hangs necessarily result in having any processes requiring further investigation.

In a Caché cluster, the cstat self-diagnostics should be run on all cluster members. It is possible that one cluster member may appear to be hung before the others. Typically, within 10 minutes, the other members become hung because the write daemons time out while trying to synchronize with the other nodes. For this reason, the self-diagnosis may not detect the hang on one or more nodes of the cluster until this timeout has expired.

Additionally, this change adds a new bit 2048 to the cstat -p option. When the 2048 bit is on, the file number and block number of each process's retained buffer is displayed.

There are two general types of tools native to the operating system that can be used to investigate the suspect processes: user-mode process dumping tools and user-mode debuggers. To gather comprehensive information about a suspect process, use a user-mode process dumping tool. The resulting dump file can be very large, but contains the entire state of the suspect process. Other debugging tools can gather key information without needing to produce a large output file. Often using multiple tools in conjunction is desired.

User-mode process dumps by platform:

• Windows:
  The Userdump utility is provided and documented by Microsoft http://support.microsoft.com/kb/241215

• UNIX:
  For Solaris, Linux,and HPUX: use gcore
  For AIX: use gencore
  kill -11 may be used to cause the process to terminate and core (invasive)

• OpenVMS:
  SET PROCESS /DUMP=NOW /ID=

When a job is terminated abnormally, there is a chance that the job could get into a CPU loop. This change prevents that possibility.

This change corrects an error that occurred when a job exhausts its heap memory space while trying to set up its cache of recently-used global subscripts.

This change fixes an access violation that can occur on Caché when using a MERGE command with two local arrays.

This change fixes a possible <STRINGSTACK> error when exporting an object that contains large arrays.

If a cluster slave crashes or is forced down when the master has one or more active ECP connection, cluster recovery may leave the cluster in a partially recovered state and prevent the slaves from restarting and joining the cluster. Slave restart may assume the master is middle of ECP recovery, and wait forever for the master to finish the recovery.

This change corrects the issue.

This affects systems which support clusters (for example, all OpenVMS versions and the Tru64 version with cluster support) regardless of whether the Caché instance is part of a Caché cluster or not.

An error has been fixed where, in very rare circumstances, an attempt to expand the database could get an access violation or could enter an infinite loop syslogging errors during the expansion of a non-cluster mounted database. The error code syslogged is 8484 (0x2124) in module #16.

When system is set to freeze on journal error and journaling fails to start at startup, startup aborts rather than continues on.

The problem present in 5.1 and later releases; it is corrected by this change.

This corrects a situation where a process (synchronous TCOMMIT, ECP daemon, write daemon, etc.) waiting for the journal daemon to commit the journal up to a certain offset could get stuck indefinitely (depending on the journal activity volume on the system).

This occurred in rare circumstance that involved a journal switch before the wait. The problem affected only Caché systems that saw very little journal activity and used small-sized journal files (as a result of either journal file max size being set to very small or journal files being switched frequently by the user).

This change addressed an issue that could cause rollback of a SET whose new and old values are strings of significant lengths (that is, close to 32KB), to fail.

This change corrects the following limitations regarding the affect of TROLLBACK on TCP devices:

• TROLLBACK could clear the user-specified line terminators of current TCP device

• It would suppress the <DISCONNECT> error during rollback only if current device is TCP and has the D mode turned on. It would not suppress the <DISCONNECT> error during rollback
  • if the current device is NOT TCP, or

  • the current device is TCP but doesn't have the D mode turned on

This correction addresses an issue where a change to JournalFilePrefix property made in the configuration parameter file (.cpf) did not take effect even after Caché restart and might get overwritten by subsequent journal switch.

This only involves changes made to the file; changes made via ^JRNOPTS or MgtPortal took affect as expected.

The defect was present in releases 5.2.4 and later.

This corrects a problem that prevented creating the permitted number of databases with an Entree license.

This correction changes the license accounting algorithm so the built-in databases of an Ensemble installation are no longer counted as part of the database limit for E2 (Entree) and E4 (Elite) license keys.

This change fixes a network lock problem where a ECP/DCP client job could hang when it has a node locked and another job locked the parent node of the one it had locked.

This change reworks the prefetching algorithm to improve performance of shadow dejournaling.

This change fixes a transaction error that can occur when a pending transaction does SET or KILL over multiple remote ECP systems. Under these circumstances, the ECP daemon on a remote ECP remote system may fail, or cause the transactions to be out of synch on the ECP server.

This problem only occurred when set/kill is done on two different ECP remote system.

The function, $SYSTEM.Security.AddRoles() can no longer be called from the command line, or from within the debugger. Doing so could allow a user to inadvertently leave their process with elevated roles when the call returns. Calling the method in this way will fail to elevate the roles, and the error

ERROR #940: Insufficient privilege for operation

will be returned as the value of the function.

This change makes the MGR directory the assumed default directory in cstat. It is no longer necessary to add "-s." on the command line.

This change modifies the NLS setting in WebLink so that it will always read multipart MIME content (such as uploaded files) in "RAW" mode.

This change was made because it was found that binary data would not upload correctly if the WebLink base NLS setting (as set in the 'NLS_Translation' parameter) was set to a multi-byte character set (e.g. SJIS).

The visible symptom of this was fault was file uploads stalling and timing-out.

The Zen Page class defines a parameter, RESOURCE. This is the name of a resource on which the user must hold USE privilege in order to use the page.

With this change, the RESOURCE parameter can contain a comma-delimited list of resource names. The user must hold USE on at least one of the given resources to use the page.