|Publication number||US8185876 B2|
|Application number||US 12/037,800|
|Publication date||May 22, 2012|
|Filing date||Feb 26, 2008|
|Priority date||Feb 26, 2008|
|Also published as||US20090217245|
|Publication number||037800, 12037800, US 8185876 B2, US 8185876B2, US-B2-8185876, US8185876 B2, US8185876B2|
|Inventors||Sreekanth Ramakrishna Iyer, Flavio Alvarenga Bergamaschi|
|Original Assignee||International Business Machines Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (12), Non-Patent Citations (6), Referenced by (1), Classifications (4), Legal Events (1)|
|External Links: USPTO, USPTO Assignment, Espacenet|
The present application relates to computer applications and more particularly to constructing of corrected Java™ native code.
Java™ Native Interface (JNI) is a standard programming interface for writing Java native methods and embedding the Java™ virtual machine into native applications. The JNI allows Java code that runs within a Java Virtual Machine (JVM) to operate with applications and libraries written in other languages, such as C, C++, and assembly. JNI also facilitates native code access to Java VM features by calling JNI functions. Thus JNI serves as the glue between Java and Native application and is a powerful feature, which will allow programmers to take advantage of the Java Platform as well as utilize code written in other languages.
Native language implementation may be preferred in the following scenarios: support for certain platform-dependent features for which Java does not provide an interface; interface to legacy code or implementation already available; situations that require loading the native library in the same process; substitution of Java™ code with lower level code gives a better performance for any time-critical application. Programmers mostly use JNI when an application needs to incorporate certain native level implementation.
While the Java™ programming language is type-safe and secure, native languages such as C or C++ are not. As a result, extra care is needed when writing applications using the JNI. A misbehaving native method can corrupt the entire application. The JNI does very little management; it mostly provides a vehicle for the code. For a programmer, Java™ Native Interface (JNI) methods are difficult to understand and implement.
There are several things that a JNI programmer must take care to produce correct JNI code. The programmer should guard the code against the common pitfalls and traps, which can affect performance and cause runtime failures. The following are the typical traps and pitfalls associated with JNI programming:
1. Error Checking—The most common mistake when writing native methods is forgetting to check whether an error condition has occurred. Unlike the Java™ programming language, native languages do not offer standard exception mechanisms. The JNI does not rely on any particular native exception mechanism (such as C++ exceptions). As a result, programmers are required to perform explicit checks after every JNI function call that could possibly raise an exception.
2. Using Java™ Objects—Java™ objects if used as they are in the native side may produce undesirable results and also can crash the Java Virtual Machine
3. Local and Global References—There are certain considerations required when a programmer uses local or global references to make good JNI code.
4. Freeing Native Resources—Failure to call Release* methods after use of resource acquired through Get* JNI methods, results in a memory leak which could ultimately lead to memory exhaustion.
5. Explicit Return—A pending exception thrown through the JNI does not automatically change control flow in native code. Instead, the programmer needs to issue an explicit return statement in order to skip the remaining statements in the C function.
6. String Manipulation—Differences in string representation when switching between UTF-8 and Unicode strings.
7. Concurrent Programming—There are certain constraints that one must keep in mind when writing native methods that are to run in a multithreaded environment. For instance, a JNIEnv pointer is only valid in the thread associated with it. The programmer must not pass this pointer from one thread to another or cache and use it in multiple threads.
Java Virtual Machine (JVM) implementations provide certain command-line options like Xcheck:jni and Xcheck:nabounds. These options instruct the virtual machine to detect and report many, albeit not all, cases of native code passing illegal arguments to JNI functions. The tool, however, warns against invalid arguments passed to the JNI functions at compile time and at runtime. The runtime checking slows down performance drastically. The implementation of the JNI specification and the JNI command-line options differ from vendor to vendor. For instance, the implementation of Java Objects, local and global references may differ between vendors. No tools are currently available for the developer community, which perform these checks based on the JVM and the JNI implementation.
Method and system for constructing corrected Java native code are provided. The method, in one aspect, may comprise analyzing a source file containing native source code interfacing with Java code, validating one or more inputs established in said native source code, and determining one or more checks to be performed on said native source code. Said one or more checks verify that the native source code correctly interfaces with the Java code. The method may also include performing said one or more checks and reporting one or more verification results from said one or more checks. The method is performed before said native source code is compiled for running on a processor or as a part of compiling said native source code.
A system for constructing corrected Java native code, in one aspect, may comprise a check tool operable to execute on a processor, the check tool further operable to receive a native source code interfacing with Java code and determine one or more checks to be performed. The checks verify that the native source code correctly interfaces with the Java code. The system may further include an error checker controller invoked by said check tool and the error checker controller is operable to execute on a processor and instantiate one or more error checker modules for performing said one or more checks. The system may also comprise a reporting module operable to execute on a processor and report one or more results of said one or more checks.
A program storage device readable by a machine, tangibly embodying a program of instructions executable by the machine to perform the above method steps may be also provided.
Further features as well as the structure and operation of various embodiments are described in detail below with reference to the accompanying drawings. In the drawings, like reference numbers indicate identical or functionally similar elements.
A method and system for constructing corrected Java™ native codes are provided. The method and system in one embodiment may include, based on the JVM implementation, statically analyzing the native code that used JNI APIs, validating the code against the JNI programming guidelines, and determining and presenting any pitfalls or traps to the developer. The method and system may be embodied as a tool that a programmer may use to discover and address many of the problems that may exist in the code at very early stage in the development cycle. The method and system provide an improvement over existing tools that detect the errors at runtime in production, which may be costly and difficult to debug.
JNI can be used to call native code in a library from a Java application as well as a native application can embed a JVM and invoke implementation in java code.
The tool embodying a method of the present disclosure in one embodiment performs the checks to avoid or mitigate the pitfalls and traps related to JNI. These checks are performed at step 108 shown in
Examples of performed checks include, but not limited to the following.
The tool embodying the method of the present disclosure in one embodiment critically examines the code to avoid the above pitfalls and traps in JNI that can lead to serious problems including virtual machine crash.
In one embodiment, the tool embodying the method of the present disclosure may be implemented as a plugin to a development environment such as Eclipse. The tool enables the developer, at any time during editing of a native file involving a JNI implementation, to make use of a menu or icon to initiate the JNI checker tool. Once the checks are completed they are displayed to the user as errors, warnings or information based, for example, on the severity of the errors. While the present disclosure was described in terms of JNI checks on native methods invoked from a Java application, the method of the present disclosure may also be used to validate the native method that invokes Java code. For instance, the method may be embodied in a tool which can be used as a plugin to interact with Java™ development environments such as the JDT (Java Development Toolkit).
Debugging a runtime failure involving native libraries can be tedious and difficult. It is even more complicated if the native library is a third party library and if tracing in that third party library code is not enabled. The method and system of the present application in one embodiment may prevent such run time failures or difficulties involved in debugging the failed code.
A tool embodying the method and/or system of the present disclosure may be delivered as a plugin, for example, to the Eclipse platform, which is becoming the preferred IDE (integrated development environment) by developers of Java™ Community. The tool may provide user friendly and improved exploitation of the JNI features, correctness of the code, and reduced runtime failures related incorrect JNI usage. The programmer need not worry about the steps involved and generation of glue code to get native code bind to the JNI interface. The tool may also keep the interest of programmers inclined to traditional languages such as C, C++ at the same time making integration of their work with Java easy and error free.
The system and method of the present disclosure may be implemented and run on a general-purpose computer or computer system. The computer system may be any type of known or will be known systems and may typically include a processor, memory device, a storage device, input/output devices, internal buses, and/or a communications interface for communicating with other computer systems in conjunction with communication hardware and software, etc.
The terms “computer system” and “computer network” as may be used in the present application may include a variety of combinations of fixed and/or portable computer hardware, software, peripherals, and storage devices. The computer system may include a plurality of individual components that are networked or otherwise linked to perform collaboratively, or may include one or more stand-alone components. The hardware and software components of the computer system of the present application may include and may be included within fixed and portable devices such as desktop, laptop, and server. A module may be a component of a device, software, program, or system that implements some “functionality”, which can be embodied as software, hardware, firmware, electronic circuitry, or etc.
The embodiments described above are illustrative examples and it should not be construed that the present invention is limited to these particular embodiments. Thus, various changes and modifications may be effected by one skilled in the art without departing from the spirit or scope of the invention as defined in the appended claims.
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US6066181 *||Dec 8, 1997||May 23, 2000||Analysis & Technology, Inc.||Java native interface code generator|
|US6282702||Aug 13, 1998||Aug 28, 2001||Sun Microsystems, Inc.||Method and apparatus of translating and executing native code in a virtual machine environment|
|US6411983 *||Apr 28, 1998||Jun 25, 2002||International Business Machines Corporation||Mechanism for managing the locking and unlocking of objects in Java|
|US6560774 *||Sep 1, 1999||May 6, 2003||Microsoft Corporation||Verifier to check intermediate language|
|US6662362||Jul 6, 2000||Dec 9, 2003||International Business Machines Corporation||Method and system for improving performance of applications that employ a cross-language interface|
|US6675371||Apr 30, 1999||Jan 6, 2004||Hewlett-Packard Development Company, L.P.||Java and native application window integration|
|US7150008||Apr 14, 2003||Dec 12, 2006||Microsoft Corporation||Non-invasive rule-based binary analysis of software assemblies|
|US7320129 *||May 14, 2003||Jan 15, 2008||Hewlett-Packard Development Company, L.P.||Native language verification system and method|
|US7437741 *||Mar 8, 2004||Oct 14, 2008||International Business Machines Corporation||Method, system, and program for invoking methods between computer languages|
|US7543271 *||Sep 8, 2003||Jun 2, 2009||Microsoft Corporation||Compiling source code using generic classes|
|US7870540 *||Jan 11, 2005||Jan 11, 2011||Microsoft Corporation||Dynamic object validation|
|US20040068735 *||Sep 16, 2003||Apr 8, 2004||York Justin E.||Java and native application window integration|
|1||*||Diagnostics Guide, Version 1.4.2, Copyright IBM Corp. 2003, 2006.|
|2||Florian Brandner et al., Short Presentation: Static Verification of Global Heap References in Java Native Libraries, pp. 1-6, Semantics, Program Analysis, and Computing Environments for Memory Management (SPACE), Jan. 2006, Charleston, South Carolina.|
|3||Linos et al., A Tool for Understanding Multi-language Program Dependencies, 11th IEEE International Workshop on Program Comprehension, May 10-11th 2003, Portland Oregon, USA. (http://www.iwpc2003.uvic.ca).|
|4||Michael Furr et al., Polymorphic Type Inference for the JNI, pp. 1-15, University of Maryland, College Park, Nov. 2005.|
|5||*||RD 452087 A Dec. 10, 2001 "Java native interface plumbing details hiding method, involves defining java native interface to be wrappered, and defining subset of Java native interface that needs to be accessed from mainline C++ code".|
|6||Robert Wenner, JNI Testing, pp. 1-15, Robert.firstname.lastname@example.org, Feb. 6, 2003.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US8959632 *||Mar 6, 2013||Feb 17, 2015||Google Inc.||Safely executing an untrusted native code module on a computing device|
|Feb 26, 2008||AS||Assignment|
Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:BERGAMASCHI, FLAVIO ALVARENGA;IYER, SREEKANTH RAMAKRISHNA;REEL/FRAME:020563/0905
Effective date: 20071204