Patent Application
20070226251
1. Field of the Invention
The present invention relates generally to relational database management systems (“RDBMS”) and more particularly to augment and control utility execution for the program product DB2 for z/OS, which is a RDBMS created by IBM.
2. Background of the Related Art
RDBMS generally include management utilities to assist the IT professional with the day to day arduous task of maintaining the integrity of the database and data contained therein. These tasks include loading a table, copying a table space, or recovering a database to a previous point in time to name a few. DB2 for z/OS is no different in this respect. IBM publishes a well-known reference and user manual for DB2 called the “DB2 Universal Database for z/OS Version 8: Utility Guide and Reference”, which is incorporated herein by reference, that describes all of the management utilities available in DB2.
In DB2, these management utilities come in two varieties—stand-alone utilities and online utilities. Online utilities may be invoked by a properly formatted utility control statement in a job control language (“JCL”) and may be run in batches with at least one separate utility being called sequentially. Online utilities may also be invoked by calling the DB2 supplied stored procedures DSNUTILS or DSNUTILU. Online utilities may also be invoked by calling the DSNUTILB program from any other program. Stand-alone utilities run independently of DB2. The online utilities require that DB2 is running.
Programming JCL commands and scripts is a tedious task, which is further complicated by the fact that any error in the JCL will cause the command or script to abort or malfunction. However, JCL is essential to automate many management tasks in DB2. Therefore, it would be advantageous to minimize the need to edit JCL commands and scripts to avoid the tedious task and prevent introduction of errors into the scripts.
One particularly important utility is the DSNUTILB program, which provides for batch processing of utility control statements to run a number of important utility functions to manage a DB2 RDBMS. DSNUTILB is a control program that processes utility control statements that result in the execution of a specific utility function or task. DB2 utilities can dynamically create object lists from a pattern-matching expression and can dynamically allocate the data sets required to process those objects.
Within a RDBMS that supports multiple simultaneous connections, applications may be running simultaneously on data contained in the RDBMS. Each of the application threads execute separately, but may share the same resources of the RDBMS. These applications can have a variety of functions and can be run by a variety of users including RDBMS users and/or administrators of the system. It is often the case that application processes block utility access to RDBMS resources. In order for the utility to continue processing, the application thread might need to be identified and terminated.
To reallocate resources effectively and terminate these application threads, system administrators often have to identify and terminate them by hand using RDBMS commands. This task can be time consuming and especially onerous. Accordingly, the prior art suffers from the disadvantage of having to manually manage and terminate multiple threads executing concurrently within a RDBMS environment.
To provide an ability to automate certain desired processes, such as the termination of application threads (which is often necessary because application threads may block access to RDBMS resources needed by a utility program), one encounters several disadvantages. One solution is to create a program and call it from a JCL script. This program, however, is a separate stand-alone program that must be called prior to the desired utility and does not intercept and preprocess the utility control statements. Because this program is a separate utility in and of itself, this solution necessarily involves rewriting the RDBMS' JCL scripts to include a call to this add-on program prior to the desired utility or as a call to the add-on program that passes the utility control statement as an argument. On a typical RDBMS system, there may be hundreds of thousands of lines of code in JCL scripts that would need to be edited to facilitate the inclusion of a separate add-on control module. Needless to say, this solution suffers from the disadvantage of being prohibitively expensive in time and cost to implement properly. Even if the time and effort are invested in the project, inevitably errors are introduced into the JCL scripts causing them to malfunction.
Therefore, it would be desirable and advantageous to have the ability to preprocess utility control statements prior to invocation of the utility program without regard to how the utility program is invoked. Additionally, there is also a need for an efficient and automated system for terminating threads to reallocate the computing resources of the RDBMS for critical utility functions.
Moreover, the task of managing a utility job stream in general is lacking in DB2 and other RDBMS. In particular, these systems lack the ability to customize the security settings, the ability to manage the execution of utilities, the ability to track and create an intelligible audit trail for administrative purposes, and the ability to further augment and control utility program execution.
The present invention provides a method of augmenting and controlling utility program execution for a RDBMS, like DB2. More specifically, the present invention solves the problems of the prior art by providing a method for intercepting the utility control statements and also by providing a control module for analyzing the utility control statements and taking actions, such as canceling threads, according to a user specified policy. Using a linkage editor, the control module is linked as the entry point into a utility processor module or control program from a load library of the RDBMS. The resulting load module may be stored in any library such that the modified utility program is loaded and executed when an attempt is made to execute the original utility program. The resulting load module may be stored in place of the original utility processor or control program in the RDBMS load library. When the utility module is executed, the control module receives initial control. As a result, utility control statements that are provided as input to the utility processor or control program may be read, parsed and subsequent actions performed.
Other useful functions that the present invention provides is the ability to provide a custom or augmented security layer that surrounds utility execution and the ability to manage the timing of execution of a series of utilities. Moreover, the present invention can provide an audit trail of the utility execution for purposes of diagnosing system problems, security flaws and other useful administrative purposes.
In the case of DB2, the control module can be relinked into the DSNUTILB control program and can be configured to cancel threads so that computing resources may be reallocated to the utility process designated in the utility control statement.
In particular, the method of the present invention of preprocessing utility control statements for a RDBMS first includes providing a control module for analyzing the utility control statements and taking actions according to a user specified policy. Next, using a linkage editor, the control module is relinked as the entry point into the utility processor or control program to form a modified utility load module. The modified utility load module replaces the utility load module in the load library of the RDBMS. When the utility processor or control program is executed, the control module gains control prior to invoking the utility function.
Accordingly, among the objects of the present invention is the provision for a method of relinking a control module as the entry-point into a utility processor or control program to provide for utility control statement preprocessing.
Another object of the present invention is the provision for a method of preprocessing utility control statements.
Yet, another object of the present invention is the provision for a method of automatically terminating conflicting application threads without the need for user intervention, thereby automating this once tedious and manual task.
Yet, another object of the present invention is the provision for a method for providing an augmented or custom layer of security around utility execution.
Another object of the present invention is the provision for a method of controlling the timing of utility execution.
Yet, another object of the present invention is the provision for a method to augment utility operation.
These and other features, aspects, and advantages of the present invention will become better understood with reference to the following description, appended claims, and accompanying drawings where:
Referring first to
Referring to
As shown in
The original exit point 28 of the DSNUTILB load module 11 returns program control, at step 44 described further below, to the control module 13 after the DSNUTILB load module 11 completes execution.
Referring now to
At step 39, the control module 13 of the present invention can include the ability to provide a custom security layer around utility program 11 execution. In particular, the control module 13 can provide for a user authentication scheme and a system-level policy control of categories of users and available actions. As can be appreciated, this enables the control module 13 to allow only certain authorized users to execute certain utilities thereby protecting the integrity of the RDBMS.
After performing the analysis, at step 36, of the command syntax and identifying, at step 38, the targets of the utility control statement, and optionally performing any security and/or authentication, at step 39, the control module 13 performs, at step 40, any necessary actions according to the user specified policy, including performing no action at all. In particular, the control module 13 can identify and cancel application threads, at step 40, in order to terminate conflicting application threads and also to free computing resources for the RDBMS to perform the actions requested in the utility control statement.
For instance, if the utility control statement is requesting that data be loaded into a particular table of the RDBMS, any threads accessing that particular table must be terminated prior to the load. Threads that are running utilities that are allowed to run concurrently with the designated action in the utility control statement may, of course, be allowed to run without being terminated. The important aspect of the present invention is that the control module 13 can identify and terminate these conflicting threads without user intervention. After the appropriate threads have been terminated, the control module 13 can invoke, at step 42, in
In addition to selectively cancelling threads, the control module 13 of the present invention can also control the timing of utility execution, at step 40. This can be done to allow execution of other critical functions to complete prior to execution of a utility program 11. Instead of cancelling a particular thread, the control module 13 can allow the thread to complete execution first prior to execution of the utility program 11. This feature is configurable according to the user level and system level policies that may be set as desired.
At step 41, the control module 13 can also provide an audit trail of utility execution that may include many parameters including user identification, when the utility was run, which utility was run (including input parameters), and the utility exit code, among others. The audit trail is useful for a number of purposes including debugging and security investigation to name a couple.
Although the method of the present invention has been described with respect to using the DSNUTILB load module of the DB2 RDBMS, other load modules may be used. Moreover, one skilled in the art would appreciate that the method of the present invention may be applied to other utility programs of other RDBMS to effect preprocessing of utility control statements therefor.
Therefore, it can be seen that the present invention provides a unique solution to the problem of avoiding changes to the invocation of the utility program by providing a control module that is linked into the utility load library of the RDBMS that intercepts and preprocesses the utility control statements prior to executing the desired utilities. The method of the present invention also enjoys the benefit of automating the tedious task of manually terminating conflicting threads for a RDBMS that supports multi-threaded operations.
It would be appreciated by those skilled in the art that various changes and modifications can be made to the illustrated embodiments without departing from the spirit of the present invention. All such modifications and changes are intended to be within the scope of the present invention except as limited by the scope of the appended claims.
