Event Log Notifications

Message generators and message servers use the application event log to report events in two general scenarios. Any errors that prevent a process from successfully executing PBInitialize (implicitly or explicitly) or PBUninitialize must be reported to the event log since that process cannot generate log messages. Additionally, notification of events that may affect the system's ability to deliver messages will be directed to the event log because internal notifications may be lost.

Event log messages contain nine fields. Date, time, user, and computer name are filled in by the operating system when the message is generated. The additional fields appear as follows:

On Windows 95/98, the event log does not exist, so a text file, currently named PB9x.log, is used. This file's location is specified by the event log directory registry setting. Each event logged to the file should contain the same information as an NT event log entry, except for the user and computer name fields. If the message server file cannot be located by a message generator when it needs to log an event, the event number, category number, and parameters will be logged. The message text for each event can be found below. If an event cannot be written to the text file for any reason, the OutputDebugString API will be used as a last resort.

The messages that may be logged to the application event log are listed next. In some cases the messages will have detailed information inserted into them and this is indicated in the format <placeholder>. In the case of <Windows error string> below, this indicates a string obtained from the operating system by calling the functions GetLastError and FormatMessage in succession. Occurrences of <socket error number> refer to an error code defined in the header file winsock2.h or in some cases Paul Bunyan specific socket error codes.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Unable to initialize security descriptor: <Windows error string>

Remarks: In the exhaustive testing that has taken place, very few Windows API functions are guaranteed not to fail. InitializeSecurityDescriptor is not one of these. For whatever reason, this function may fail, and if so the library cannot be initialized.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Named mutex creation failed: <Windows error string>

Remarks: The library uses named semaphores and events to synchronize resources across process boundaries. If another application chooses names that conflict with Paul Bunyan’s, the Paul Bunyan kernel objects are unable to be initialized. Diamond Sierra has taken measures to ensure that the chosen names are likely to be unique.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Another thread in the same process already failed to initialize.

Remarks: Each module must initialize the library once per process, and all threads then share some global variables. Since PBInitialize is called automatically the first time any library function is used, the initialization may be executed by any thread in the calling process. It’s even possible that two threads can try to initialize at essentially the same time. A semaphore is used to serialize calls to PBInitialize, so in this rare case, the first thread in will perform the initialization while the second thread waits. If initialization succeeds, both threads are now ready to log. If initialization fails, the second thread will not attempt to perform initialization, but will bail immediately. (All subsequent PBInitialize calls in that process will also fail immediately.) In the case of a thread race to initialize where initialization fails, the first thread will log the specific error message. The thread that lost the race will log this message. The message is included only for completeness; it should always be accompanied by another message and the only additional information carried by this message is that there were, in fact, two threads trying to initialize simultaneously.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. An unknown error has occurred.

Remarks: This message indicates a bug in Paul Bunyan and should be reported immediately.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Mutex wait failed: <Windows error string>

Remarks: This message occurs when the Win32 API function WaitForSingleObject fails. This could occur in a process that has corrupted its own memory space, in which case the Windows error string should indicate an invalid handle was used.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Named event semaphore creation failed: <Windows error string>

Remarks: The library uses named semaphores and events to synchronize resources across process boundaries. If another application chooses names that conflict with Paul Bunyan’s, the Paul Bunyan kernel objects are unable to be initialized. Diamond Sierra has taken measures to ensure that the chosen names are likely to be unique.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Unable to open IPC buffer (path specified by registry entry <HKEY_LOCAL_MACHINE\etc\IPC buffer directory>): <Windows error string>

Remarks: The IPC buffer is implemented as a memory-mapped disk file. The path to this file must be specified in the registry. This error message indicates a simple disk I/O failure. The most common causes are that the path is invalid or the generator or message server that is initializing does not have adequate permissions to access the file. Note that since the message server is implemented as an NT service (or loaded before logon on 9x), this path cannot contain any network components such as UNC paths or mapped drives. The Windows error string should give detailed information on the cause of the failure.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Unable to open IPC buffer (path specified by registry entry <HKEY_LOCAL_MACHINE\etc\IPC buffer directory>): the file is missing.

Remarks: This error indicates that two processes were trying to initialize the library at the same time, the IPC buffer disk file did not exist, and the first process failed to initialize. The process that got there first will try to create the IPC buffer disk file. If this process subsequently fails to initialize, this process will, clean up and delete the disk file. Meanwhile, the second process sees that another process had already started to initialize the shared resources, and yet when the second process gets to the part about the disk file, it finds that it doesn’t exist. That’s when the second process logs this message. This error is extremely unlikely. This message is only included for completeness; the first process that failed to initialize will log the actual cause of the initialization failure.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Disk error while accessing IPC buffer: <Windows error string>

Remarks: This error indicates a disk I/O failure during initialization, most likely due to a bad hard drive.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Insufficient disk space to create IPC buffer (path specified by registry entry <HKEY_LOCAL_MACHINE\etc\IPC buffer directory>) at size specified by registry entry <HKEY_LOCAL_MACHINE\etc\Shared mem file size>: <Windows error string>

Remarks: Free up some space on the disk or reduce the IPC buffer size configuration setting.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Unable to create file mapping object: <Windows error string>

Remarks: Indicates a failure of the Win32 API function CreateFileMapping. The Windows error string should give a description of the error. Report this error to technical support for suggested resolutions.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Unable to map view of file mapping object: <Windows error string>

Remarks: Indicates a failure of the Win32 API function MapViewOfFile. The Windows error string should give a description of the error. The most likely cause is insufficient memory available to view the IPC buffer. In this case, reduce the registry entry for IPC buffer size. Otherwise report this error to technical support for suggested resolutions.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. The path specified by registry entry <HKEY_LOCAL_MACHINE\etc\IPC buffer directory> contains too many characters.

Remarks: In Windows NT/9x, file path names can contain a maximum of 260 characters (or so). If the registry entry is a valid path, this error should not occur.

Message text: The Paul Bunyan library could not be initialized by process <process name>, module <module name>. Invalid operating system or GetVersionEx failed: <windows error string>

Remarks: The library uses several operating system specific features. If code built with the library is run on an unsupported OS, initialization will fail and the error string will read "This operating system is not supported." If the error string reads differently, the library was unable to validate the operating system.

Message text: The Paul Bunyan library found an invalid value for registry entry <registry key/value name>. The default value <default string> will be used.

Remarks: Registry entries such as IPC buffer size are not required for initialization; a suitable default value will be used instead. This situation will not generate a warning. If, however, an invalid entry is specified, a warning will be issued to indicate that the default value will be used in place of the specified one.

Message text: The Paul Bunyan library encountered an error while reading registry value 'Next IPC buffer directory': <windows error string> The IPC buffer cannot be moved; the old location will be used.

Remarks: When a configuration specifies that the IPC buffer be moved, the library uses the registry to coordinate the move between generators and the message server. If an error occurs while moving the buffer, it may still be possible to use the old location. If not, number 107 will be logged indicating that the library could not be initialized.

Message text: The Paul Bunyan library encountered an error while initializing the file specified by registry value 'Next IPC buffer directory': <windows error string> The IPC buffer cannot be moved; the old location will be used.

Remarks: When a configuration specifies that the IPC buffer be moved, the library uses the registry to coordinate the move between generators and the message server. If an error occurs while moving the buffer, it may still be possible to use the old location. If not, number 107 will be logged indicating that the library could not be initialized.

Message text: The Paul Bunyan library encountered an error while intializing the file specified by registry value 'Next IPC buffer directory': <windows error string> The registry could not be updated.

Remarks: When a configuration specifies that the IPC buffer be moved, the library uses the registry to coordinate the move between generators and the message server. If an error occurs updating the registry, the previous disk file for the IPC buffer may be orphaned. Any data remaining in the file will be lost and the file will not be deleted.

Message text: The Paul Bunyan message server could not be initialized. RegisterServiceCtrlHandler failed: <Windows error string>

Remarks: This error indicates that the message server is not correctly installed. Run the Paul Bunyan setup program to rectify this error. If the situation persists, contact technical support.

Message text: The Paul Bunyan message server could not be initialized. Event creation failed: <Windows error string>

Remarks: The message server uses kernel objects such as events for thread synchronization. The operating system reserves the right to deny creation of these objects. The most likely causes are lack of available resources or invalid security permissions. The Windows error string should give a detailed explanation of the cause. For any other cause than an overloaded machine, contact technical support.

Message text: The Paul Bunyan message server could not be initialized. Cannot access registry value <registry key/value name>: <Windows error string>

Remarks: The message server requires two values from the registry to operate: IPC buffer directory and Config path. If either of these value names does not exist under the base key, the service will fail to load and log this message. Running the Paul Bunyan setup program will create all required registry entries. After installation, these values can be configured with the message viewer. Note that if this message is seen with the registry key/value name parameter of IPC buffer directory, all generators will silently fail to initialize on that machine as they will interpret that to mean that PB is not installed.

Message text: The Paul Bunyan message server could not be initialized. Socket initialization failed, Windows error: <Windows error string> Socket error <socket error number>.

Remarks: This message indicates a failure of the TCP/IP implementation. The message server requires TCP/IP to be properly installed. If TCP/IP is installed and this error occurs, contact technical support.

Message text: The Paul Bunyan message server could not be initialized. Failed to initialize listener socket: <socket error number>.

Remarks: While this message may indicate a temporary network failure or a lack of system resources, the most likely cause is a port conflict. If the problem persists, the Port configuration setting may require modification. Note that this will require modifying the connection settings in all viewers that connect to the message server. It is recommended that, if possible, all machines on a network use the same Port value.

Message text: The Paul Bunyan message server could not be initialized. Thread creation failed.

Remarks: Indicates an internal failure while loading the message server. If this situation persists, contact technical support.

Message text: The Paul Bunyan message server could not be initialized. Wait for thread creation failed: <Windows error string>

Remarks: Indicates an internal failure while loading the message server. If this situation persists, contact technical support.

Message text: The Paul Bunyan message server could not be initialized. StartServiceCtrlDispatcher failed: <Windows error string>

Remarks: The server failed to register itself as an NT service. This could indicate an installation problem. This notification will be logged if the server is run on Windows NT as an ordinary process rather than as a service.

Message text: The Paul Bunyan message server could not be initialized. COM initialization failed: <Windows error string>

Remarks: CoInitialize or CoInitializeEx failed. This shouldn't happen.

Message text: The Paul Bunyan message server could not be initialized. Cannot open configuration file specified by registry entry 'Config path': <Windows error string>

Remarks: The bulk of configuration information for the message server is saved in a binary file. The path to this file is specified in the registry. If the path is invalid or the file does not exist, the message server will abort. See the message server configuration section for instructions on how to restore this file. Note that the path should not contain any network elements or mapped drives since it must be accessed at boot time. On Windows NT, the system account must have valid permissions to access the file.

Message text: The Paul Bunyan message server could not be initialized. The configuration file specified by registry entry 'Config path' is corrupt.

Remarks: This message indicates that the configuration file can be opened but can not be interpreted. Either the file was not created by Paul Bunyan, or a disk error has occurred. See the message server configuration section for instructions on how to restore this file.

Message text: The Paul Bunyan message server could not be initialized. The configuration file specified by registry entry 'Config path' is an invalid version.

Remarks: This message indicates that the configuration file can be opened and interpreted, but that the version of the file is incompatible with the version of the message server. See the message server configuration section for instructions on how to restore this file.

Message text: The Paul Bunyan message server encountered an error while shutting down. One or more threads were forcibly terminated.

Remarks: If we’ve done our jobs, this error should not occur. The message is included in case we’ve screwed up. The most likely scenario where this situation could occur is if a viewer is connected to the message server and the message server is shut down. Normally the connection should be closed by the message server. If the message server is in the middle of sending a large bundle of log messages, it should abort that operation and still close the connection. If for some reason the socket operation cannot be escaped from, the thread in the message server responsible for shutting down will have to kill the thread involved in the send. An analogous situation could occur with a message handler. Contact technical support if you see this message.

Message text: The Paul Bunyan message server was unable to complete its shutdown routine.

Remarks: When Windows NT shuts down, it notifies all services that they are to stop and gives a fixed amount of time for them to comply. Any services that don’t comply are forcibly terminated by the operating system. The most time consuming task the service must perform at shutdown is to save its cache file. If this error occurs, try reducing the configuration setting for Message server cache size. If the situation persists, use the Services applet in control panel to stop the Paul Bunyan service without shutting down the operating system. If the service terminates normally but takes more than about 20 seconds, there’s a problem. It is possible, however, to configure NT to give more time to all services to shut down by modifying the WaitToKillServiceTimeout registry value under the HKLM\System\CurrentControlSet\Control key. (Consult your Windows NT documentation for further information (or just go do it…).) If no other error notifications occur and reducing the cache size or increasing the timeout allowance does not fix the problem, contact technical support.

Message text: The Paul Bunyan message server was terminated abnormally and did not execute its shutdown routine.

Remarks: This notification will be logged at message server start after an abnormal shutdown. The most common cause is a cold restart of the operating system. Since the message server did not get a chance to shut down, the cache will be lost. (There may still be messages in the IPC buffer.) This notification will usually be accompanied by notification number 301.

Message text: Paul Bunyan is unable to obtain licensing information and will abort. Run the setup program to restore licensing information for this computer. If you continue to have problems, please contact technical support.

Remarks: The setup program stores copy protection information. If the message server cannot access this information, it will log this error and abort.

Message text: Paul Bunyan is unable to validate licensing information and will abort. Run the setup program to restore licensing information for this computer. If you continue to have problems, please contact technical support.

Remarks: The setup program stores copy protection information. If the message server cannot validate this information, it will log this error and abort.

Message text: The Paul Bunyan message server could not access registry entry <registry key/value name>: <Windows error string> The default value <default string> will be used.

Remarks: This message indicates that a non-required registry entry does not exist. It will only be logged for registry entries that are normally written by the Paul Bunyan setup program. If this message occurs, somebody’s been messing with the registry.

Message text: The Paul Bunyan message server could not obtain a working set large enough to accommodate memory use specified in the configuration file: <Windows error string> Reduced performance may result.

Remarks: The message server attempts to adjust its page file usage to match the memory parameters specified in the configuration under Message server average mem. This message indicates that not enough memory is available to ensure a minimum of swapping memory to disk. This is not a critical error, but it may indicate that the machine is overloaded. Try reducing the registry setting or reducing the load on the machine.

Message text: The Paul Bunyan message server could not access registry entry <registry key/value name>.

Remarks: This message is logged when the message server can’t find state information that it stored in the registry. It only indicates a serious situation if it occurs repeatedly.

Message text: The Paul Bunyan message server configuration values for IP, port could not be used: <socket error description>. An attempt will be made to use the last known good values.

Remarks: This message indicates that the listener socket could not be created because the configuration is invalid. If the configuration has been changed, the server will attempt to revert to the previously used values. This at least could allow upload of a corrected configuration. Configurations can also be saved as disk files and placed at the location specified to the setup app. If no previous value exists or the previous value cannot be used, notification 207 will be logged and the message server will abort.

Message text: The Paul Bunyan message server could not open its cache file: <Windows error string>

Remarks: Several scenarios can lead to this message. The net result of any of these situations is that all log messages in the cache are lost. Any viewer or message handler that was receiving messages before the last shutdown should already have received all those messages. One cause of this problem is if the shutdown procedure could not be completed. In that case event log message number 221 should also be logged. Another common cause of this error is when the operating system was not shut down properly due to a power failure or a hard stop. The message server then has no opportunity to save its cache. If you’re trying to debug a device driver or other process that is stopping the operating system, you’ve got problems because it's likely that any log messages generated just before the crash will be removed from the IPC buffer and placed in the message server cache and subsequently lost. In this scenario the best bet is to stop the Paul Bunyan service through the control panel Services applet (or the PB Message Server Control applet on Windows 95/98) and re-try the test. Then the messages will be left in the IPC buffer and with any luck the operating system will flush the buffer to disk and the messages can be recovered at the next reboot. If this message occurs without any accompanying messages and after a normal shutdown and restart, the most likely cause is that the "message server cache directory" specified in the configuration file is invalid. Note that this value cannot contain any network elements (UNC paths or mapped drives) and the system account must have valid security permissions to access the file. See the message server configuration section for instructions on how to restore this file.

Message text: The Paul Bunyan message server could not interpret its cache file: <Windows error>

Remarks: This message indicates that the cache file could be opened, but could not be successfully read or written. It could occur at startup if a new version of Paul Bunyan was installed but the cache file was not converted properly. Otherwise it’s pretty likely that a disk error occurred or somebody’s been messing with the file.

Message text: The Paul Bunyan message server encountered a memory exception while reading/writing the cache file. The existing cache was lost.

Remarks: Insufficient RAM was available to initialize the cache. Reducing the configuration entry for "message server cache size" may alleviate this problem. This could also be indicative that the machine is severely overloaded and needs either more page file space or less work to do.

Message text: The Paul Bunyan message server could not save its cache at shutdown and attempted to use the last known good cache file location.

Remarks: Indicates an error writing the cache. The message server will attempt to use a previous location if one is available in order to avoid losing the cache. If this message is accompanied by notification 351, the cache will be saved to the old location and can be recovered. This is not a permanent fix for the problem since the message server will continue to attempt to use the invalid location. To fix this problem, edit the configuration to establish a valid value. Note that this value can’t contain any network elements (UNC paths or mapped drives) and the system account must have valid security permissions to access the file.

Message text: The Paul Bunyan message server could not save to new cache file but the last known good cache file location was used successfully.

Remarks: Occurs in conjunction with notification 350 or 353. When unable to read/write the cache file, the message server will attempt to use a previous location if one is available. This is not a permanent fix for the problem since the message server will not be able to locate the cache the next time it starts. To fix this problem, edit the configuration to enter a valid value. Note that this value can’t contain any network elements (UNC paths or mapped drives) and the system account must have valid security permissions to access the file.

Message text: The Paul Bunyan message server could not save to the new cache file location and the last known good cache file location could not be used either. The cache could not be saved.

Remarks: Occurs in conjunction with notification 350. The configuration contains an invalid cache file location and a location that was used successfully before could not be used either. This probably indicates a change in directory structure or a bad disk.

Message text: The Paul Bunyan message server could not read its cache file at startup: <windows error string> An attempt will be made to use the last known good cache location.

Remarks: At startup, the message server looks for the cache it stored at shutdown using the location specified in the configuration file. This could fail if there is a disk problem or an invalid location is specified in the config. The server will attempt to retrieve its cache from a previous location if one is available. If this fails also, notification 301 will be logged.

Message text: The Paul Bunyan message server was unable to process a socket connection request: <socket error number>.

Remarks: Indicates either a network failure or a resource overload.

Message text: Client socket error in Paul Bunyan message server: <socket error description>

Remarks: This error indicates a socket connection was lost in the message server. This could result simply from a failure to allocate memory, a network failure, or various other causes.

Message text: Wait object failure in Paul Bunyan message server: <windows error string>

Remarks: The message server uses windows synchronization objects to coordinate its various threads with each other and with message generating processes. If a wait fails, the server will terminate and log this error. This has never happened.

Message text: The Paul Bunyan message server was unable to save an uploaded configuration: <windows error string>

Remarks: Message server configuration gives the ability to upload configuration information to a message server. If an error is encountered while saving the configuration to disk, the old configuration will be restored, an error will be returned to the message viewer performing the upload, and this message will be logged.

Message text: After an uploaded configuration could not be saved, the attempt to restore the previous configuration file from the backup '<temp file path>' failed. The message server will fail to start until a valid configuration is put in place.

Remarks: Occurs in conjunction with notification 405. If an error is encountered while saving an uploaded configuration and the old configuration cannot be restored, the message server will be left unbootable. Note that this scenario is extremely unlikely unless there is a hardware problem.

Message text: The Paul Bunyan message server could not be started: <windows error string>

Remarks: There are several scenarios where an attempt is made to start the message server from code: when processing an uploaded configuration with the restart option enabled, when the setup application installs the server, when the server control utility is used on Windows 95/98, or when a shutdown is cancelled on Windows 95/98. In any of these scenarios, this message is logged when the code attempting to start the message server encounters an error. The message server will remain stopped.

Message text: Warning: current conditions are taxing available resources. Messages may be lost if the IPC buffer size is not increased.

Remarks: The registry setting for IPC buffer size fixes the maximum amount of messages that can pile up before they start getting lost. Under calm conditions, the message server will clear the IPC buffer whenever something shows up. But the message server is designed to operate in the background and not interfere with other things happening on the machine. If large demands are put on the CPU or if large volumes of log messages are generated in a short period of time, the IPC buffer will fill up and logging will fail. We can’t let that happen, can we? Of course, we’ll notify you with message 1004 when messages have been lost, but that’s too late. This message and its corresponding internal message 1017 are here to let you know before messages are lost. The notification is generated when the IPC buffer is “nearly” full. (We reserve the right to define “nearly” any way we please.) That way you can increase the size and avoid the tragic loss of beloved log messages. We recommended if you see this message to double the size of the IPC buffer until it goes away. (Note that this may require also increasing the configuration setting for "message server average mem" since it should be larger than the IPC buffer size, and consequently the configuration setting for "message server max mem" to avoid pausing.) Note that this message will only be logged once per service start. If you ignore it and lose messages, you had your warning. The setting can be edited directly in the registry or through remote configuration. The resize will not take affect until all users of the IPC buffer (generators and the message server) are shut down, so a reboot is recommended.

Message text: Register service process failed. The message server will terminate if a user logs off.

Remarks: Windows 95 only: The message server uses the RegisterServiceProcess API to facilitate running when no user is logged on. If this call fails, the message server will terminate if a user logs off without shutting down Windows.

Message text: Paul Bunyan Message server memory use exceeded <number> bytes. New data processing suspended.

Remarks: The message server needed to use more memory than that specified by the configuration setting "message server max mem." This will occur if log messages are generated faster than they can be processed (e.g. somebody messed up and is logging in an infinite loop) or if the CPU is severely overloaded and the low-priority service threads can’t get sliced in. The message server will let messages pile up in the IPC buffer until it has time to process and delete the messages it has already retrieved. Forwarders will also be cut off until conditions return to normal. If the IPC buffer subsequently is filled, messages will be lost and a notification message (1004) will be generated once the message server has reduced its memory load. Forwarders may also report a rolloff notification (1305) if the connection is interrupted for too long. The best resolution to this problem is to reduce the volume of messages being generated and/or reduce the traffic on the machine. If the machine has lots of page file space, increasing the relevant configuration setting and restarting the message server will (temporarily at least) prevent this situation.

Message text: Paul Bunyan Message server memory use reduced to normal levels. Data processing resumed.

Remarks: This message will always be paired up with number 450. It indicates a return to normal processing.

Message text: An unhandled exception of type <exception code> occurred in <process name>.

Remarks: This error indicates a bug in the message server. The message server will abort. It is our vowed intention to eliminate all such errors, so if you see this, please let us know.

Message text: An unhandled exception of type <exception code> occurred in process <process name> while module <module name> was logging in pb*.lib.

Remarks: This message indicates an unusual occurrence in a message generator and will result in the termination of the generator process. The message will only be logged if the exception occurs while the generator is executing one of the Paul Bunyan library functions. This could indicate several things. It could be a bug in the library code, in which case we’d like to hear about it promptly. It’s more likely, though, that it’s a problem that was not caught by the generator. It’s certainly not our intention that logging calls need to be wrapped in exception handlers. For that reason the library code traps access violations (the most common exception by far) locally and simply generates a notification message (1006) and allows the process to continue. Other exceptions, however, may be indicative of a hardware problem (e.g. bad RAM) or a software bug (e.g. stack overflow). We don’t want to hide these problems from a generator, so we don’t trap them locally. A generator has every opportunity to trap this sort of error locally, in which case Paul Bunyan will do nothing at all. Unfortunately when exceptions occur that are not caught by the generator, the operating system default behavior is to show a message box to the user. Since generators may be running on production boxes or servers with no user around to clear the message box, the misbehaving process (or victim of a hardware fault) could be left holding the shared library resources indefinitely. This is unacceptable since any other generators running on the machine could be suspended until the message box goes away. So we simply replace the message box with an event log entry. Either way the unfortunate process is going to be killed and the resources freed up. If your process really, really needs to be informed of unhandled exceptions when they occur, you can override this behavior with the function PBSetUnhandledExceptionFilter. Finally it is worth noting that this message can occur not only because a thread executing a library function throws an exception, but also if another thread in the same process throws an unhandled exception while a thread is executing a library function. This is not terribly likely since Paul Bunyan library calls take very little time, and it’d be quite a coincidence if another thread dies exactly when a thread is in the lib. Again in this case, all we do is replace the OS message box with an event log entry.

Message text: The Paul Bunyan message server was not able to allocate memory and is aborting.

Remarks: Indicates that memory allocation failed in the message server during its initialization process. Critical resources could not be obtained so the server can’t load. This is most likely due to an overloaded machine.

Message text: The Paul Bunyan message server was not able to allocate memory. Data was most likely lost.

Remarks: This message occurs when the message server is not able to allocate memory while attempting to distribute messages. This could occur at any stage of data processing. In some cases processing will simply be delayed and no data lost, but you might as well count on missing something. This message indicates an improperly configured machine. While the ideal solutions would be to (1) go out and buy more RAM, (2) reduce the load on the machine, or (3) increase page file space, that’s not always practical. Lowering the configuration setting "message server average mem" may help some since the message server will attempt to purge messages sooner. A better solution is to lower the setting for "message server max mem." This setting was added for just this purpose. If log messages are generated faster than they can be distributed, a backlog will be created. The only way to resolve this is to stop processing new messages until the current ones can be dealt with. The basic idea is to set the max mem low enough that there’s always enough page file space for the server’s needs. Memory allocation will never fail in the message server. Of course if the max mem value is reached and the server stops processing new messages for a long enough period, the IPC buffer will fill up and messages will be lost, but this is a much better scenario than having memory allocations fail in the server. This way rather than going to all the work of creating new messages just to have them tossed later, the generators don’t even bother to create them. This reduces the load on the already overloaded machine and lets things get back to normal as soon as possible. Even if we do say so ourselves, this is rather an elegant solution. The inability to allocate memory in the message server process is transferred to the generator processes, who are the cause of the problem in the first place. They were, after all, creating more data than the machine could process. Finally note that the value for "message server max mem" is required to be at least twice the average mem setting. Internal message 1013 is also generated.

Message text: The Paul Bunyan message server was unable to process a socket connection, message handler, or forwarding request: insufficient memory.

Remarks: This message indicates that memory allocation failed in the message server while a viewer or forwarder was attempting to connect to it or a message handler was being loaded. The other side will see the connection fail. See notification number 504 for suggestions on how to deal with this error.

Message text: <insertion string>

Remarks: Reserved for future use.

Message text: The Paul Bunyan library could not be uninitialized by process <process name>, module <module name>. Unable to initialize security descriptor: <Windows error string>

Remarks: In our experience, we’ve only seen one Windows API function that’s guaranteed not to fail. InitializeSecurityDescriptor is not it. For whatever reason, this function may fail, and if so the library cannot be initialized. If you see this message, congratulations! You’ve won the lottery.

Message text: The Paul Bunyan library could not be uninitialized by process <process name>, module <module name>. The operation timed out.

Remarks: This message indicates that the library resources used by a generator or message server could not be cleaned up. Library functions will still be disabled, but resources such as kernel object handles will not be cleaned up until the indicated process terminates. There are two distinct scenarios that can lead to this notification. If one thread is attempting to execute the PBUninitialize function while another is still trying to execute library functions, the uninitializing thread will wait for the time period specified in the dwMilliseconds parameter to that function, and then abort the attempt to perform cleanup. Also if a thread has ended execution (e.g. TerminateThread was called) while it was executing a library function, an internal reference count will be incorrect and PBUninitialize can never complete, regardless of the timeout value specified. To distinguish between these cases, specify a large timeout. (One second should be more than enough but if INFINITE is specified the uninitializing thread may hang forever.) If the notification recurs despite a lengthy timeout, it’s likely that a thread is dying violently somewhere. If a long timeout fixes the problem (note that there are thread timing issues involved and so the problem may occur only intermittently), this indicates that PBUninitialize is being called while multiple threads are still trying to use library functions. It’s recommended that PBUninitialize be called only by the main thread in the module after all other threads have had a chance to finish what they are doing. See the documentation of that function for more information.

Message text: The Paul Bunyan library could not be uninitialized by process <process name>, module <module name>. Event wait failed: <Windows error string>

Remarks: This message indicates that PBUninitialize aborted because the Win32 API function WaitForSingleObject failed for a reason other than expiration of the timeout period. This could occur if the calling process has corrupted its memory space to the extent that the calling thread’s stack is unreliable, in which case the Windows error string should indicate an invalid handle. Contact technical support if you cannot resolve this error.

Message text: The Paul Bunyan library could not be uninitialized by process <process name>, module <module name>. Mutex wait failed: <Windows error string>

Remarks: This message occurs when the Win32 API function WaitForSingleObject fails. This could occur in a process that has corrupted its own memory space, in which case the Windows error string should indicate an invalid handle was used. It’s also remotely possible that this indicates a bug in our code, in which case we’d like to hear about it.

Message text: The Paul Bunyan library could not be uninitialized by process <process name>, module <module name>. Named event semaphore creation failed: <Windows error string>

Remarks: PBUninitialize uses an unnamed event to synchronize cleanup across threads. The only reason the Win32 API function CreateEvent should fail is if the machine is so overloaded that a handle cannot be allocated. The actual occurrence of this message is unlikely, but it is included for completeness.

Message text: Attempt by process <process name>, module <module name> to access the Paul Bunyan library after PBUninitialize was executed.

Remarks: Indicates failure of one or more API functions because PBUninitialize was called previously. The message will only be logged once per module, regardless of how many API calls are made after cleanup. If the ulOptions parameter to PBUninitialize specifies the PB_UNINIT_SILENT flag, this message will not be generated. This message could indicate the loss of one or more log messages because uninitialization was carried out too early. It could also result from a destructor of a global CPBComponent or CPBContext object attempting to unset a thread default, in which case it’s truly harmless since all the thread defaults will already have been cleaned up. The resolution of this situation is to defer cleanup until the last possible moment, or in many scenarios to not call this function at all. See the PBUninitialize documentation for more information.

Message text: Paul Bunyan licensing information could not be updated. The key is invalid.

Remarks: This message is logged when an invalid license key is entered into the installer or setup application. A license key should be provided at the time of purchase. Contact Diamond Sierra if you have difficulties.

Message text: Paul Bunyan licensing information could not be updated. The key has expired.

Remarks: PB supports temporary licenses. This message is logged when an expired key has been provided to the installer or setup application. A license key should be provided at the time of purchase. Contact Diamond Sierra if you have difficulties.

Message text: Paul Bunyan licensing information could not be updated. The key is for an earlier version.

Remarks: This message will be logged when a key provided to the installer or setup application does not match the version being installed. In general, each major version will require a different key.

Message text: Setup failed: unable to access the registry: <Windows error string>

Remarks: Part of the installer's job is to establish values in the registration database. If registry cannot be accessed (e.g. setup is run from an account without permission to edit the registry), setup cannot continue.

Message text: Setup failed: invalid parameter: '<key name>' The path contains an invalid character.

Remarks: This error will be logged when a response file specifies a bad path or directory.

Message text: Setup failed: invalid parameter: '<key name>' The directory cannot be created.

Remarks: This error will be logged when a response file specifies a bad path or directory.

Message text: Setup failed: invalid parameter: '<key name>' The file cannot be created in the location specified.

Remarks: This error will be logged when a response file specifies a bad path or directory.

Message text: Paul Bunyan Setup supports the Windows NT, Windows 95, and Windows 98 operating systems. Please run setup on one of those platforms.

Remarks: An attempt will be made to log this error if setup is run from any OS other than those listed above.

Message text: Setup failed: the command line (<command string>) is invalid.

Remarks: The installer and setup application can be configured for automated installation. Any unrecognized options will cause setup to abort.

Message text: Setup failed: the command line (<command string>) is not supported by the setup application.

Remarks: The installer and the setup application support different command sets. See the topic automated installation for more information.

Message text: Setup failed: the command line (<command string>) is not supported by the installer.

Remarks: The installer and the setup application support different command sets. See the topic automated installation for more information.

Message text: Setup failed: invalid parameter '<key name>'.

Remarks: This error will be logged when a response file specifies an invalid value for a key. See Configuration Settings for a listing of valid parameter values. Note that key name "Application directory" is supported by the installer but not the setup application.

Message text: Setup failed: one or more parameters could not be interpreted.

Remarks: This error will be logged when a response file specifies an invalid key name.

Message text: The license number appears to be valid but newer than this version of setup.

Remarks: The license key used to unlock Paul Bunyan is tied to the release number. The key provided to setup must match the installed version.

Message text: Setup failed: <error string.> Please run setup again.

Remarks: This is a catch-all for exceptional conditions encountered during installation. The error string may come from Windows, or it may be specific to Paul Bunyan. If the error string does not provide enough information to fix the problem, contact technical support.

Message text: The current user does not have security access to install or remove the message server or to configure the start menu. It is recommended to run setup under an administrator account.

Remarks: On Windows NT, installation of a system service requires setup to be run under an account with sufficient permissions. Other portions of the installation process may not work correctly under a user account. It is recommended that setup always be run by an administrator. All installed components are available to all users.

Message text: The message viewer component requires version 4.70 or later of comctl32.dll. Since this machine has an earlier version, the viewer cannot be installed. This DLL can be upgraded by visiting Microsoft's web site.

Remarks: The message viewer will not function correctly unless this DLL is updated.

Message text: Setup was unable to configure Paul Bunyan as a system service: <Windows error string> This step will need to be performed manually.

Remarks: This message indicates that installation and registration of the message server component failed. If the problem persists, contact technical support.

Message text: Setup could not communicate properly with the Windows shell to add or remove shortcuts. You will have to add or remove shortcuts manually.

Remarks: This message indicates that setup could not create start menu shortcuts. On NT, this will most likely be caused by invalid permissions. Re-run setup from an administrator account.

Message text: Setup was unable to store licensing information, possibly because of invalid security permissions. If this problem persists, please contact technical support.

Remarks: The setup application writes licensing information to enforce copy protection. If the actual writing of this information fails, the product cannot function.

Message text: Setup is unable to determine an appropriate directory in which to install the message server. The message server component cannot be installed.

Remarks: Since the message server runs without a user logged on (and on NT runs under the system account), it cannot access network resources. The setup application will attempt to locate a fixed drive on which to install it. If no valid drive can be found, the message server component cannot be installed. The installation directory is normally read from the following registry key:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\ProgramFilesDir

Message text: The runtime features of the license key have expired.

Remarks: Runtime licenses, now known as Connectivity Licenses can be purchased on an annual basis. In this case, a license key will unlock a given edition as well as the connectivity features. When the connectivity features expire, the key will still be valid for unlocking the edition features. The connectivity features will be unavailable.

Message text: Silent setup succeeded!

Remarks: This message is logged to indicate a successful automated installation with the /S switch specified.

Message text: Silent setup succeeded! A system reboot is required to complete the installation.

Remarks: This message is logged when an automated installation with the /S switch specified needs to replace a file that is in use. The file will be replaced at the next system restart. Setup requires a reboot only in unusual scenarios, such as when the event viewer is open on previously logged messages from Paul Bunyan or when a message handler continues to run after the message server shuts down.