# IBM Runtime Environment for Linux platforms, Java 2 Technology Edition, Version 1.4.2

# User Guide

# Copyright information

Note: Before using this information and the product it supports, be sure to read the general information under Notices.

This edition of the User Guide applies to these platforms as they become available:

- IBM 32-bit Runtime Environment for Linux on Intel architecture, Java 2 Technology Edition, Version 1.4.2
- IBM 64-bit Runtime Environment for Linux on Intel Itanium(R) architecture, Java 2 Technology Edition, Version 1.4.2
- IBM 32-bit Runtime Environment for Linux on iSeries(TM) and pSeries(R), Java 2 Technology Edition, Version 1.4.2
- IBM 64-bit Runtime Environment for Linux on iSeries and pSeries, Java 2 Technology Edition, Version 1.4.2
- IBM 31-bit Runtime Environment for Linux on zSeries(R), Java 2 Technology Edition, Version 1.4.2
- IBM 64-bit Runtime Environment for Linux on zSeries, Java 2 Technology Edition, Version 1.4.2

and to all subsequent releases, modifications, and service refreshes, until otherwise indicated in new editions.

(c) Copyright Sun Microsystems, Inc. 1997, 2003, 901 San Antonio Rd., Palo Alto, CA 94303 USA. All rights reserved.

(c) Copyright International Business Machines Corporation, 1999, 2006. All rights reserved.

U.S. Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.

# Preface

This User Guide describes the IBM(R) Runtime Environment for all Linux platforms. Platform-specific information is clearly marked as such. Ensure that you are reading material relevant to your platform. In particular, Web Start and the Plug-in are specific to the 32-bit SDK for Linux on Intel(TM) architecture.

The IBM Runtime Environment contains the Java Virtual Machine (JVM), core Sun Microsystems Java classes, and supporting files. The Runtime Environment does not contain all the classes that are found in the SDK package.

The User Guide provides general information about the Runtime Environment and specific information about any differences in the IBM implementation of the Runtime Environment compared with the Sun implementation. Read this User Guide in conjunction with the more extensive documentation on the Sun Web site: http://java.sun.com.

The IBM JVM Diagnostics Guide provides more detailed information about the IBM JVM.

For the list of distributions against which the SDK for Linux has been tested, see: http://www-106.ibm.com/developerworks/java/jdk/linux/tested.html

Note that the Runtime Environment for Linux is a subset of the SDK and enables you only to run Java applications. If you have installed the SDK, the Runtime Environment is included.

The terms "Runtime Environment" and "Java Virtual Machine" are used interchangeably throughout this User Guide.

Technical changes made to this User Guide for Version 1.4.2, other than minor or obvious ones such as updating "1.4.1" to "1.4.2", are indicated in red when viewing in HTML or in a color-printed copy and by vertical bars to the left of the changes.

# Contents

Copyright information
Preface
Overview
| |
Conventions
Version compatibility
| |
Information for Linux PPC64 users
Files included with the Runtime Environment for Linux
License agreement
The just-in-time (JIT) compiler
The Java Native Interface and the Native Method Interface
| |
Installing on Red Hat Enterprise Linux (RHEL) 3 (zSeries only)
| |
Installing on Red Hat Enterprise Linux (RHEL) 4
Configuring the Runtime Environment for Linux
Uninstalling the Runtime Environment for Linux
Uninstalling the installable Red Hat Package Manager (RPM) package
Uninstalling the compressed Tape Archive (TAR) package
| |
JDBC/ODBC bridge reinstated
Launching a Java application
Summary of commands
Options
Standard options
Non-standard options
Globalization of the java command
Working with classpaths
| |
Configuring large page memory allocation
Working with the bootclasspath
Specifying garbage collection policy
Pause time
Pause time reduction
Environments with very full heaps
Further information about garbage collection
How the JVM processes signals
Signals used by the JVM
Linking a native code driver to the signal-chaining library
| |
Implementing the Connection Handler Pool for RMI
Obtaining the IBM build and version number
(Linux IA 32-bit only) Using the Java Plug-in
| |
Installing and configuring the Java Plug-in for Mozilla
| |
Installing and configuring the Java Plug-in for Firefox
| |
Installing and configuring the Java Plug-in for Netscape
| |
Locating JVM libraries for the browser Plug-in
Using DBCS parameters
(Linux IA 32-bit only) Using Web Start
Installing Web Start
Working with floating stacks
| |
(Linux IA 32-bit only) Preventing buffer overruns with NX/XD bit support
Switching the input method in DBCS languages
Installing your application on a user's system
Known limitations
Limitations that apply to all Linux platforms except where indicated
Linux IA 32-bit limitations
Linux PPC 32-bit and 64-bit limitations
Linux PPC 32-bit limitations
| |
Linux PPC 64-bit limitations
Linux zSeries 64-bit limitations
Linux zSeries 32-bit and 64-bit limitations
Any comments on this User Guide?
Notices
Trademarks

# Overview

The Runtime Environment for Linux contains the subset of classes that are required to create a Java runtime environment and to run Java programs. It also contains the Java Virtual Machine, Java classes, and supporting files. The Runtime Environment for Linux contains only a subset of the classes that are found in the SDK.

| | |

## Conventions

|

Throughout this User Guide the default installation directory of the SDK |is referred to as /opt/IBMJava2-142/. The platforms listed below have the following |default installation directories; use the appropriate directory |for your platform when you see /opt/IBMJava2-142/:

|

|
- Linux IA 32-bit: /opt/IBMJava2-142/
|
- Linux IA 64-bit: /opt/IBMJava2-142/
|
- Linux PPC 32-bit: /opt/IBMJava2-ppc-142/
|
- Linux PPC 64-bit: /opt/IBMJava2-ppc64-142/
|
- Linux zSeries 31-bit: /opt/IBMJava2-s390-142/
|
- Linux zSeries 64-bit: /opt/IBMJava2-s390x-142/

## Version compatibility

In general, any applet or application that runs in Version 1.1.8, 1.2.2 or 1.3.1 of the SDK for Linux should run correctly in this version. Applets that depend on Sun's Java 1.4.2 APIs work only on browsers that support Java 1.4.2 APIs.

There is no guarantee that 1.4.2-compiled classes work on pre-1.4.0 Runtime Environment releases.

| | |

### Information for Linux PPC64 users

|

Unlike PPC32, the Runtime Environment v1.4.2 is not supported on SLES 8.

## Files included with the Runtime Environment for Linux

The Runtime Environment for Linux includes non-debuggable .so files and class files that are needed to support a program at runtime. The Runtime Environment for Linux does not include any of the development tools, such as appletviewer or javac, or classes that would pertain only to a development system.

In addition, the Java Communications application programming interface (API) package is provided for use with the Runtime Environment for Linux. (Except on Linux IA 64-bit and Linux zSeries 31-bit and 64-bit).

## License agreement

The LICENSE_xx.html file contains the license agreement for the Runtime Environment for Linux software. (xx is an abbreviation for the language.)

To view or print the license agreement, open the file in a Web browser.

## The just-in-time (JIT) compiler

The just-in-time (JIT) compiler (libjitc.so) dynamically generates machine code for frequently used bytecode sequences in Java applications and applets while they are running.

The Runtime Environment for Linux includes the JIT (libjitc.so), which is enabled by default. You can disable the JIT to help isolate a problem with a Java application, an applet, or the compiler itself.

To disable the JIT, at a shell prompt in the window where you will run the application, type:

        export JAVA_COMPILER=NONE

To enable the JIT, type at a shell prompt:

        export JAVA_COMPILER=jitc

To verify whether or not the JIT is enabled, type at a shell prompt:

        java -version

If the JIT is in use, a message is displayed that includes:

    (JIT enabled: jitc)

If the JIT is not in use, a message is displayed that includes:

    (JIT disabled)

## The Java Native Interface and the Native Method Interface

The Java Native Interface (JNI) is included with the Runtime Environment. For information about using the JNI, see the Sun Web site: http://java.sun.com.

IBM does not support the Native Method Interface in this release. Do not use this interface in your applications.

| | |

# Installing on Red Hat Enterprise Linux (RHEL) 3 (zSeries only)

|

The zSeries 31-bit and 64-bit SDKs depend on shared libraries that are |not installed by default for Red Hat Enterprise Linux (RHEL) 3.0.

|

The RPM that contains these libraries is:

|

|
- `compat-libstdc++-7.2-2.95.3`

|

To include this library during RHEL 3 installation:

|

|
1. When you reach the Package Defaults screen, select Customize the set of packages to be installed.
|
2. At the Package Group Selection screen, under Development Options, select Legacy Software |Development.

| | |

# Installing on Red Hat Enterprise Linux (RHEL) 4

|

The SDK depends on shared libraries that are not installed by default for |Red Hat Enterprise Linux (RHEL) 4.0.

|

The RPMs that contain these libraries are:

|

|
- `compat-libstdc++-33-3.2.3` and `xorg-x11-deprecated-libs-6.8.1` (Intel Architecture, PPC, and PPC64)
|
- `compat-libstdc++-295-2.95.3` and `xorg-x11-deprecated-libs-6.8.1` (zSeries)

|

|If you are installing the SDK on 64-bit architecture, both |32- and 64-bit versions of the packages listed above are available. Make |sure that you install the correct version of the packages, either 32- or 64-bit. | The 64-bit versions of the packages are available in the Compatibility Arch Support package group.|

|

To include these libraries during RHEL 4 installation:

|

|
1. When you reach the Package Defaults screen, select Customize the set of packages to be installed.
|
2. At the Package Group Selection screen, under X Windows System, choose Details and |make sure that you have selected `xorg-x11-deprecated-libs`.
|
3. Under the Development options, select Legacy Software Development.

# Configuring the Runtime Environment for Linux

After you install the Runtime Environment for Linux, edit your shell login script and add this directory to your PATH statement:

/opt/IBMJava2-142/jre/bin

If you installed the Runtime Environment for Linux in a different directory, replace /opt/IBMJava2-142/ with the directory in which you installed the Runtime Environment.

Note:
(For Linux IA 32-bit Chinese users only) Because of inconsistencies in the font encodings on Red Hat Advanced Server, when you install for an environment in which you want Chinese to be the default language, it is better to install with a default language of English and then change to Chinese after the installation is complete. Otherwise, you might find that the Chinese fonts do not display.

# Uninstalling the Runtime Environment for Linux

The way you remove the Runtime Environment depends on whether you installed the installable Red Hat Package Manager (RPM) package or the compressed Tape Archive (TAR) package. See Uninstalling the installable Red Hat Package Manager (RPM) package or Uninstalling the compressed Tape Archive (TAR) package for instructions.

## Uninstalling the installable Red Hat Package Manager (RPM) package

To uninstall the Runtime Environment for Linux if you installed the installable RPM package:

1. At a shell script, type:

   -     |    rpm -e IBMJava2-JRE-1.4.2-x.x

   - For Linux PPC 32-bit:

         |rpm -e IBMJava2-142-ppc32-JRE-1.4.2-x.x

   - For Linux PPC 64-bit:

         |rpm -e IBMJava2-142-ppc64-JRE-1.4.2-x.x

   |(Where "x.x" indicates the Service Refresh |level: "5.0", for example.)

   As an alternative to typing at a shell script, you can use a graphical tool such as kpackage or yast2

2. Remove from your PATH statement the directory in which you installed the Runtime Environment.
3. (Linux IA 32-bit only) If you installed the Java Plug-in, remove the Java Plug-in files from the web browser directory.

## Uninstalling the compressed Tape Archive (TAR) package

To uninstall the Runtime Environment for Linux if you installed the compressed TAR package:

1. Remove the Runtime Environment files from the directory in which you installed the Runtime Environment.
2. Remove from your PATH statement the directory in which you installed the Runtime Environment.
3. (Linux IA 32-bit only) If you installed the Java Plug-in, remove the Java Plug-in files from the web browser directory.

| | |

# JDBC/ODBC bridge reinstated

|

The JDBC/ODBC bridge, which had been removed from the IBM SDK, v1.4.0, |has been reinstated for v1.4.2.

# Launching a Java application

The java tool launches a Java application.

The JVM searches for the startup class, and other classes that are used, in three sets of locations: the bootstrap classpath, the installed extensions, and the user classpath. Arguments after the class name or JAR file name are passed to the main function.

The javaw command is identical to java, except that javaw has no associated console window. Use javaw when you do not want a command prompt window to appear. The javaw launcher displays a dialog box with error information if a launch fails.

## Summary of commands

The java and javaw command have the following syntax:

    java [ options ] class [ arguments ... ]
    java [ options ] -jar file.jar [ arguments ... ]
    javaw [ options ] class [ arguments ... ]
    javaw [ options ] -jar file.jar [ arguments ... ]

Items that are within brackets are optional.

options
  Command-line options.
class
  Name of the class to invoke.
file.jar
  Name of the jar file to invoke. It is used only with -jar.
argument
  Argument passed to the main function.

If the -jar option is specified, the named .jar file contains class and resource files for the application, with the startup class indicated by the Main-Class manifest header.

From Version 1.4.2 Service Refresh 4, using the -jar command-line option will make the .jar file the source of all user classes; all other user CLASSPATH settings will be ignored.

To be able to use a .jar file with other CLASSPATH settings, add the .jar file to the CLASSPATH as above, and specify the startup class manually.

## Options

The launcher has a set of standard options that are supported on the current runtime environment and will be supported in future releases. In addition, there is a set of nonstandard options.

### Standard options

- -D<property_name>=<value>
  - Sets a system property.
- -assert
  - Prints help on assert-related options.
- -cp or -classpath <directories and zip or jar files separated by :>
  - Set search path for application classes and resources. If -classpath and -cp are not used, and CLASSPATH is not set, the user classpath is, by default, the current directory (.). Also see Working with classpaths.
- -help or -?
  - Prints a usage message.
- -showversion
  - Prints product version and continues.
- -verbose:[class | gc | jni]
  - Enables verbose output.
- -version
  - Prints product version.
- -X
  - Prints help on non-standard options.

### Non-standard options

The -X options listed below are a subset of the available ones. They are nonstandard and subject to change without notice.

- -Xargencoding
  - Allows the options on the java command to use Unicode escape sequences to represent characters that are not in the character set of the locale. Unicode escape sequences are of the form \u#### where # is a hexadecimal digit.
- -Xbootclasspath:<directories and zip or jar files separated by ;>
  - Sets search path for bootstrap classes and resources. There are other ways of setting the bootclasspath. See Working with the bootclasspath.
- -Xbootclasspath/a:<directories and zip or jar files separated by ;>
  - Appends to end of bootstrap class path.
- -Xbootclasspath/p:<directories and zip or jar files separated by ;>
  - Puts on the front of bootstrap class path. See Working with the bootclasspath.
- -Xcheck:jni
  - Performs additional checks for JNI functions.
- -Xcheck:nabounds
  - Performs additional checks for JNI array operations.
- |-Xdebug |
  |
  - Starts the JVM with the debugger enabled. Used with -Xrunjdwp. On PPC32 and PPC64, from Service Refresh 5, this option |starts the JVM using the alternative debug environment. (See the Diagnostics Guide at http://www-106.ibm.com/developerworks/java/jdk/diagnosis/.)
- -Xdisableexplicitgc
  - Changes calls to System.gc() into no-ops.
- -Xdisablejavadump
  - Disables the java dump facility for abnormal process termination. When the java dump is disabled, the system process termination dump is run. The java dump is useful when the problem occurs within the java code. If the problem is in system components, it might be more useful to get the normal system dump.
- -Xgcpolicy:{optthruput | optavgpause }
  - Specifies the garbage collection setting. The default setting is optthruput. For more information, see Specifying garbage collection policy.
- |-Xlp |
  |
  - Requests the JVM to allocate the Java heap (the heap from which Java objects |are allocated) with large pages, of which the size is in megabytes. If large |pages are not available, the Java heap is allocated with Linux's standard |pages, which are usually 4 KB in size. The JVM uses shmget() to allocate large |pages for the heap. Large pages are supported by systems running Linux kernels |V2.6 or higher.
- -Xms<size>
  - Sets initial Java heap size.
- -Xmx<size>
  - Sets maximum Java heap size.
- -Xnoclassgc
  - Disables class garbage collection.
- -Xoss<size>
  - Sets maximum Java stack size for any thread.
- |-Xpd |
  |
  - Loads the Problem Determination (PD) runtime libraries. Use this option |only when IBM service requests it. The PD libraries are for use under the |guidance of IBM Service. They are not shipped, so you would expect this option |to fail. |The -Xpd option must be |specified before any other parameter; if it is not placed first, the JVM might |report an `unrecognized option error`.| For more information |about the PD builds, see the Diagnostics Guide |for v1.4.2.
- -Xquickstart
  - Improves the startup time of applications. If you do not specify this option, the initial compilation of methods is done at high optmization (that is, the JIT does not recompile "hot" methods because the methods are initially compiled with high optimization).
- -Xrs
  - Reduces the use of operating system signals.
- -Xrun library_name[:options]
  - Loads helper libraries. To load multiple libraries, specify it more than once on the command line. Examples of these libraries are:
    - -Xrunhprof[:help] | [:<option>=<value>, ...]
      - Performs heap, CPU, or monitor profiling.
    - -Xrunjdwp[:help] | [:<option>=<value>, ...]
      - Loads debugging libraries to support the remote debugging of applications.
- -Xss<size>
  - Sets maximum native stack size for any thread. For more information, see Working with floating stacks.
- -Xverbosegclog:<path to file><filename>[X, Y]
  - Causes verboseGC output to be written to the specified file. If the file exists, it is overwritten. Otherwise, if an existing file cannot be opened or a new file cannot be created, the output is redirected to stderr.

    If you specify the arguments X and Y (both are integers), the verboseGC output is redirected to X number of files, each containing Y number of GC cycles worth of verboseGC output. |Filename must contain a "#" |(hash symbol), which is substituted with a generation identifier, starting |at 1. These files have the form filename1, filename2, and so on.

    Note:
    The environment variable IBM_JVM_ST_VERBOSEGC_LOG has been removed.
- -Xverify
  - Enables strictest checks, anticipating future default.

## Globalization of the java command

The java command and other java launcher commands (such as javaw) allow a class name to be specified as any character that is in the character set of the current locale.

You can specify any Unicode character in the class name and arguments by using java escape sequences. To do this, you must specify -Xargencoding. To specify a Unicode character, use escape sequences in the form `\u####`, where # is a hexadecimal digit (0 through 9, A through F).

To specify that the class name and command arguments are in UTF8 or ISO8859_1 encoding, use -Xargencoding:utf8 and -Xargencoding:latin.

In the Runtime Environment, if you are using a non-English locale, the java and javaw commands give translated output messages. These messages are different from those that were in the 1.3.1 version and also differ based on the locale in which Java is running. The detailed error descriptions and other debug information that is returned by java is in English. Debug information that is returned during initialization is shown in brackets.

## Working with classpaths

In the Runtime Environment, you can specify a class name as a complete file name including a full path and the .class extension. In previous versions of the SDK, you could specify only the class that was relative to the CLASSPATH, and the .class extension was not allowed. Use of the complete file name permits you to launch a java application from your desktop or file launcher. If you specify a .class file with path and extension, the specified path is put into the CLASSPATH. For example, the command `java ~/myapp/thisapp.class` is equivalent to specifying `java -classpath ~/myapp thisapp`.

From Version 1.4.2 Service Refresh 4, using the -jar command-line option will disable the use of a CLASSPATH.

| | |

## Configuring large page memory allocation

|

Large page usage is primarily intended to provide performance improvements |to applications that allocate a lot of memory and frequently access that memory. |The large page performance improvements are mainly caused by the reduced number |of misses in the Translation Lookaside Buffer (TLB). This improvement is caused |by the TLB mapping a larger virtual memory range.

|

To configure large page memory allocation, first ensure that the running |kernel supports large pages. Check that the file /proc/meminfo contains the |following lines:

|

    HugePages_Total:     4
    |HugePages_Free:      4
    |Hugepagesize:     4096 kB

Note that the values of these fields are system-dependent. |If the kernel does not support large pages, you must compile a new kernel |with large page support.

|

The amount of memory that you can allocate to large pages is given by the |product of `HugePages_Free * Hugepagesize`. The system administrator |should configure the number of large pages in the system to satisfy Java's |heap requirements. The system administator can configure the number of large |pages by editing the file /proc/sys/vm/nr_hugepages.

|

Sometimes, when the system has an adequate number of free large pages available, |the call to shmget() for large page memory allocation fails. This failure |occurs because the huge pages are not contiguous. To prevent this failure, | the system administrator must specify the `hugepages=<n>` option |at system bootup (rather than doing it later through /proc).

|

shmget(), which uses shmmax, allocates large page memory. To modify the |value of shmmax, edit the file /proc/sys/kernel/shmmax.

|

Note that shmget() succeeds only if it is being run by root. To use large |pages, you can either run Java as root or set the suid bit of the Java executable.

## Working with the bootclasspath

You can set the system property ibm.jvm.bootclasspath by using the -D option that is described in Launching a Java application. The value of this property is used as an additional search path, which is inserted between any value that is defined by -Xbootclasspath/p: and the bootstrap classpath. The bootstrap classpath is either the default, or that is defined using the -Xbootclasspath: option.

Do not deploy applications that use the -Xbootclasspath: or -Xbootclasspath/p: option to override a class in core.jar, graphics.jar, server.jar, security.jar, xml.jar, tools.jar, or charsets.jar, because such a deployment would contravene the Java 2 Runtime Environment binary code license.

## Specifying garbage collection policy

The -Xgcpolicy JVM runtime option specifies garbage collection policy.

-Xgcpolicy takes the values optthruput (the default) or optavgpause. The option controls garbage collector behavior, making tradeoffs between throughput of the application and overall system and the pause times that are caused by garbage collection.

The format of the option and its values is:

> -Xgcpolicy:optthruput

> -Xgcpolicy:optavgpause

### Pause time

When an application's attempt to create an object cannot be satisfied immediately from the available space in the heap, the garbage collector is responsible for identifying unreferenced objects (garbage), deleting them, and returning the heap to a state in which the immediate and subsequent allocation requests can be satisfied quickly. Such garbage collection cycles introduce occasional unexpected pauses in the execution of application code. Because applications grow in size and complexity, and heaps become correspondingly larger, this garbage collection pause time tends to grow in size and significance. The default garbage collection value, optthruput, delivers very high throughput to applications, but at the cost of these occasional pauses, which can vary from a few milliseconds to many seconds, depending on the size of the heap and the quantity of garbage.

### Pause time reduction

The optavgpause option substantially reduces the time that is spent in these garbage collection pauses, in addition to limiting the effect of increasing heap size on the length of the garbage collection pause. This option is particularly relevant to configurations that have large heaps. The pause times are reduced by performing some garbage collection activities that are concurrent with normal program execution. With the reduced pause time, you might experience some reduction of application throughput, which varies from application to application.

### Environments with very full heaps

If the Java heap becomes nearly full, and very little garbage is to be reclaimed, requests for new objects might not be satisfied quickly because no space is immediately available. If the heap is operated at near-full capacity, application performance might suffer regardless of which of the above options is used; and, if requests for more heap space continue to be made, the application receives an OutofMemory exception, which results in JVM termination if the exception is not caught and handled. At this point the JVM will produce two diagnostic files: a Heapdump and a Javadump. These are detailed in the Diagnostics Guide for Java v1.4.2 and can be used to determine what caused the high occupancy of the Java heap. The Diagnostics Guide is on developerWorks, at: http://www-106.ibm.com/developerworks/java/jdk/diagnosis/. In these conditions, you are recommended either to increase the heap size by using the -Xmx option, or to reduce the number of application objects in use.

### Further information about garbage collection

For more detailed information about garbage collection, see:

http://www.ibm.com/developerworks/ibm/library/i-garbage1/

http://www.ibm.com/developerworks/ibm/library/i-garbage2/

http://www.ibm.com/developerworks/ibm/library/i-garbage3/

# How the JVM processes signals

When a signal is raised that is of interest to the JVM, a signal handler is called. This signal handler determines whether it has been called for a Java or non-Java thread. If the signal is for a Java thread, the JVM takes control of the signal handling. If the signal is for a non-Java thread, and the application that installed the JVM had previously installed its own handler for the signal, control is given to that handler. Otherwise, the signal is ignored (whether or not this is not the signal's default action).

For exception and error signals the JVM either:

- Handles the condition and recovers (when the exception is caused by your application code), or
- Enters a controlled shutdown sequence where it:
  1. Calls your application's signal handler for that signal
  2. Outputs a Javadump, to describe the JVM state at the point of failure
  3. Calls any application-installed abort hook
  4. Performs the necessary cleanup to give a clean shutdown

For information about how to write a launcher that specifies the above hooks, see: http://www-106.ibm.com/developerworks/java/library/i-signalhandling/. This item was written for Java V1.3.1, but applies also to later versions.

For interrupt signals, the JVM also enters a controlled shutdown sequence, but this time it is treated as a normal termination that:

- Calls your application's signal handler for that signal
- Runs all application shutdown hooks
- Calls any application-installed exit hook
- Performs the necessary JVM cleanup

The shutdown is identical to the shutdown initiated by a call to the Java method `System.exit()`.

Other signals that are used by the JVM are for internal control purposes and do not cause it to terminate. The only control signal of interest is SIGQUIT, which causes a Javadump to be generated.

## Signals used by the JVM

Table 1 below shows the signals that are used by the JVM. The signals have been grouped in the table by type or use, as follows:

- Exceptions: The operating system synchronously raises an appropriate exception signal whenever a fatal condition occurs.
- Errors: The JVM raises a SIGABRT if it detects a condition from which it cannot recover.
- Interrupts: Interrupt signals are raised asynchronously, from outside a JVM process, to request shutdown.
- Controls: Other signals that are used by the JVM for control purposes.

Table 1. Signals used by the JVM
Signal Name | Signal type | Description | Disabled by -Xrs
--- | --- | --- | ---
SIGSEGV | Exception | Incorrect access to memory (write to inaccessible memory) | No
SIGILL | Exception | Illegal instruction (attempt to invoke an unknown machine instruction) | No
SIGFPE | Exception | Floating point exception (divide by zero) | No
SIGBUS | Exception | Bus error (attempt to address nonexistent memory location) | Yes
SIGSYS | Exception | Bad system call issued | Yes
SIGXCPU | Exception | CPU time limit exceeded (you have been running too long) | Yes
SIGXFSZ | Exception | File size limit exceeded | Yes
SIGABRT | Error | Abnormal termination. The JVM raises this signal whenever it detects a JVM fault. | Yes
SIGINT | Interrupt | Interactive attention (CTRL-C). JVM exits normally. | Yes
SIGTERM | Interrupt | Termination request. JVM will exit normally. | Yes
SIGHUP | Interrupt | Hang up. JVM exits normally. | Yes
SIGUSR1 | Control | User defined. Used by some JVMs for internal control purposes. | No
SIGUSR2 | Control | User defined. Used by some JVMs for internal control purposes. | No
SIGQUIT | Control | A quit signal for a terminal. JVM uses this for taking Javadumps. | Yes
SIGTRAP | Control | Internal for use by DBX or ptrace. Used by some JVMs for internal control purposes. | Yes
SIGPIPE | Control | A write to a pipe that is not being read. JVM ignores this. | No

Use the -Xrs (reduce signal usage) option to prevent the JVM from handling most signals. For more information, see Sun's Java application launcher page at http://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/java.html.

Signals `1 (SIGHUP)`, `2 (SIGINT)`, `4 (SIGILL)`, `6 (SIGABRT)`, `7 (SIGEMT)`, `8 (SIGFPE)`, `10 (SIGBUS)`, `11 (SIGSEGV)`, `12 (SIGSYS)`, `15 (SIGTERM)`, and `24 (SIGXCPU)` cause the JVM to shut down; therefore, an application signal handler must not attempt to recover from these unless it no longer requires the services of the JVM.

## Linking a native code driver to the signal-chaining library

The Runtime Environment contains a signal-chaining facility. Signal-chaining enables the JVM to interoperate more efficiently with native code that installs its own signal handlers.

The signal-chaining facility enables an application to link and load the shared library libjsig.so before the system libraries. The libjsig.so library ensures that calls such as `signal()`, `sigset()`, and `sigaction()` are intercepted so that their handlers do not replace the JVM's signal handlers. Instead, these calls save the new signal handlers, or "chain" them behind the handlers that are installed by the JVM. Later, when any of these signals are raised and found not to be targeted at the JVM, the preinstalled handlers are invoked.

To use libjsig.so:

- Link it with the application that creates or embeds a JVM:

      gcc -L$JAVA_HOME/bin -ljsig
      	-L$JAVA_HOME/bin/classic -ljvm java_application.c

  or
- Use the LD_PRELOAD environment variable:

      export LD_PRELOAD=$JAVA_HOME/bin/libjsig.so;
      		<java_application> (bash and ksh)

      setenv LD_PRELOAD=$JAVA_HOME/bin/libjsig.so;
      		<java_application> (csh)

  (Assuming that `JAVA_HOME` is set up; otherwise, use /opt/IBMJava2-142/jre.)

If you install signal handlers that use `sigaction()`, some sa_flags are not observed when the JVM uses the signal. These are:

- SA_NOCLDSTOP - This is always unset.
- SA_NOCLDWAIT - This is always unset.
- SA_RESTART - This is always set.
- SA_ONSTACK - This is always set (SIGSEGV only) for Linux IA and zSeries and is not set for Linux PPC.

The libjsig.so library also hides JVM signal handlers from the application. Therefore, calls such as `signal()`, `sigset()`, and `sigaction()` that are made after the JVM has started no longer return a reference to the JVM's signal handler, but instead return any handler that was installed before JVM startup.

| | |

# Implementing the Connection Handler Pool for RMI

|

Thread pooling for RMI Connection Handlers is not enabled |by default.

|

To enable the connection pooling implemented at the RMI TCPTransport level, |set the option

|

    -Dsun.rmi.transport.tcp.connectionPool=true (or any non-null value)

|

This version of the Runtime Environment does not have any setting that |you can use to limit the number of threads in the connection pool.

# Obtaining the IBM build and version number

To obtain the IBM build and version number, at a shell prompt type:

`java -version`

# (Linux IA 32-bit only) Using the Java Plug-in

The Java Plug-in is a Web browser plug-in. If you use the Java Plug-in, you can bypass your Web browser's default JVM and use instead a Runtime Environment for running applets or beans in the browser.

The Java Plug-in is documented by Sun at: http://java.sun.com/j2se/1.4.2/docs/guide/plugin/developer_guide/.

|The Java Plug-in is supported on Netscape |4, Netscape 6, and Mozilla 1.4, 1.6, and 1.8, as provided by default with |your distribution.

| | |

## Installing and configuring the Java Plug-in for |Mozilla

|

Mozilla 1.4 and later are compiled with gcc 3.x. So a gcc |3.x compatible version of the Java plugin must be used. From v1.4.2 onwards, |IBM SDK for Linux is being shipped with an additional gcc3 compiled plug-in |library (libjavaplugin_ojigcc3.so), to make the plug-in |compatible with the later updates of Mozilla browser.

|

To make the Java Plug-in available to all users:

|

|
1. Log in as root.
|
2. Change to your Mozilla plugins directory (this could be different on some |Linux distributions) . |

       cd /usr/local/mozilla/plugins/

|
3. Create a symbolic link to libjavaplugin_ojigcc3.so. |

       ln -s /opt/IBMJava2-142/jre/bin/libjavaplugin_ojigcc3.s .

| |
Note:
|
libjavaplugin_ojigcc3.so should |be symbolically linked instead of copied; otherwise, it will not be able to |find the location of the JVM.
|

For earlier versions of Mozilla (below 1.4),

|

To make the Java Plug-in available to all users:

|

|
1. Log in as root.
|
2. Change to your Mozilla plugins directory (this could be different on some |Linux distributions). |

       cd /usr/local/mozilla/plugins/

|
3. Create a symbolic link to libjavaplugin_oji.so. |

       ln -s /opt/IBMJava2-142/jre/bin/libjavaplugin_oji.s .

| |
Note:
|
libjavaplugin_oji.so should be |symbolically linked instead of copied; otherwise, it will not be able to find |the location of the JVM.
| | |

## Installing and configuring the Java Plug-in for |Firefox

|

To make the Java Plug-in available to all users:

|

|
1. Log in as root.
|
2. Change to your Firefox plugins directory (this could be different on some |Linux distributions) . |

       cd /usr/local/mozilla-firefox/plugins/

|
3. Create a symbolic link to libjavaplugin_ojigcc3.so. |

       ln -s /opt/IBMJava2-142/jre/bin/libjavaplugin_ojigcc3.s .

| |
Note:
|
libjavaplugin_ojigcc3.so should |be symbolically linked instead of copied; otherwise, it will not be able to |find the location of the JVM.
| | |

## Installing and configuring the Java Plug-in for |Netscape

|

To install and configure the Java Plug-in for Netscape 6, make a symbolic |link from the library file /opt/IBMJava2-142/jre/bin/javaplugin_oji.so to your browser's |plugins directory (/browser-install-path/plugins).

|

|
1. Log in as root.
|
2. Change to your Netscape plugins directory (this could be different on |some Linux distributions). |

       cd /usr/local/netscape/plugins/

|
3. Put a symbolic link to the javaplugin_oji.so into |the plugin directory. |

       ln -s /opt/IBMJava2-142/jre/bin/javaplugin_oji.so .

| |
Note:
|
javaplugin_oji.so should be symbolically |linked instead of copied; otherwise, it will not be able to find the location |of the JVM.
|

To install and configure the Java Plug-in for Netscape 4, make a symbolic |link from the library file /opt/IBMJava2-142/jre/bin/javaplugin.so to your browser's |plugins directory (/browser-install-path/plugins).

|

To make the Java Plug-in available to the current user:

|

|
1. Create a directory called plugins under the $HOME/.netscape directory |if it does not already exist.
|
2. Make a symbolic link from the library file /opt/IBMJava2-142/jre/bin/javaplugin.so |to /$HOME/.netscape/plugins.

|

To make the Java Plug-in available to all users:

|

|
1. Log in as root.
|
2. Put a symbolic link to the library file /opt/IBMJava2-142/jre/bin/javaplugin.so |into the plugin directory (usually /usr/local/netscape/plugins/, although |this might vary on some distributions). |

       ln -s /opt/IBMJava2-142/jre/bin/javaplugin.so \
       |   /usr/local/netscape/plugins/

| |
Note:
|
javaplugin.so should be symbolically |linked instead of copied; otherwise, it will not be able to find the location |of the JVM.
| | |

## Locating JVM libraries for the browser Plug-in

|

From Java 1.4.2 Service Refresh 6, you no longer need to set the LD_LIBRARY_PATH environment variable to use the browser Plug-in.

## Using DBCS parameters

The Java Plug-in supports double-byte characters (for example Chinese Traditional BIG-5, Korean, Japanese) as parameters for the tags `<APPLET>`, `<OBJECT>`, and `<EMBED>`. You must select the correct character encoding for your HTML document so that the Java Plug-in can parse the parameter. Specify character encoding for your HTML document by using the `<META>` tag in the `<HEAD>` section like this:

    <meta http-equiv="Content-Type" content="text/html; charset=big5">

This example tells the browser to use the Chinese BIG-5 character encoding to parse the HTML file using. All the parameters are passed to the Java Plug-in correctly. However, some of the older versions of browsers might not understand this tag correctly. In this case, you can force the browser to ignore this tag, but you might have to change the encoding manually.

You can specify which encoding you want to use to parse the HTML file:

- Netscape 4: View Menu -> Character Set
- Mozilla: View Menu -> Character Coding

# (Linux IA 32-bit only) Using Web Start

Java Web Start is a way of deploying Java technology-based applications. It connects the computer and the Internet and allows the user to launch and manage applications directly from the Web. Java Web Start provides one-click activation of applications, and ensures that you are always running the latest version, eliminating installation or upgrade procedures. Often, distributing software across the Web requires you to find the installer on the Web, download the installer, locate the installer, and execute the installer. After the installer is executed, it prompts for installation directories and installation options such as full, typical, or minimum. This can be a time-consuming and complicated task that must be repeated for each new version of the software.

In contrast, Web-deployed applications, such as your HTML-based e-mail client and calendar, are straightforward to install and use. The Web browser has automated the process. There are no complicated download, setup, and configuration steps, and you are guaranteed to be running the latest version. Java Web Start provides the same benefits to full-featured applications.

For more information about Web Start, see: http://java.sun.com/products/javawebstart and for more documentation, see: http://java.sun.com/j2se/1.4.2/docs/guide/jws/index.html.

## Installing Web Start

|Web Start is installed as part of the RPM installable |package. No separate Web Start installation script is provided. Web Start |is located in <java_home>/jre/javaws.

The installation process also updates the mime-types that are used by Mozilla and other browsers.

|You can invoke Web Start in three ways:

| |
- On a Web page, select a link that refers to a .jnlp file.
|
- Start /opt/IBMJava2-142/jre/javaws/javaws to |open the Web Start dialog from which you can select applications.
|
- Type `/opt/IBMJava2-142/jre/javaws/javaws <URL>`, where `<URL>` is the location of a .jnlp file.

All these actions cause Web Start to start the selected application. The application is downloaded if this is the first time it is being used. On later invocations, the original Web site is checked to see whether any updates are available. Web Start downloads these updates before the application is started.

If an error (such as an invalid tag name) occurs in a .jnlp file, Web Start fails without displaying an error message.

# Working with floating stacks

On a nonfloating stack Linux system, regardless of what is set for -Xss, a minimum native stack size of 256 KB for each thread is provided. On a floating stack Linux system, the -Xss values are honored. Therefore, if you are migrating from a non floating stack Linux system, you must ensure that any -Xss values are large enough and are not relying on a minimum of 256 KB.

(Linux IA 32-bit only) Particular Linux distributions - Red Hat, for example - have enabled a GLIBC feature called 'floating stacks'. Because of Linux kernel limitations, the JVM does not run on SMP hardware with floating stacks enabled if the kernel level is less than 2.4.10. In this environment, floating stacks must be disabled before the JVM, or any application that starts the JVM, is started. On Red Hat, use this command to disable floating stacks by exporting an environment variable:

    export LD_ASSUME_KERNEL=2.2.5

| | |

# (Linux IA 32-bit only) Preventing buffer overruns with NX/XD bit support

|

NX/XD is a security feature that prevents the exploitation of buffer overruns. |It changes the default access of memory regions to be non-executable. NX/XD |bit support for Linux IA32 running on IA32, IA64, and AMD64/EM64T processors |with RHEL3U3 and SLES9 is made available in Service Refresh 2 |of the IBM Version 1.4.2 Runtime Environment.

# Switching the input method in DBCS languages

On double-byte character set (DBCS) systems, if you want to switch the input method, you should use java.util.prefs.Preferences class instead of IBMJAVA_INPUTMETHOD_SWITCHKEY and IBMJAVA_INPUTMETHOD_SWITCHKEY_MODIFIERS environment variables. See Sun's Input Method Framework Specification in detail.

# Installing your application on a user's system

After you develop your product and are ready to ship, you need to install your product on a user's system, configure the user's system to support your software, and configure the runtime environment.

If you use the Runtime Environment for Linux, you must make sure that your installation procedure does not overwrite an existing installation (unless the existing Runtime Environment for Linux is an older version).

To redistribute the Runtime Environment for Linux, you can install it on your own system, then copy the required Runtime Environment files into your installation set. If you choose this approach, you must include all the files provided with the Runtime Environment for Linux. The Runtime Environment for Linux software can be redistributed only if all files are included. In effect, when you ship your application, it has its own copy of the Runtime Environment for Linux.

For specific information about the files that must be redistributed, see the license agreement that accompanies this product.

# Known limitations

The following sections explain known limitations of the Runtime Environment for Linux.

## Limitations that apply to all Linux platforms except where indicated

- |Your window manager might override some of the Java keyboard |shortcuts. If you need to use an overridden Java keyboard shortcut, consult |your operating system manual and change your window manager keyboard shortcuts. |
- You might not be able to use the system clipboard with double-byte character set (DBCS) to copy information between Linux applications and Java applications if you are running the K Desktop Environment (KDE).
- The SDK implements Java threads as native threads, which results in each thread being a separate Linux process. If the number of Java threads exceeds the maximum number of processes allowed, your program might get an error message, a SIGSEGV error, or your system might hang.

  The maximum number of threads available is determined by the minimum of:

  - The user processes setting (ulimit -u) in /etc/security/limits.conf
  - The limit that is defined in /proc/sys/kernel/threads_max
  - The limit PTHREAD_THREADS_MAX that is defined in libpthreads.so (change requires glibc to be recompiled)

  However, you might run out of virtual storage before you reach the maximum number of threads.

- If you terminated a Java application with a Ctrl-C, several processes might be left orphaned.
- An attempt to display dialog boxes that are created with Swing might cause a delay of a few seconds before those boxes are displayed in the window.
- KeyEvent results that include the ALT key differ between using different window managers in Linux. They also differ from results of other operating systems. In the Enlightenment window manager, Alt+A and Shift+Alt+A produce different modifiers, and Ctrl+Alt+A produces no key event at all. However, using the WindowMaker window manager, Ctrl+Alt+A produces a key event.
- On the Linux X Window System, the keymap is set to: 64 0xffe9 (Alt_L) 0xffe7 (Meta_L), and 113 0xffea (Alt_R) 0xffe8 (Meta_R). You can check this by typing the following at a shell prompt:

      xmodmap -pk

  This is why the SDK considers that Meta + Alt are being pressed together. As a workaround, you can remove the Meta_x mapping by typing the following at a shell prompt:

      xmodmap -e "keysym Alt_L = Alt_L" -e "keysym Alt_R = Alt_R"

  Note:
  This workaround might affect other X-Window applications that are running on the same display if they use the Meta-key that was removed.
- Creating DSA key pairs of unusual lengths can take a significant amount of time on slow machines. Do not interpret this delay as a hang because the process will complete if you allow enough time. The DSA key generation algorithm has been optimized to generate standard key lengths (for instance, 512, 1024) more quickly than others.
- Native programs cannot create a 1.1 JVM. You cannot call JNI_CreateJavaVM() and pass it a version of JNI_VERSION_1_1(0x00010001). The versions that can be passed are:
  - JNI_VERSION_1_2(0x00010002)
  - JNI_VERSION_1_4(0x00010004)

  The JVM created in every case is the one specified by the libraries (that is, 1.2.2, 1.3.x, 1.4.x), not the one that is implied by the JNI interface. The interface API does not affect the language specification that is implemented by the JVM, the class library APIs, or any other area of JVM behavior. The interface API specifies only how native code can invoke the required behavior.

- For users of Traditional Chinese only, function keys Enter, Space, Backspace, and ESC do not work as expected when using the LinYi ZhuYin, YiTian ZhuYin, and Bosham IMEs to input the TCH characters. The Enter key inserts a new line, the ESC key is used to cancel the preedit strings or the candidate window, and the Space bar inserts a space. The candidate window should disappear after the commit key has been pressed and it should not appear when you press the Backspace key while using the LinYi ZhuYin, YiTian ZhuYin, and Bosham IMEs to input the Traditional Chinese characters.
- If you are running with a lot of concurrent threads, you might get a warning message: `java.lang.OutOfMemoryError`. This is an indication that your machine is running out of system resources and messages can be caused by the following reasons:
  1. New threads cannot be created because:
     - The number of processes created exceeds your user limit.
     - Not enough system resources are available to create new threads. In this case, you might see also other Java exceptions, depending on what your application is running.
  2. Kernel memory is either running out or is fragmented. You can see corresponding Out of Memory kernel messages in /var/log/messages that have the killed process id.
  Try tuning your system to increase the corresponding system resources.
- During installation, if you have already installed an earlier version of this product that was distributed by Red Hat, the Red Hat Package Manager (RPM) will report that the IBM package is older than any versions of the product that Red Hat has distributed. This condition occurs because Red Hat adds to the RPM package a "serial number" that overrides the versioning scheme of the product in the package, and, by default, the RPM refuses to install a package that seems to be older than one already installed. The --oldpackage option of the rpm command enables you to install the new IBM package.
- In SDK Version 1.4.2, applications that run on symmetric multiprocessor machines (SMP) on SLES 8 perform better with a changed IBM JVM implementation of Java monitors. Because most applications will have either benefits or no change to performance, the new algorithm is now the default behavior. If, on the other hand, the new default setting reduces the performance of your JVM, you can restore the old algorithm by setting the environment variable: `export IBM_JVM_MONITOR_OLD=<any value>`.

  For more information, see the Diagnostics Guide for v1.4.2.

- When running a java awt/swing application on a Linux machine and exporting the display to a second machine, you might experience problems displaying some dialogs if the set of fonts loaded on the X client machine is different from the set loaded on the X server machine. This problem is noticeable particularly with SLES8 in Chinese locales, where the default installation of the server version installs arphic fonts, but the default installation of the client does not. To avoid this problem, install the same fonts on both machines.
- |If your system locale is using a UTF-8 encoding, some SDK |tools might throw a sun.io.MalformedInputException. To find out whether your |system is using a UTF-8 encoding, examine the locale-specific environment |variables such as LANG or LC_ALL to |see if they end with the suffix ".UTF-8". If you get this sun.io.MalformedInputException, |change characters that are not within the 7-bit ASCII range (0x00 - 0x7f) |and are not represented as Java Unicode character literals to Java Unicode |character literals (for example: '\u0080'). You can also work around this |problem by removing the ".UTF-8" suffix from the locale-specific environment |variables; for example, if your machine has default locale of "en_US.UTF-8", |set LANG to "en_US". | |
  Note:
  |
  Some distributions |of Red Hat, including Red Hat 9 and RHEL3, use UTF-8 encoding by default.
  |
  |
- |If you are using AMI and xcin in a cross-platform environment |(for example, if you try to export the display between a 32-bit and a 64-bit |system, or between a big-endian and a little-endian system) there might be |some problems. If you have this kind of problem, contact your Linux distributor. |
  |
- |On Red Hat Enterprise Linux 3.0, Chinese characters might |not be displayed in AWT text components except for GB2312 characters in the |Chinese GB18030 locale. |
  |
- |On SLES9, you might experience internationalization problems | with, for example: |
  |
  - Font displays.
  |
  - Input Method Engine (Canna might not work on Big Endian platforms).
  |
  - Locale data (SDK for PowerPC 64-bit might not work correctly because |of missing locale data)
  |

  If you see these problems, please contact SuSE.

| |
- (Linux IA 32-bit and zSeries only) Although the |SDK supports the Bengali (bn_IN), Kannada (kn_IN), Malayalam (ml_IN), Oriya |(or_IN), and Punjabi (pa_IN) locales, the fonts from these locales do not |work on AWT components. Also note that the fonts from these |locales are not present on the Linux operating system. |
  |

- |If |the Common UNIX Printing System (CUPS) is not installed on your system, print |jobs sent to the default printer might be directed to a different printer.

## Linux IA 32-bit limitations

- SLES 8 for Korean might not display Korean characters. To fix this, install the "baekmuk-ttf" rpm package and run `SUSEconfig`:

        # touch /usr/X11R6/lib/X11/fonts/truetype/fonts.scale.baekmuk
        # SUSEconfig

- For Arabic text users, when using Linux with a Matrox video card and acceleration enabled, distortion of characters can be seen when using drawString to display large fonts. This problem is caused by the driver for those cards. The suggested workaround is to disable acceleration for the device.
- |On SLES 9 NPTL, the parallel port driver |causes a kernel crash and brings down a Java thread. The JVM detects this |crash when it tries to suspend the thread for Garbage Collection and then |crashes producing a core file and the message "JVMLH030: threads are disappearing |when trying to suspend all threads". |

  SuSE Bugzilla report 47947 is raised |against this problem. This bug is fixed in SLES 9 Service Pack 1.

## Linux PPC 32-bit and 64-bit limitations

- If you are running XFree86 version 3.x, you might receive a SIGSEGV error. To avoid this problem, it is recommended that you use XFree86 version 4.x.
- If the date is set to a date before 1970, you get an exception error when you try to start Java. To work around this problem, manually set your machine to the current date.
- |The JavaComm package cannot support parallel port operations |on the SLES 9 GA and SP1 kernels. This limitation is resolved in the SP2 kernel. |The SuSE Bugzilla number is 50028. |
- |Because of an unimplemented IOCTL function in the 32-bit |mode of the 64-bit kernel, JavaComm cannot support serial port operations |on SLES 9 and RHEL 4. This limitation is resolved in SLES 9 SP2 (Bugzilla |number 49787) and RHEL 4 update 1 (Bugzilla number 144904). |

## Linux PPC 32-bit limitations

- The SLES 8.0 install CDs for PowerPC do not include adequate TrueType Chinese fonts for Java to display Chinese correctly. Install the ttf-hanyi-20021016-0.noarch.rpm package from United Linux 1.0 to improve the display of Chinese fonts.
- If your Java code uses JNI calls, and any specific call has more than eight float or double parameters, your C code must be compiled with the gcc-2.95.3 Free Software Foundation (FSF) level of GNU C Compiler (GCC).

| | |

## Linux PPC 64-bit limitations

|

|
- On Linux PPC 64-bit on SLES9, because of a known problem in the SLES9 |GA kernel, you are recommended to use SP1 to run the SDK. However, a workaround |is available for the SDK to run on the GA level of SLES9. Set the JITC_COMPILEOPT=NJVM_FASTPATH environment variable to avoid possible |hangs, particularly in security-related code

## Linux zSeries 64-bit limitations

The following limitations apply to users of Chinese, Taiwanese, and Korean on Linux zSeries 64-bit:

- The Chinese and Taiwanese input method server (xcin) has not been tested with Version 1.4.2.
- For users of Simplified Chinese only, some Chinese characters might not be displayed. To avoid the problem, download the following TrueType font onto SLES8 for your zSeries 64-bit system:
  - ttf-hanyi-20021016-0
  The font is available from the SuSE Web site at: http://www.suse.com/index_us.html.
- For users of Traditional Chinese only, some Chinese characters might not be displayed. To avoid the problem, download the following TrueType fonts onto SLES8, which works as a graphical client:
  - ttf-arphic-bkai00mp-20001125-103
  - ttf-arphic-gbsn00lp-20001125-103
  - ttf-arphic-gkai00mp-20001125-103
  - ttf-arphic-bsmi00lp-20001125-103
  - ttf-arphic-20001125-323
  The fonts are available from the SuSE web site at: http://www.suse.com/index_us.html.

## Linux zSeries 32-bit and 64-bit limitations

- If you use audio on a machine without a sound card, you might get an error message stating that you are out of memory when Java tries to play a sound. The message is displayed in the console, but it does not affect your Java application.
- Although the Linux kernel in the current distributions provides support for Internet Protocol version 6 (IP6), you might encounter problems using it. Support for IP6 from Java is included in this release, but you are advised to turn off the support with the -Djava.net.preferIPv4Stack=true option on the Java command. If you install a kernel that fully supports IP6, you do not need this option.

# Any comments on this User Guide?

If you have any comments about the usefulness, or otherwise, of this User Guide, we would be pleased to hear from you through one of these channels. Please note that these channels are not set up to answer technical queries, but are for comments about the documentation only. Send your comments:

- By e-mail to idrcf@hursley.ibm.com.
- By fax:
  - From the UK: 01962 842327
  - From elsewhere:<international code>44 1962 842327
- By mail to:
  IBM United Kingdom Ltd
  User Technologies,
  Mail Point 095
  Hursley Park
  Winchester
  Hampshire
  SO21 2JN United Kingdom

The fine print. By choosing to send a message to IBM, you acknowledge that all information contained in your message, including feedback data, such as questions, comments, suggestions, or the like, shall be deemed to be non-confidential and IBM shall have no obligation of any kind with respect to such information and shall be free to reproduce, use, disclose, and distribute the information to others without limitation. Further, IBM shall be free to use any ideas, concepts, know-how or techniques contained in such information for any purpose whatsoever, including, but not limited to, developing, manufacturing and marketing products incorporating such information.

# Notices

This information was developed for products and services offered in the U.S.A. IBM may not offer the products, services, or features discussed in this document in other countries. Consult your local IBM representative for information on the products and services currently available in your area. Any reference to an IBM product, program, or service is not intended to state or imply that only that IBM product, program, or service may be used. Any functionally equivalent product, program, or service that does not infringe any IBM intellectual property right may be used instead. However, it is the user's responsibility to evaluate and verify the operation of any non-IBM product, program, or service.

IBM may have patents or pending patent applications covering subject matter in this document. The furnishing of this document does not give you any license to these patents. You can send license inquiries, in writing, to:

- IBM Director of Licensing
  IBM Corporation
  North Castle Drive, Armonk
  NY 10504-1758 U.S.A.

For license inquiries regarding double-byte (DBCS) information, contact the IBM Intellectual Property Department in your country or send inquiries, in writing, to:

- IBM World Trade Asia Corporation Licensing
  2-31 Roppongi 3-chome, Minato-ku
  Tokyo 106-0032, Japan

The following paragraph does not apply to the United Kingdom or any other country where such provisions are inconsistent with local law:

INTERNATIONAL BUSINESS MACHINES CORPORATION PROVIDES THIS PUBLICATION "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Some states do not allow disclaimer of express or implied warranties in certain transactions, therefore, this statement may not apply to you.

This information could include technical inaccuracies or typographical errors. Changes are periodically made to the information herein; these changes will be incorporated in new editions of the information. IBM may make improvements and/or changes in the product(s) and/or the program(s) described in this information at any time without notice.

Any references in this information to non-IBM Web sites are provided for convenience only and do not in any manner serve as an endorsement of those Web sites. The materials at those Web sites are not part of the materials for this IBM product and use of those Web sites is at your own risk.

IBM may use or distribute any of the information you supply in any way it believes appropriate without incurring any obligation to you.

Licensees of this program who wish to have information about it for the purpose of enabling (i) the exchange of information between independently created programs and other programs (including this one) and (ii) the mutual use of the information which has been exchanged, should contact:

- JIMMAIL@uk.ibm.com
  [Hursley Java Technology Center (JTC) contact]

Such information may be available, subject to appropriate terms and conditions, including in some cases, payment of a fee.

The licensed program described in this document and all licensed material available for it are provided by IBM under terms of the IBM Customer Agreement, IBM International Program License Agreement or any equivalent agreement between us.

Any performance data contained herein was determined in a controlled environment. Therefore, the results obtained in other operating environments may vary significantly. Some measurements may have been made on development-level systems and there is no guarantee that these measurements will be the same on generally available systems. Furthermore, some measurement may have been estimated through extrapolation. Actual results may vary. Users of this document should verify the applicable data for their specific environment.

Information concerning non-IBM products was obtained from the suppliers of those products, their published announcements or other publicly available sources. IBM has not tested those products and cannot confirm the accuracy of performance, compatibility or any other claims related to non-IBM products. Questions on the capabilities of non-IBM products should be addressed to the suppliers of those products.

## Trademarks

IBM, iSeries, pSeries, and zSeries are trademarks or registered trademarks of International Business Machines Corporation in the United States, or other countries, or both.

Java and all Java-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.

Other company, product, or service names may be trademarks or service marks of others.

This product includes software developed by the Apache Software Foundation http://www.apache.org/.