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 the IBM 64-bit SDK for Linux on AMD64/EM64T architecture, Java 2 Technology Edition, Version 1.4.2.
© Copyright Sun Microsystems, Inc. 1997, 2003, 901 San Antonio Rd., Palo Alto, CA 94303 USA. All rights reserved.
© Copyright International Business Machines Corporation, 1999, 2008. All rights reserved.
U.S. Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
This User Guide describes the IBM® SDK (Software Developer Kit) for Linux® on AMD64/EM64T architecture.
The IBM SDK for Linux is a development environment for writing and running applets and applications that conform to the Sun Microsystems Java™ 1.4.2 Core Application Program Interface (API).
Read this User Guide if you want to use the SDK to write Sun Microsystems Java applications and applets or if you want to use the Runtime Environment to run them. The User Guide provides general information about the SDK and specific information about any differences in the IBM implementation of the SDK. 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.ibm.com/developerworks/java/jdk/linux/tested.html
Note that the SDK includes the Runtime Environment for Linux, which 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.
The SDK for Linux is a development environment for writing applets and applications that conform to Sun's Java 1.4.2 Core Application Programming Interface (API).
In general, any applet or application that runs in Version 1.1.8, 1.2.2 or 1.3.1 of the SDK should run correctly in this version.
There is no guarantee that v1.4.2-compiled classes work on pre-v1.4.0 SDK releases.
To read Sun's documentation on compatibility, see the Sun Web site at http://java.sun.com.
If you are upgrading the SDK from a previous release, back up all the configuration files and security policy files before you go ahead with the upgrade.
After the upgrade, you might have to restore or reconfigure these files because they might have been overwritten during the upgrade process. Check the syntax of the new files before restoring the original files because the format or options for the files might have changed.
The SDK contains several development tools and a Java Runtime Environment (JRE). This section describes the contents of the SDK tools and the Runtime Environment.
Applications written entirely in Java should have no dependencies on the IBM SDK's directory structure (or files in those directories). Any dependency on the SDK's directory structure (or the files in those directories) could result in application portability problems.
Earlier versions of the IBM JRE shipped with a file called rt.jar in the jre/lib directory. From Java v1.4 onwards, this file has been replaced by multiple JAR files that reside in the jre/lib directory. Examples of these JAR files are:
This change should be completely transparent to the application. If an error is received about a missing rt.jar file in CLASSPATH, this error points to a setting that was used in Java v1.1.8 and was made obsolete in subsequent versions of Java. You can safely remove references to rt.jar in CLASSPATH.
Note: The User Guides and the accompanying license, copyright files, and demo directory are the only documentation that is included in this SDK for Linux. You can view Sun's software documentation by visiting the Sun Web site, or you can download Sun's software documentation package from the Sun Web site: http://java.sun.com.
The following tools are not included in the IBM SDK:
From Version 1.4.2 Service Refresh 7, the IBM SDK for Java, v1.4.2 is also available in a JPackage compatible format.
To simplify managing the SDK, the various components of it are now available as separate RPMs: the base Java Runtime Environment, Development Kit, Plug-in, JDBC, Demo, Sound, Source, and Fonts. "jpackage-utils" RPM (downloadable from http://jpackage.org), which allows managing multiple Java RPMs on a system, is a prerequisite for the IBM SDKs. For more information about the JPackage specification, see http://jpackage.org.
If you install the SDK using JPackage, it will not be installed in the default location. See the "Directory Structure" section of the JPackage Java™ infrastructure design and packaging policy for details about the default JPackage installation location: http://www.jpackage.org/cgi-bin/viewvc.cgi/src/jpackage-utils/doc/jpackage-1.5-policy.xhtml?root=jpackage&view=co.
JPackage is not supported on SLES9 or SLES10 platforms.
For RHEL 4 and 5, the SDK depends on shared libraries that are not installed by default.
In RHEL 4, the RPMs that contain these libraries are:
To include these libraries during RHEL 4 installation:
In RHEL 5, the RPMs that contain these libraries are:
To include these libraries during RHEL 5 installation:
rpm -i /media/cdrom/Server/libXp-1.0.0-8.i386.rpm
To run the IBM SDK for Java on Red Hat Enterprise Linux Version 5 with SELinux enabled, Java must be installed in the default directory. If Java is not installed in the default directory, enter:
chcon -R -t texrel_shlib_t path_of_sdk
(Where path_of_sdk is the path where Java is installed).
For more information about SELinux, see http://www.redhat.com/magazine/006apr05/features/selinux/
After you install the SDK , edit your shell login script and add this directory to your PATH statement:
/opt/IBMJava2-amd64-142/bin
If you installed the SDK in a directory other than /opt/IBMJava2-amd64-142/, replace /opt/IBMJava2-amd64-142/ with the directory in which you installed the SDK .
The process that you use to remove the SDK for Linux 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.
To uninstall the SDK for Linux if you installed the installable RPM package:
rpm -e IBMJava2-AMD64-142-SDK-1.4.2-x.x
As an alternative to typing at a shell script, you can use a graphical tool such as kpackage or yast2
To uninstall the SDK for Linux if you installed the compressed TAR package:
The Java tools are programs that are run from a shell prompt; they do not have a Graphical User Interface (GUI).
The following sections give information about using the SDK for Linux.
To obtain the IBM build and version number, at a shell prompt type:
java -version
The Just-In-Time (JIT) compiler (libj9jit22.so) dynamically generates machine code for frequently used bytecode sequences in Java applications and applets while they are running.
The SDK for Linux includes the JIT, 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, use the -Xint option. At the shell prompt window where you run the application, type:
java -Xint class
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)
If the JIT is not in use, a message is displayed that includes:
(JIT disabled)
For more information about the JIT, see the Diagnostics Guide.
After installing the SDK for Linux, you can run a tool by typing its name at a shell prompt with a filename as an argument.
You can specify the path to a tool by typing the path before the name of the tool each time. For example, if the SDK for Linux software is installed in /opt/IBMJava2-amd64-142/bin, you can compile a file named myfile.java by typing the following at a shell prompt:
/opt/IBMJava2-amd64-142/bin/javac myfile.java
To avoid typing the full path each time:
javac myfile.java
The PATH environment variable enables Linux to find executable files, such as javac, java, and javadoc, from any current directory. To display the current value of your PATH, type the following at a shell prompt:
echo $PATH
To change the PATH environment variable:
The CLASSPATH tells the SDK tools, such as java, javac, and javadoc, where to find the Java class libraries. If you keep the bin and lib directories under the same parent directory level, the executable files can find the classes.
You need to set the CLASSPATH explicitly only if one of the following applies:
To display the current value of your CLASSPATH, type the following at a shell prompt:
echo $CLASSPATH
If you plan to develop and run applications that use different runtime environments, including other versions that you have installed separately, you must set the CLASSPATH (and PATH) explicitly for each application. If you plan to run multiple applications simultaneously and use different runtime environments, be sure that each application is run in its own shell.
If you want to run only one version of Java at a time, you can use a shell script to switch between the different runtime environments.
To debug Java programs, you can use the Java Debugger (JDB) application or other debuggers that communicate by using the Java Platform Debugger Architecture (JPDA) that is provided by the SDK for Linux.
The Java Debugger (JDB) is included in the SDK for Linux. The debugger is invoked by the jdb command; it "attaches" to the JVM using JPDA. To debug a Java application:
java -Xdebug -Xrunjdwp:transport=dt_socket,server=y, address=<port number> MyApplication <MyApplication args>
jdb -attach <port number>The debugger will attach to the JVM, and you can now issue a range of commands to examine and control the Java application, for example type "run" to allow the Java application to execute.
To find out more about JDB options, type:
jdb -help
To find out more about JDB commands:
You can also use JDB to debug remote Java applications:
jdb -attach <machine name or ip address>:<port number>
When you launch a debug session using the dt_socket transport, be sure that the specified ports are free to use.
The Java Virtual Machine Debugging Interface (JVMDI) is not supported.
For more information on JDB and JPDA and their usage see the following Web sites:
You can enable large page support, on systems that support it, by starting Java with the -Xlp option.
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). The TLB maps a larger virtual memory range and thus causes this improvement.
Large page support must be available in the kernel, and enabled, to allow Java to use large pages.
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: <number of pages> HugePages_Free: <number of pages> Hugepagesize: <page size, in kB
The number of pages available and their sizes vary between distributions.
If large page support is not available in your kernel, these lines will not exist in the /proc/meminfo file. In this case, you must install a new kernel containing support for large pages.
If large page support is available, but not enabled, HugePages_Total will be 0. In this case, your administrator must enable large page support. Check your operating system manual for more instructions.
For the JVM to use large pages, your system must have an adequate number of contiguous large pages available. If large pages cannot be allocated, even when enough pages are available, possibly the large pages are not contiguous. Configuring the number of large pages at bootup will create them contiguously.
Large page allocations will only succeed if the user is a member of the group whose gid is stored in /proc/sys/vm/hugetlb_chm_group, |or if Java is run with root access. See http://devresources.linux-foundation.org/dev/robustmutexes/src/fusyn.hg/Documentation/vm/hugetlbpage.txt for more information.
Valid JNI version numbers that native programs can specify on the JNI_CreateJavaVM() API call are:
This version number determines only the level of the JNI native interface to use. The actual level of the JVM that is created is specified by the J2SE libraries (that is, v1.4.2). The JNI 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. For further information see http://java.sun.com/j2se/1.4.2/docs/guide/jni.
Use the com.ibm.vm.bitmode system property to determine if you're running with a 32- or 64-bit JVM. An application that has two JNI libraries, one built for 32-bit and the other for 64-bit, can use this system property to operate with both 32- and 64-bit JVMs. At runtime the Java code can select which library to load based on the value of com.ibm.vm.bitmode.
To compile and link a native application with the IBM 1.4.2 SDK, use the following command:
gcc -I/opt/IBMJava2-amd64-142/include -L/opt/IBMJava2-amd64-142/jre/bin/j9vm -ljvm -ldl -lpthread <JNI program filename>
The -ljvm option specifies that libjvm.so is the shared library that implements the JVM. The -lpthread option indicates that you are using native pthread support; if you do not link with the pthread library, a segmentation fault (signal SIGSEGV) might be caused when you run the JNI program.
With the Applet Viewer, you can run one or more applets that are called by reference in a Web page (HTML file) by using the APPLET tag. The Applet Viewer finds the APPLET tags in the HTML file and runs the applets, in separate windows, as specified by the tags.
Because the Applet Viewer is for viewing applets, it cannot display a whole Web page that contains many HTML tags. It parses only the APPLET tags and no other HTML on the Web page.
To run an applet with the Applet Viewer, type the following at a shell prompt:
appletviewer name
where name is one of the following:
For example, to invoke the Applet Viewer on an HTML file that calls an applet, type at a shell prompt:
appletviewer $HOME/filename.html
where filename is the name of the HTML file.
For example, http://java.sun.com/applets/NervousText/example1.html is the URL of a Web page that calls an applet. To invoke the Applet Viewer on this Web page, type at a shell prompt:
appletviewer http://java.sun.com/applets/NervousText/example1.html
The Applet Viewer does not recognize the charset option of the <META> tag. If the file that appletviewer loads is not encoded as the system default, an I/O exception might occur. To avoid the exception, use the -encoding option when you run appletviewer. For example:
appletviewer -encoding JISAutoDetect sample.html
You can debug applets by using the -debug option of the Applet Viewer. When debugging applets, you are advised to invoke the Applet Viewer from the directory that contains the HTML file that calls the applet. For example:
cd demo/applets/TicTacToe ../../bin/appletviewer -debug example1.html
You can find documentation about how to debug applets using the Applet Viewer at the Sun Web site: http://java.sun.com.
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.
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.
The Java 2 Platform, Standard Edition (J2SE) supports, at a minimum, the specifications that are defined in the Official Specifications for CORBA support in J2SE V1.4 at http://java.sun.com/j2se/1.4.2/docs/api/org/omg/CORBA/doc-files/compliance.html. In some cases, the IBM J2SE ORB supports more recent versions of the specifications.
This SDK supports all versions of GIOP, as defined by chapters 13 and 15 of the CORBA 2.3.1 specification, OMG document formal/99-10-07, which you can obtain from:
http://www.omg.org/cgi-bin/doc?formal/99-10-07
Bidirectional GIOP is not supported.
This SDK supports Portable Interceptors, as defined by the OMG in the document ptc/01-03-04, which you can obtain from:
http://www.omg.org/cgi-bin/doc?ptc/01-09-58
Portable Interceptors are hooks into the ORB through which ORB services can intercept the normal flow of execution of the ORB.
This SDK supports the Interoperable Naming Service, as defined by the OMG in the document ptc/00-08-07, which you can obtain from:
http://www.omg.org/cgi-bin/doc?ptc/00-08-07
The default port that is used by the Transient Name Server (the tnameserv command), when no ORBInitialPort parameter is given, has changed from 900 to 2809, which is the port number that is registered with the IANA (Internet Assigned Number Authority) for a CORBA Naming Service. Programs that depend on this default might have to be updated to work with this version.
The initial context that is returned from the Transient Name Server is now an org.omg.CosNaming.NamingContextExt. Existing programs that narrow the reference to a context org.omg.CosNaming.NamingContext still work, and do not need to be recompiled.
The ORB supports the -ORBInitRef and -ORBDefaultInitRef parameters that are defined by the Interoperable Naming Service specification, and the ORB::string_to_object operation now supports the ObjectURL string formats (corbaloc: and corbaname:) that are defined by the Interoperable Naming Service specification.
The OMG specifies a method ORB::register_initial_reference to register a service with the Interoperable Naming Service. However, this method is not available in the Sun Java Core API at Version 1.4.2. Programs that need to register a service in the current version must invoke this method on the IBM internal ORB implementation class. For example, to register a service "MyService":
((com.ibm.CORBA.iiop.ORB)orb).register_initial_reference("MyService",
serviceRef);
where orb is an instance of org.omg.CORBA.ORB, which is returned from ORB.init(), and serviceRef is a CORBA Object, which is connected to the ORB.This mechanism is an interim one, and is not compatible with future versions or portable to non-IBM ORBs.
A runtime debug feature provides improved serviceability. You might find it useful for problem diagnosis or it might be requested by IBM service personnel. Tracing is controlled by three system properties.
For example, to trace events and formatted GIOP messages, type:
java -Dcom.ibm.CORBA.Debug=true -Dcom.ibm.CORBA.CommTrace=true myapp
Do not turn on tracing for normal operation, because it might cause performance degradation. Even if you have switched off tracing, FFDC (First Failure Data Capture) is still working, so that only serious errors are reported. If a debug output file is generated, examine it to check on the problem. For example, the server might have stopped without performing an ORB.shutdown().
The content and format of the trace output might vary from version to version.
The following properties help you to tune the ORB:
For example, to set the fragment size to 4096 bytes:
java -Dcom.ibm.CORBA.FragmentSize=4096 myapp
The default fragment size is 1024 bytes. You can turn off fragmentation by setting the fragment size to 0.
java -Dcom.ibm.CORBA.RequestTimeout=30
-Dcom.ibm.CORBA.LocateRequestTimeout=30 myapp
By default, the ORB waits indefinitely for a response. Do not set the timeout too low, or connections might be ended unnecessarily.
For example, to make the ORB use port 1050, type:
java -Dcom.ibm.CORBA.ListenerPort=1050 myapp
If this property is set, the ORB starts listening as soon as it is initialized. Otherwise, it starts listening only when required.
When running with a Java 2 SecurityManager, invocation of some methods in the CORBA API classes might cause permission checks to be made, which might result in a SecurityException. Affected methods include the following:
| Class/Interface | Method | Required permission |
|---|---|---|
|
org.omg.CORBA.ORB |
init |
java.net.SocketPermission resolve |
|
org.omg.CORBA.ORB |
connect |
java.net.SocketPermission listen |
|
org.omg.CORBA.ORB |
resolve_initial_references |
java.net.SocketPermission connect |
|
org.omg.CORBA. portable.ObjectImpl |
_is_a |
java.net.SocketPermission connect |
|
org.omg.CORBA. portable.ObjectImpl |
_non_existent |
java.net.SocketPermission connect |
|
org.omg.CORBA. portable.ObjectImpl |
OutputStream _request (String, boolean) |
java.net.SocketPermission connect |
|
org.omg.CORBA. portable.ObjectImpl |
_get_interface_def |
java.net.SocketPermission connect |
|
org.omg.CORBA. Request |
invoke |
java.net.SocketPermission connect |
|
org.omg.CORBA. Request |
send_deferred |
java.net.SocketPermission connect |
|
org.omg.CORBA. Request |
send_oneway |
java.net.SocketPermission connect |
|
javax.rmi. PortableRemoteObject |
narrow |
java.net.SocketPermission connect |
If your program uses any of these methods, ensure that it is granted the necessary permissions.
The ORB implementation classes in this release are:
These are the default values, and you are advised not to set these properties or refer to the implementation classes directly. For portability, make references only to the CORBA API classes, and not to the implementation. These values might be changed in future releases.
Java Remote Method Invocation (RMI) provides a simple mechanism to do distributed Java programming. RMI over IIOP (RMI-IIOP) uses the Common Object Request Broker Architecture (CORBA) standard Internet Inter-ORB Protocol (IIOP protocol) to extend the base Java RMI to perform communication. This allows direct interaction with any other CORBA Object Request Brokers (ORBs), whether they were implemented in Java or another programming language.
The following documentation is available:
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.
For more information, see the Sun Java site: http://java.sun.com.
From Service Refresh 8, the following new locale is added: Serbia (SE), with these three new locale variations:
The existing locale variations for the former Serbia and Montenegro are maintained as before. The 3-letter country code SRB, corresponding to the 2-letter country code RC, is also added.
The SDK includes an enhanced BigDecimal class (com.ibm.math.BigDecimal) for Java programming. It is provided (with its supporting class MathContext) as an alternative to the java.math.BigDecimal class.
The java.math.BigDecimal class provides a minimal, fixed-point, decimal arithmetic capability only. The com.ibm.math.BigDecimal class adds:
The com.ibm.math.BigDecimal class uses significantly fewer resources for common operations than the java.math.BigDecimal class.
The com.ibm.math.BigDecimal class is compatible with java.math.BigDecimal, and supports all of its methods. To use the com.ibm.math.BigDecimal class, change the import statement at the top of your .java file: import java.math,*; to import com.ibm.math.*;.
For more information see http://www.alphaworks.ibm.com/tech/bigdecimal.
The IBM SDK includes enhanced BiDirectional support. For more information, see http://www.ibm.com/developerworks/java/jdk/bidirectional/index.html.
The IBM SDK sets the Euro as the default currency for those countries in the European Monetary Union (EMU) for dates on or after 1 January, 2002. From 1 January, 2008, Cyprus and Malta also have the Euro as the default currency.
To use the old national currency, specify -Duser.variant=PREEURO on the Java command line.
If you are running the UK, Danish, or Swedish locales and want to use the Euro, specify -Duser.variant=EURO on the Java command line.
In V1.4.2 SR6, the default for the Slovenian locale is set to the Euro. If you install SR6 before 1 January 2007, you might want to change the currency to the Tolar.
The IBM SDK contains the XSLT4J 2.6 processor and the XML4J 4.3 parser that conform to the JAXP 1.2 specification. These tools allow you to parse and transform XML documents independently from any given XML processing implementation. By using "Factory Finders" to locate the SAXParserFactory, DocumentBuilderFactory and TransformerFactory implementations, your application can swap between different implementations without having to change any code.
The XSLT4J 2.6 processor allows you to choose between the original XSLT Interpretive processor or the new XSLT Compiling processor. The Interpretive processor is designed for tooling and debugging environments and supports the XSLT extension functions that are not supported by the XSLT Compiling processor. The XSLT Compiling processor is designed for high performance runtime environments; it generates a transformation engine, or translet, from an XSL stylesheet. This approach separates the interpretation of stylesheet instructions from their runtime application to XML data.
The XSLT Interpretive processor is the default processor. To select the XSLT Compiling processor you can:
To implement properties in the jaxp.properties file, copy jaxp.properties.sample to jaxp.properties in /opt/IBMJava2-amd64-142/jre/lib. This file also contains full details about the procedure used to determine which implementations to use for the TransformerFactory, SAXParserFactory, and the DocumentBuilderFactory.
To improve the performance when you transform a StreamSource object with the XSLT Compiling processor, specify the com.ibm.xslt4j.b2b2dtm.XSLTCB2BDTMManager class as the provider of the service org.apache.xalan.xsltc.dom.XSLTCDTMManager. To determine the service provider, try each step until you find org.apache.xalan.xsltc.dom.XSLTCDTMManager:
The XSLT Compiling processor detects the service provider for the org.apache.xalan.xsltc.dom.XSLTCDTMManager service when a javax.xml.transform.TransformerFactory object is created. Any javax.xml.transform.Transformer or javax.xml.transform.sax.TransformerHandler objects that are created by using that TransformerFactory object will use the same service provider. You can only change service providers by modifying one of the settings described above and then creating a new TransformerFactory object.
If you are using an older version of Tomcat, this limitation might apply.
If you are using an older version of Xerces or Xalan in the endorsed override, you might get a null pointer exception when you launch your application. This exception occurs because these older versions do not handle the jaxp.properties file correctly.
To avoid this situation, use one of the following workarounds:
set IBM_JAVA_OPTIONS=-Djavax.xml.parsers.SAXParserFactory= org.apache.xerces.jaxp.SAXParserFactoryImplor
set IBM_JAVA_OPTIONS=-Djavax.xml.parsers.DocumentBuilderFactory= org.apache.xerces.jaxp.DocumentBuilderFactoryImplor
set IBM_JAVA_OPTIONS=-Djavax.xml.transform.TransformerFactory= org.apache.xalan.processor.TransformerFactoryImpl
A Java application, unlike a Java applet, cannot rely on a Web browser for installation and runtime services. When you ship a Java application, your software package probably consists of the following parts:
To run your application, a user needs the Runtime Environment for Linux. The SDK for Linux software contains a Runtime Environment. However, you cannot assume that your users have the SDK for Linux software installed.
Your SDK for Linux software license does not allow you to redistribute any of the SDK's files with your application. You should ensure that a licensed version of the SDK for Linux is installed on the target machine.
If you are entitled to services for the Program code pursuant to the IBM Solutions Developer Program, contact the IBM Solutions Developer Program through your normal method of access or on the Web at: http://www.ibm.com/partnerworld/.
If you have purchased a service contract (that is, IBM's Personal Systems Support Line or equivalent service by country), the terms and conditions of that service contract determine what services, if any, you are entitled to receive with respect to the Program.
The User Guides that are supplied with this SDK and the Runtime Environment have been tested by using screen readers. You can use a screen reader such as the Home Page Reader or the JAWS screen reader with these User Guides.
To change the font sizes in the User Guides, use the function that is supplied with your browser, usually found under the View menu option.
For users who require keyboard navigation, a description of useful keystrokes for Swing applications is in "Swing Component Keystroke Assignments" at http://java.sun.com/j2se/1.4/docs/api/javax/swing/doc-files/Key-Index.html
The iKeyman tool has a GUI only; however, the IBM 64-bit SDK for Linux, v1.4.2 provides the command-line tool IKEYCMD, which has the same functions that iKeyman has. IKEYCMD allows you to manage keys, certificates, and certificate requests. You can call IKEYCMD from native shell scripts and from programs that are to be used when applications need to add custom interfaces to certificate and key management tasks. IKEYCMD can create key database files for all the types that iKeyman currently supports. IKEYCMD can also create certificate requests, import CA signed certificates, and manage self-signed certificates.
To run an IKEYCMD command, enter:
java [-Dikeycmd.properties=<properties file>]com.ibm.gsk.ikeyman.ikeycmd <object><action>[options]
where:
For more information, see the iKeyman User Guide at: http://www.ibm.com/developerworks/java/jdk/security/142/ikmuserguide.pdf.
If you have a Swing JMenu that has more entries than can be displayed on the screen, you can navigate through the menu items by using the down or up arrow keys.
If you traverse the drop-down list of a JComboBox component with the cursor keys, the button or editable field of the combo box does not change value until an item is selected. This is the desired behavior for this release and improves accessibility and usability by ensuring that the keyboard traversal behavior is consistent with mouse traversal behavior.
If you find a problem after you install the SDK for Linux, check the following list.
You will find more help with problem diagnosis in the IBM Diagnostics Guide, at http://www.ibm.com/developerworks/java/jdk/diagnosis/142.html.
java -verbose sun.applet.AppletViewer
The SDK is provided as is, with no support unless you are entitled by means of an IBM support contract. For information on known problems and FAQs, refer to: http://www.ibm.com/developerworks.
You can report problems to the ibm.software.java.linux news group. This news group is monitored, but solutions to specific reports are not guaranteed. The newsgroup is available from the news server news://news.software.ibm.com.
When you report a problem, provide the following information:
uname -a java -version
The following known limitations apply to the SDK and Runtime Environment for Linux.
The Node memory interleaving BIOS setting must be set to DISABLED. Otherwise, unpredictable results might occur, including Java crashes and hangs. This instruction is in accord with AMD's recommendation.
The maximum
number of threads available is determined by the minimum of:
However, you might run out of virtual storage before you reach the maximum number of threads.
xmodmap -pkThis 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"
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:
For license inquiries regarding double-byte (DBCS) information, contact the IBM Intellectual Property Department in your country or send inquiries, in writing, to:
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:
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.
IBM, developerWorks, iSeries, pSeries, AS/400, and PowerPC 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 are trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.
Linux is a trademark of Linus Torvalds in the United States, other countries, or both.
UNIX is a registered trademark of The Open Group in the United States and other countries.
Other company, product, or service names may be trademarks or service marks of others.
This product is also based in part on the work of the FreeType Project. For more information about Freetype, see http://www.freetype.org.
This product includes software developed by the Apache Software Foundation http://www.apache.org/.